func genPkg(p *types.Package) {
fname := defaultFileName(*lang, p)
switch *lang {
case "java":
w, closer := writer(fname, p)
processErr(bind.GenJava(w, fset, p, *javaPkg))
closer()
case "go":
w, closer := writer(fname, p)
processErr(bind.GenGo(w, fset, p))
closer()
case "objc":
if fname == "" {
processErr(bind.GenObjc(os.Stdout, fset, p, *prefix, true))
processErr(bind.GenObjc(os.Stdout, fset, p, *prefix, false))
} else {
hname := fname[:len(fname)-2] + ".h"
w, closer := writer(hname, p)
processErr(bind.GenObjc(w, fset, p, *prefix, true))
closer()
w, closer = writer(fname, p)
processErr(bind.GenObjc(w, fset, p, *prefix, false))
closer()
}
default:
errorf("unknown target language: %q", *lang)
}
}
func (b *binder) GenGo(pkg *types.Package, allPkg []*types.Package, outdir string) error {
pkgName := "go_"
pkgPath := ""
if pkg != nil {
pkgName += pkg.Name()
pkgPath = pkg.Path()
}
goFile := filepath.Join(outdir, pkgName+"main.go")
generate := func(w io.Writer) error {
if buildX {
printcmd("gobind -lang=go -outdir=%s %s", outdir, pkgPath)
}
if buildN {
return nil
}
conf := &bind.GeneratorConfig{
Writer: w,
Fset: b.fset,
Pkg: pkg,
AllPkg: allPkg,
}
return bind.GenGo(conf)
}
if err := writeFile(goFile, generate); err != nil {
return err
}
return nil
}
func genPkg(pkg *build.Package) {
files := parseFiles(pkg.Dir, pkg.GoFiles)
if len(files) == 0 {
return // some error has been reported
}
conf := loader.Config{
Fset: fset,
AllowErrors: true,
}
conf.TypeChecker.IgnoreFuncBodies = true
conf.TypeChecker.FakeImportC = true
conf.TypeChecker.DisableUnusedImportCheck = true
var tcErrs []error
conf.TypeChecker.Error = func(err error) {
tcErrs = append(tcErrs, err)
}
conf.CreateFromFiles(pkg.ImportPath, files...)
program, err := conf.Load()
if err != nil {
for _, err := range tcErrs {
errorf("%v", err)
}
errorf("%v", err)
return
}
p := program.Created[0].Pkg
fname := defaultFileName(*lang, p)
switch *lang {
case "java":
w, closer := writer(fname, p)
processErr(bind.GenJava(w, fset, p, *javaPkg))
closer()
case "go":
w, closer := writer(fname, p)
processErr(bind.GenGo(w, fset, p))
closer()
case "objc":
if fname == "" {
processErr(bind.GenObjc(os.Stdout, fset, p, *prefix, true))
processErr(bind.GenObjc(os.Stdout, fset, p, *prefix, false))
} else {
hname := fname[:len(fname)-2] + ".h"
w, closer := writer(hname, p)
processErr(bind.GenObjc(w, fset, p, *prefix, true))
closer()
w, closer = writer(fname, p)
processErr(bind.GenObjc(w, fset, p, *prefix, false))
closer()
}
default:
errorf("unknown target language: %q", *lang)
}
}
func genPkg(pkg *build.Package) {
if len(pkg.CgoFiles) > 0 {
errorf("gobind: cannot use cgo-dependent package as service definition: %s", pkg.CgoFiles[0])
return
}
files := parseFiles(pkg.Dir, pkg.GoFiles)
if len(files) == 0 {
return // some error has been reported
}
conf := loader.Config{
Fset: fset,
}
conf.TypeChecker.Error = func(err error) {
errorf("%v", err)
}
conf.CreateFromFiles(pkg.ImportPath, files...)
program, err := conf.Load()
if err != nil {
errorf("%v", err)
return
}
p := program.Created[0].Pkg
fname := defaultFileName(*lang, p)
switch *lang {
case "java":
w, closer := writer(fname, p)
processErr(bind.GenJava(w, fset, p))
closer()
case "go":
w, closer := writer(fname, p)
processErr(bind.GenGo(w, fset, p))
closer()
case "objc":
if fname == "" {
processErr(bind.GenObjc(os.Stdout, fset, p, true))
processErr(bind.GenObjc(os.Stdout, fset, p, false))
} else {
hname := fname[:len(fname)-2] + ".h"
w, closer := writer(hname, p)
processErr(bind.GenObjc(w, fset, p, true))
closer()
w, closer = writer(fname, p)
processErr(bind.GenObjc(w, fset, p, false))
closer()
}
default:
errorf("unknown target language: %q", *lang)
}
}
func (b *binder) GenGo(outdir string) error {
pkgName := "go_" + b.pkg.Name()
goFile := filepath.Join(outdir, pkgName, pkgName+"main.go")
if buildX {
printcmd("gobind -lang=go %s > %s", b.pkg.Path(), goFile)
}
generate := func(w io.Writer) error {
return bind.GenGo(w, b.fset, b.pkg)
}
if err := writeFile(goFile, generate); err != nil {
return err
}
return nil
}
func genPkg(p *types.Package, allPkg []*types.Package) {
fname := defaultFileName(*lang, p)
conf := &bind.GeneratorConfig{
Fset: fset,
Pkg: p,
AllPkg: allPkg,
}
switch *lang {
case "java":
w, closer := writer(fname)
conf.Writer = w
processErr(bind.GenJava(conf, *javaPkg, bind.Java))
closer()
cname := "java_" + p.Name() + ".c"
w, closer = writer(cname)
conf.Writer = w
processErr(bind.GenJava(conf, *javaPkg, bind.JavaC))
closer()
hname := p.Name() + ".h"
w, closer = writer(hname)
conf.Writer = w
processErr(bind.GenJava(conf, *javaPkg, bind.JavaH))
closer()
case "go":
w, closer := writer(fname)
conf.Writer = w
processErr(bind.GenGo(conf))
closer()
case "objc":
gohname := p.Name() + ".h"
w, closer := writer(gohname)
conf.Writer = w
processErr(bind.GenObjc(conf, *prefix, bind.ObjcGoH))
closer()
hname := fname[:len(fname)-2] + ".h"
w, closer = writer(hname)
conf.Writer = w
processErr(bind.GenObjc(conf, *prefix, bind.ObjcH))
closer()
w, closer = writer(fname)
conf.Writer = w
processErr(bind.GenObjc(conf, *prefix, bind.ObjcM))
closer()
default:
errorf("unknown target language: %q", *lang)
}
}
func genPkg(pkg *build.Package) {
if len(pkg.CgoFiles) > 0 {
errorf("gobind: cannot use cgo-dependent package as service definition: %s", pkg.CgoFiles[0])
return
}
files := parseFiles(pkg.Dir, pkg.GoFiles)
if len(files) == 0 {
return // some error has been reported
}
conf := loader.Config{
SourceImports: true,
Fset: fset,
}
conf.TypeChecker.Error = func(err error) {
errorf("%v", err)
}
conf.CreateFromFiles(pkg.ImportPath, files...)
program, err := conf.Load()
if err != nil {
errorf("%v", err)
return
}
p := program.Created[0].Pkg
switch *lang {
case "java":
err = bind.GenJava(os.Stdout, fset, p)
case "go":
err = bind.GenGo(os.Stdout, fset, p)
default:
errorf("unknown target language: %q", *lang)
}
if err != nil {
if list, _ := err.(bind.ErrorList); len(list) > 0 {
for _, err := range list {
errorf("%v", err)
}
} else {
errorf("%v", err)
}
}
}
func (b *binder) GenGo(pkg *types.Package, outdir string) error {
pkgName := "go_" + pkg.Name()
outdir = filepath.Join(outdir, pkgName)
goFile := filepath.Join(outdir, pkgName+"main.go")
generate := func(w io.Writer) error {
if buildX {
printcmd("gobind -lang=go -outdir=%s %s", outdir, pkg.Path())
}
if buildN {
return nil
}
return bind.GenGo(w, b.fset, pkg)
}
if err := writeFile(goFile, generate); err != nil {
return err
}
return nil
}
func genPkg(p *types.Package, allPkg []*types.Package, classes []*java.Class) {
fname := defaultFileName(*lang, p)
conf := &bind.GeneratorConfig{
Fset: fset,
Pkg: p,
AllPkg: allPkg,
}
switch *lang {
case "java":
var buf bytes.Buffer
g := &bind.JavaGen{
JavaPkg: *javaPkg,
Generator: &bind.Generator{
Printer: &bind.Printer{Buf: &buf, IndentEach: []byte(" ")},
Fset: conf.Fset,
AllPkg: conf.AllPkg,
Pkg: conf.Pkg,
},
}
g.Init(classes)
pkgname := bind.JavaPkgName(*javaPkg, p)
pkgDir := strings.Replace(pkgname, ".", "/", -1)
buf.Reset()
w, closer := writer(filepath.Join(pkgDir, fname))
processErr(g.GenJava())
io.Copy(w, &buf)
closer()
for i, name := range g.ClassNames() {
buf.Reset()
w, closer := writer(filepath.Join(pkgDir, name+".java"))
processErr(g.GenClass(i))
io.Copy(w, &buf)
closer()
}
buf.Reset()
pn := "universe"
if p != nil {
pn = p.Name()
}
cname := "java_" + pn + ".c"
w, closer = writer(cname)
processErr(g.GenC())
io.Copy(w, &buf)
closer()
buf.Reset()
hname := pn + ".h"
w, closer = writer(hname)
processErr(g.GenH())
io.Copy(w, &buf)
closer()
// Generate support files along with the universe package
if p == nil {
p, err := build.Default.Import("golang.org/x/mobile/bind", ".", build.ImportComment)
if err != nil {
errorf(`"golang.org/x/mobile/bind" is not found; run go get golang.org/x/mobile/bind: %v`)
return
}
repo := filepath.Clean(filepath.Join(p.Dir, "..")) // golang.org/x/mobile directory.
for _, javaFile := range []string{"Seq.java", "LoadJNI.java"} {
src := filepath.Join(repo, "bind/java/"+javaFile)
in, err := os.Open(src)
if err != nil {
errorf("failed to open Java support file: %v", err)
}
defer in.Close()
w, closer := writer(filepath.Join("go", javaFile))
defer closer()
if _, err := io.Copy(w, in); err != nil {
errorf("failed to copy Java support file: %v", err)
return
}
}
}
case "go":
w, closer := writer(fname)
conf.Writer = w
processErr(bind.GenGo(conf))
closer()
case "objc":
var gohname string
if p != nil {
gohname = p.Name() + ".h"
} else {
gohname = "GoUniverse.h"
}
var buf bytes.Buffer
g := &bind.ObjcGen{
Generator: &bind.Generator{
Printer: &bind.Printer{Buf: &buf, IndentEach: []byte("\t")},
Fset: conf.Fset,
AllPkg: conf.AllPkg,
Pkg: conf.Pkg,
},
Prefix: *prefix,
}
g.Init(nil)
w, closer := writer(gohname)
processErr(g.GenGoH())
io.Copy(w, &buf)
closer()
hname := fname[:len(fname)-2] + ".h"
w, closer = writer(hname)
processErr(g.GenH())
io.Copy(w, &buf)
closer()
w, closer = writer(fname)
conf.Writer = w
processErr(g.GenM())
io.Copy(w, &buf)
closer()
default:
errorf("unknown target language: %q", *lang)
}
}