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 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 (b *binder) GenJava(pkg *types.Package, allPkg []*types.Package, outdir, javadir string) error {
className := strings.Title(pkg.Name())
javaFile := filepath.Join(javadir, className+".java")
cFile := filepath.Join(outdir, "java_"+pkg.Name()+".c")
hFile := filepath.Join(outdir, pkg.Name()+".h")
bindOption := "-lang=java"
if bindJavaPkg != "" {
bindOption += " -javapkg=" + bindJavaPkg
}
conf := &bind.GeneratorConfig{
Fset: b.fset,
Pkg: pkg,
AllPkg: allPkg,
}
generate := func(w io.Writer) error {
if buildX {
printcmd("gobind %s -outdir=%s %s", bindOption, javadir, pkg.Path())
}
if buildN {
return nil
}
conf.Writer = w
return bind.GenJava(conf, bindJavaPkg, bind.Java)
}
if err := writeFile(javaFile, generate); err != nil {
return err
}
generate = func(w io.Writer) error {
if buildN {
return nil
}
conf.Writer = w
return bind.GenJava(conf, bindJavaPkg, bind.JavaC)
}
if err := writeFile(cFile, generate); err != nil {
return err
}
generate = func(w io.Writer) error {
if buildN {
return nil
}
conf.Writer = w
return bind.GenJava(conf, bindJavaPkg, bind.JavaH)
}
return writeFile(hFile, generate)
}
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) GenJava(outdir string) error {
className := strings.Title(b.pkg.Name())
javaFile := filepath.Join(outdir, className+".java")
if buildX {
printcmd("gobind -lang=java %s > %s", b.pkg.Path(), javaFile)
}
generate := func(w io.Writer) error {
return bind.GenJava(w, b.fset, b.pkg)
}
if err := writeFile(javaFile, generate); err != nil {
return err
}
return nil
}
func (b *binder) GenJava(outdir string) error {
firstRune, size := utf8.DecodeRuneInString(b.pkg.Name())
className := string(unicode.ToUpper(firstRune)) + b.pkg.Name()[size:]
javaFile := filepath.Join(outdir, className+".java")
if buildX {
printcmd("gobind -lang=java %s > %s", b.pkg.Path(), javaFile)
}
generate := func(w io.Writer) error {
return bind.GenJava(w, b.fset, b.pkg)
}
if err := writeFile(javaFile, generate); err != nil {
return err
}
return nil
}
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) GenJava(outdir string) error {
className := strings.Title(b.pkg.Name())
javaFile := filepath.Join(outdir, className+".java")
bindOption := "-lang=java"
if bindJavaPkg != "" {
bindOption += " -javapkg=" + bindJavaPkg
}
generate := func(w io.Writer) error {
if buildX {
printcmd("gobind %s -outdir=%s %s", bindOption, outdir, b.pkg.Path())
}
return bind.GenJava(w, b.fset, b.pkg, bindJavaPkg)
}
if err := writeFile(javaFile, generate); err != nil {
return err
}
return nil
}
