func prettyPrint(w io.Writer, v interface{}) {
if v == nil {
return
}
f := strutil.IndentFormatter(w, "· ")
defer func() {
if e := recover(); e != nil {
f.Format("\npanic: %v", e)
}
}()
prettyPrint0(nil, f, "", "", v)
}
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 prettyPrint0(protect map[interface{}]struct{}, sf strutil.Formatter, prefix, suffix string, v interface{}) {
if v == nil {
return
}
switch x := v.(type) {
case *Token:
if x == nil {
return
}
sf.Format("%s%v"+suffix, prefix, x.String())
return
}
rt := reflect.TypeOf(v)
rv := reflect.ValueOf(v)
switch rt.Kind() {
case reflect.Slice:
if rv.Len() == 0 {
return
}
sf.Format("%s[]%T{ // len %d%i\n", prefix, rv.Index(0).Interface(), rv.Len())
for i := 0; i < rv.Len(); i++ {
prettyPrint0(protect, sf, fmt.Sprintf("%d: ", i), ",\n", rv.Index(i).Interface())
}
sf.Format("%u}" + suffix)
case reflect.Struct:
sf.Format("%s%T{%i\n", prefix, v)
for i := 0; i < rt.NumField(); i++ {
f := rv.Field(i)
if !f.CanInterface() {
continue
}
prettyPrint0(protect, sf, fmt.Sprintf("%s: ", rt.Field(i).Name), ",\n", f.Interface())
}
sf.Format("%u}" + suffix)
case reflect.Ptr:
if rv.IsNil() {
return
}
rvi := rv.Interface()
if _, ok := protect[rvi]; ok {
sf.Format("%s&%T{ /* recursive/repetitive pointee not shown */ }"+suffix, prefix, rv.Elem().Interface())
return
}
if protect == nil {
protect = map[interface{}]struct{}{}
}
protect[rvi] = struct{}{}
prettyPrint0(protect, sf, prefix+"&", suffix, rv.Elem().Interface())
case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int8:
if v := rv.Int(); v != 0 {
sf.Format("%s%v"+suffix, prefix, v)
}
case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint8:
if v := rv.Uint(); v != 0 {
sf.Format("%s%v"+suffix, prefix, rv.Uint())
}
case reflect.Bool:
if v := rv.Bool(); v {
sf.Format("%s%v"+suffix, prefix, rv.Bool())
}
case reflect.String:
s := rv.Interface().(string)
if s == "" {
return
}
sf.Format("%s%q"+suffix, prefix, s)
case reflect.Map:
keys := rv.MapKeys()
if len(keys) == 0 {
return
}
var buf bytes.Buffer
nf := strutil.IndentFormatter(&buf, "· ")
var skeys []string
for i, k := range keys {
prettyPrint0(protect, nf, "", "", k.Interface())
skeys = append(skeys, fmt.Sprintf("%s%10d", buf.Bytes(), i))
}
sort.Strings(skeys)
sf.Format("%s%T{%i\n", prefix, v)
for _, k := range skeys {
si := strings.TrimSpace(k[len(k)-10:])
k = k[:len(k)-10]
n, _ := strconv.ParseUint(si, 10, 64)
mv := rv.MapIndex(keys[n])
prettyPrint0(protect, sf, fmt.Sprintf("%s: ", k), ",\n", mv.Interface())
}
sf.Format("%u}" + suffix)
default:
panic(fmt.Sprintf("prettyPrint: missing support for reflect.Kind == %v", rt.Kind()))
}
}
func main1(fn, gn string) (err error) {
b, err := ioutil.ReadFile(fn)
if err != nil {
return err
}
if len(b) == 0 {
return fmt.Errorf("empty input examples file")
}
b = b[:len(b)-1] // Strip trailing new line.
f0, err := os.Create(gn)
if err != nil {
return err
}
defer func() {
if e := f0.Close(); e != nil && err == nil {
err = e
}
}()
f := strutil.IndentFormatter(f0, "\t")
f.Format(`// Copyright 2015 The parser Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// CAUTION: Generated file - DO NOT EDIT!
package parser
import (
"fmt"
)
`)
for _, r := range strutil.SplitFields(string(b), "\n") {
flds := strutil.SplitFields(r, "|")
rn, err := strconv.Atoi(flds[0])
if err != nil {
return err
}
nm := flds[1]
isNil := flds[2] == "nil"
src := flds[3] // raw
if src == "" {
a := make([]string, len(flds)-4)
var s string
lit := 0
for i, tok := range flds[4:] {
switch x, ok := static[tok]; {
case ok:
s = x
default:
switch tok {
case "C_IDENTIFIER":
s = fmt.Sprintf("%c:\n", lit+'a')
lit++
case "IDENTIFIER":
s = fmt.Sprintf("\n\t%c", lit+'a')
lit++
case "NUMBER":
s = fmt.Sprintf("%d", lit)
lit++
case "STRING_LITERAL":
s = fmt.Sprintf(`"@%c"`, lit+'a')
lit++
default:
if tok[0] == '\'' {
if s, err = strconv.Unquote(tok); err != nil {
return fmt.Errorf("%v: %q", err, tok)
}
break
}
return fmt.Errorf("unsupported token %q", tok)
}
}
if s != "" {
a[i] = s
}
}
src = strings.Join(a, " ")
src = strings.Replace(src, "\n\n\n", "\n\n", -1)
a = strings.Split(src, "\n")
for i, v := range a {
a[i] = strings.Trim(v, " ")
}
src = "\n" + strings.TrimSpace(strings.Join(a, "\n")) + "\n"
}
f.Format("\nfunc %s() {%i\n", nm)
switch {
case isNil:
typ := strings.Split(nm[len("Example"):], "_")[0]
f.Format("fmt.Println(exampleAST(%d, %u`\n%s\n`%i) == (*%s)(nil))\n", rn, src, typ)
f.Format(`// Output:
// true
`)
default:
f.Format("fmt.Println(exampleAST(%d, %u`\n%s\n`%i))\n", rn, src)
f.Format("// Output:\n")
}
f.Format("%u}\n")
}
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")
}
}