154 lines
3.1 KiB
Go
154 lines
3.1 KiB
Go
package main
|
|
|
|
import (
|
|
"log"
|
|
"go/ast"
|
|
"go/format"
|
|
"go/parser"
|
|
"go/token"
|
|
"golang.org/x/tools/go/ast/astutil"
|
|
"os"
|
|
"regexp"
|
|
)
|
|
|
|
type subspec struct {
|
|
r *regexp.Regexp
|
|
s string
|
|
}
|
|
|
|
var (
|
|
firstone bool
|
|
gfset *token.FileSet
|
|
fspec, tspec, nspec subspec
|
|
ntspecs []subspec
|
|
nodes *ast.File
|
|
)
|
|
|
|
type gvisit struct{}
|
|
|
|
func subs(dst *string, specs []subspec) {
|
|
for _,spec := range(specs) {
|
|
sub(dst,spec)
|
|
}
|
|
}
|
|
|
|
func sub(dst *string,spec subspec) {
|
|
if spec.r.MatchString(*dst) {
|
|
*dst = spec.r.ReplaceAllString(*dst,spec.s)
|
|
}
|
|
}
|
|
|
|
func (v *gvisit) Visit(node ast.Node) ast.Visitor {
|
|
switch n := node.(type) {
|
|
case *ast.Ident:
|
|
if n.Obj != nil && n.Obj.Kind == ast.Typ {
|
|
subs(&n.Name,ntspecs)
|
|
subs(&n.Obj.Name,ntspecs)
|
|
}
|
|
case *ast.TypeSwitchStmt:
|
|
for _,s := range(n.Body.List) {
|
|
cs, ok := s.(*ast.CaseClause); if !ok { continue }
|
|
for _,c := range(cs.List) {
|
|
ci, ok := c.(*ast.Ident); if !ok { continue }
|
|
subs(&ci.Name,ntspecs)
|
|
}
|
|
}
|
|
case *ast.TypeAssertExpr:
|
|
nt, ok := n.Type.(*ast.Ident); if !ok { return v }
|
|
subs(&nt.Name,ntspecs)
|
|
case *ast.Ellipsis:
|
|
nt, ok := n.Elt.(*ast.Ident); if !ok { return v }
|
|
subs(&nt.Name,ntspecs)
|
|
case *ast.Field:
|
|
nt, ok := n.Type.(*ast.Ident); if !ok { return v }
|
|
subs(&nt.Name,ntspecs)
|
|
case *ast.StarExpr:
|
|
nt, ok := n.X.(*ast.Ident); if !ok { return v }
|
|
subs(&nt.Name,ntspecs)
|
|
case *ast.TypeSpec:
|
|
//ast.Print(gfset,n)
|
|
case *ast.ValueSpec:
|
|
nt, ok := n.Type.(*ast.Ident); if !ok { return v }
|
|
subs(&nt.Name,ntspecs)
|
|
case *ast.ArrayType:
|
|
nt, ok := n.Elt.(*ast.Ident); if !ok { return v }
|
|
subs(&nt.Name,ntspecs)
|
|
case *ast.MapType:
|
|
nt, ok := n.Key.(*ast.Ident); if ok {
|
|
subs(&nt.Name,ntspecs)
|
|
}
|
|
nt, ok = n.Value.(*ast.Ident); if ok {
|
|
subs(&nt.Name,ntspecs)
|
|
}
|
|
case *ast.FuncDecl:
|
|
sub(&n.Name.Name,fspec)
|
|
//ast.Print(gfset,n)
|
|
}
|
|
return v
|
|
}
|
|
|
|
func init() {
|
|
firstone = true
|
|
err := os.Remove("pgen.go")
|
|
if err != nil && os.IsExist(err) {
|
|
log.Fatal("Removing pgen.go:",err)
|
|
}
|
|
}
|
|
|
|
func add(newName, typName, typ string) {
|
|
fspec = subspec{regexp.MustCompile("New"), newName}
|
|
nspec = subspec{regexp.MustCompile("_N"), typName}
|
|
tspec = subspec{regexp.MustCompile("_T"), typ}
|
|
ntspecs = []subspec{nspec,tspec}
|
|
|
|
gfset = token.NewFileSet()
|
|
f, err := parser.ParseFile(gfset, "", template, 0)
|
|
if err != nil {
|
|
log.Fatal("Parsing persist/template.T:",err)
|
|
}
|
|
var v = &gvisit{}
|
|
ast.Walk(v,f)
|
|
|
|
if firstone {
|
|
nodes = f
|
|
} else {
|
|
for _,decl := range(f.Decls) {
|
|
imp, ok := decl.(*ast.GenDecl); if ok {
|
|
if imp.Tok == token.IMPORT {
|
|
continue // skip imports
|
|
}
|
|
}
|
|
nodes.Decls = append(nodes.Decls,decl)
|
|
}
|
|
}
|
|
firstone = false
|
|
}
|
|
|
|
func newImportSpec(name string) *ast.ImportSpec {
|
|
path := &ast.BasicLit{ Value: name }
|
|
ret := &ast.ImportSpec{ Path: path }
|
|
return ret
|
|
}
|
|
|
|
func gen(wantImps []string) {
|
|
if nodes == nil {
|
|
return
|
|
}
|
|
of, err := os.Create("pgen.go")
|
|
if err != nil {
|
|
log.Fatal("Cannot open pgen.go")
|
|
}
|
|
|
|
qexp := regexp.MustCompile(`"`)
|
|
for _,v := range wantImps {
|
|
v = qexp.ReplaceAllString(v,"")
|
|
astutil.AddImport(gfset, nodes, v)
|
|
}
|
|
|
|
err = format.Node(of,gfset,nodes)
|
|
if err != nil {
|
|
log.Fatal("Generate error:",err)
|
|
}
|
|
}
|
|
|