blob: 7595fa0ffdf50066c2b7ca099a5d4e8ed56d3d8b [file] [log] [blame]
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package bind
import (
"fmt"
"go/constant"
"go/types"
"math"
"strings"
"golang.org/x/mobile/internal/importers/objc"
)
// TODO(hyangah): handle method name conflicts.
// - struct with SetF method and exported F field.
// - method names conflicting with NSObject methods. e.g. Init
// - interface type with InitWithRef.
// TODO(hyangah): error code/domain propagation
type ObjcGen struct {
Prefix string // prefix arg passed by flag.
*Generator
// fields set by init.
namePrefix string
// Map of all wrapped Objc types
wrapMap map[string]*objc.Named
// Structs that embeds Objc wrapper types.
ostructs map[*types.TypeName]*objcClassInfo
modules []string
// Constructors is a map from Go struct types to a list
// of exported constructor functions for the type, on the form
// func New<Type>(...) *Type
constructors map[*types.TypeName][]*types.Func
}
type objcClassInfo struct {
// The Objc class this class extends.
extends *objc.Named
// All classes and protocols this class extends and conforms to.
supers []*objc.Named
methods map[string]*objc.Func
}
func (g *ObjcGen) Init(wrappers []*objc.Named) {
g.Generator.Init()
g.namePrefix = g.namePrefixOf(g.Pkg)
g.wrapMap = make(map[string]*objc.Named)
g.constructors = make(map[*types.TypeName][]*types.Func)
modMap := make(map[string]struct{})
for _, w := range wrappers {
g.wrapMap[w.GoName] = w
if _, exists := modMap[w.Module]; !exists {
if !w.Generated {
g.modules = append(g.modules, w.Module)
}
modMap[w.Module] = struct{}{}
}
}
if _, exists := modMap["Foundation"]; !exists {
g.modules = append(g.modules, "Foundation")
}
g.ostructs = make(map[*types.TypeName]*objcClassInfo)
for _, s := range g.structs {
embds := embeddedObjcTypes(s.t)
if len(embds) == 0 {
continue
}
inf := &objcClassInfo{
methods: make(map[string]*objc.Func),
}
for _, n := range embds {
t := g.wrapMap[n]
for _, f := range t.AllMethods {
inf.methods[f.GoName] = f
}
inf.supers = append(inf.supers, t)
if !t.Protocol {
if inf.extends != nil {
g.errorf("%s embeds more than one ObjC class; only one is allowed.", s.obj)
}
inf.extends = t
}
}
g.ostructs[s.obj] = inf
}
for _, f := range g.funcs {
if t := g.constructorType(f); t != nil {
g.constructors[t] = append(g.constructors[t], f)
}
}
}
func (g *ObjcGen) namePrefixOf(pkg *types.Package) string {
if pkg == nil {
return "Universe"
}
p := g.Prefix
return p + strings.Title(pkg.Name())
}
func (g *ObjcGen) GenGoH() error {
var pkgPath string
if g.Pkg != nil {
pkgPath = g.Pkg.Path()
}
g.Printf(objcPreamble, pkgPath, g.gobindOpts(), pkgPath)
g.Printf("#ifndef __GO_%s_H__\n", g.pkgName)
g.Printf("#define __GO_%s_H__\n\n", g.pkgName)
g.Printf("#include <stdint.h>\n")
g.Printf("#include <objc/objc.h>\n")
for _, i := range g.interfaces {
if !i.summary.implementable {
continue
}
for _, m := range i.summary.callable {
if !g.isSigSupported(m.Type()) {
g.Printf("// skipped method %s.%s with unsupported parameter or return types\n\n", i.obj.Name(), m.Name())
continue
}
g.genInterfaceMethodSignature(m, i.obj.Name(), true, g.paramName)
g.Printf("\n")
}
}
g.Printf("#endif\n")
if len(g.err) > 0 {
return g.err
}
return nil
}
func (g *ObjcGen) GenH() error {
var pkgPath string
if g.Pkg != nil {
pkgPath = g.Pkg.Path()
}
g.Printf(objcPreamble, pkgPath, g.gobindOpts(), pkgPath)
g.Printf("#ifndef __%s_H__\n", g.namePrefix)
g.Printf("#define __%s_H__\n", g.namePrefix)
g.Printf("\n")
for _, m := range g.modules {
g.Printf("@import %s;\n", m)
}
g.Printf("#include \"ref.h\"\n")
if g.Pkg != nil {
g.Printf("#include \"Universe.objc.h\"\n\n")
}
if g.Pkg != nil {
for _, pkg := range g.Pkg.Imports() {
if g.validPkg(pkg) {
g.Printf("#include %q\n", g.namePrefixOf(pkg)+".objc.h")
}
}
}
g.Printf("\n")
// Forward declaration of @class and @protocol
for _, s := range g.structs {
g.Printf("@class %s%s;\n", g.namePrefix, s.obj.Name())
}
for _, i := range g.interfaces {
g.Printf("@protocol %s%s;\n", g.namePrefix, i.obj.Name())
if i.summary.implementable {
g.Printf("@class %s%s;\n", g.namePrefix, i.obj.Name())
// Forward declaration for other cases will be handled at the beginning of GenM.
}
}
if len(g.structs) > 0 || len(g.interfaces) > 0 {
g.Printf("\n")
}
// @interfaces
for _, i := range g.interfaces {
g.genInterfaceH(i.obj, i.t)
g.Printf("\n")
}
for _, s := range g.structs {
g.genStructH(s.obj, s.t)
g.Printf("\n")
}
// const
// TODO: prefix with k?, or use a class method?
for _, obj := range g.constants {
if _, ok := obj.Type().(*types.Basic); !ok || !g.isSupported(obj.Type()) {
g.Printf("// skipped const %s with unsupported type: %s\n\n", obj.Name(), obj.Type())
continue
}
g.objcdoc(g.docs[obj.Name()].Doc())
switch b := obj.Type().(*types.Basic); b.Kind() {
case types.String, types.UntypedString:
g.Printf("FOUNDATION_EXPORT NSString* _Nonnull const %s%s;\n", g.namePrefix, obj.Name())
default:
g.Printf("FOUNDATION_EXPORT const %s %s%s;\n", g.objcType(obj.Type()), g.namePrefix, obj.Name())
}
}
if len(g.constants) > 0 {
g.Printf("\n")
}
// var
if len(g.vars) > 0 {
g.Printf("@interface %s : NSObject\n", g.namePrefix)
for _, obj := range g.vars {
if t := obj.Type(); !g.isSupported(t) {
g.Printf("// skipped variable %s with unsupported type: %s\n\n", obj.Name(), t)
continue
}
objcType := g.objcType(obj.Type())
g.objcdoc(g.docs[obj.Name()].Doc())
g.Printf("+ (%s) %s;\n", objcType, objcNameReplacer(lowerFirst(obj.Name())))
g.Printf("+ (void) set%s:(%s)v;\n", obj.Name(), objcType)
g.Printf("\n")
}
g.Printf("@end\n\n")
}
// static functions.
for _, obj := range g.funcs {
g.genFuncH(obj)
g.Printf("\n")
}
for _, i := range g.interfaces {
if i.summary.implementable {
g.Printf("@class %s%s;\n\n", g.namePrefix, i.obj.Name())
}
}
for _, i := range g.interfaces {
if i.summary.implementable {
// @interface Interface -- similar to what genStructH does.
g.genInterfaceInterface(i.obj, i.summary, true)
g.Printf("\n")
}
}
g.Printf("#endif\n")
if len(g.err) > 0 {
return g.err
}
return nil
}
func (g *ObjcGen) gobindOpts() string {
opts := []string{"-lang=objc"}
if g.Prefix != "" {
opts = append(opts, fmt.Sprintf("-prefix=%q", g.Prefix))
}
return strings.Join(opts, " ")
}
func (g *ObjcGen) GenM() error {
var pkgPath string
if g.Pkg != nil {
pkgPath = g.Pkg.Path()
}
g.Printf(objcPreamble, pkgPath, g.gobindOpts(), pkgPath)
g.Printf("#include <Foundation/Foundation.h>\n")
g.Printf("#include \"seq.h\"\n")
g.Printf("#include \"_cgo_export.h\"\n")
g.Printf("#include %q\n", g.namePrefix+".objc.h")
g.Printf("\n")
// struct
for _, s := range g.structs {
g.genStructM(s.obj, s.t)
g.Printf("\n")
}
// interface
var needProxy []*types.TypeName
for _, i := range g.interfaces {
if g.genInterfaceM(i.obj, i.t) {
needProxy = append(needProxy, i.obj)
}
g.Printf("\n")
}
// const
for _, o := range g.constants {
g.genConstM(o)
}
if len(g.constants) > 0 {
g.Printf("\n")
}
// vars
if len(g.vars) > 0 {
g.Printf("@implementation %s\n", g.namePrefix)
for _, o := range g.vars {
g.genVarM(o)
}
g.Printf("@end\n\n")
}
g.Printf("\n")
for _, obj := range g.funcs {
if !g.isSigSupported(obj.Type()) {
g.Printf("// skipped function %s with unsupported parameter or return types\n\n", obj.Name())
continue
}
g.genFuncM(obj)
g.Printf("\n")
}
for _, i := range g.interfaces {
for _, m := range i.summary.callable {
if !g.isSigSupported(m.Type()) {
g.Printf("// skipped method %s.%s with unsupported parameter or return types\n\n", i.obj.Name(), m.Name())
continue
}
g.genInterfaceMethodProxy(i.obj, m)
}
}
g.Printf("__attribute__((constructor)) static void init() {\n")
g.Indent()
g.Printf("init_seq();\n")
g.Outdent()
g.Printf("}\n")
if len(g.err) > 0 {
return g.err
}
return nil
}
func (g *ObjcGen) genVarM(o *types.Var) {
if t := o.Type(); !g.isSupported(t) {
g.Printf("// skipped variable %s with unsupported type: %s\n\n", o.Name(), t)
return
}
objcType := g.objcType(o.Type())
// setter
g.Printf("+ (void) set%s:(%s)v {\n", o.Name(), objcType)
g.Indent()
g.genWrite("v", o.Type(), modeRetained)
g.Printf("var_set%s_%s(_v);\n", g.pkgPrefix, o.Name())
g.genRelease("v", o.Type(), modeRetained)
g.Outdent()
g.Printf("}\n\n")
// getter
g.Printf("+ (%s) %s {\n", objcType, objcNameReplacer(lowerFirst(o.Name())))
g.Indent()
g.Printf("%s r0 = ", g.cgoType(o.Type()))
g.Printf("var_get%s_%s();\n", g.pkgPrefix, o.Name())
g.genRead("_r0", "r0", o.Type(), modeRetained)
g.Printf("return _r0;\n")
g.Outdent()
g.Printf("}\n\n")
}
func (g *ObjcGen) genConstM(o *types.Const) {
if _, ok := o.Type().(*types.Basic); !ok || !g.isSupported(o.Type()) {
g.Printf("// skipped const %s with unsupported type: %s\n\n", o.Name(), o.Type())
return
}
cName := fmt.Sprintf("%s%s", g.namePrefix, o.Name())
objcType := g.objcType(o.Type())
switch b := o.Type().(*types.Basic); b.Kind() {
case types.Bool, types.UntypedBool:
v := "NO"
if constant.BoolVal(o.Val()) {
v = "YES"
}
g.Printf("const BOOL %s = %s;\n", cName, v)
case types.String, types.UntypedString:
g.Printf("NSString* const %s = @%s;\n", cName, o.Val().ExactString())
case types.Int, types.Int8, types.Int16, types.Int32:
g.Printf("const %s %s = %s;\n", objcType, cName, o.Val())
case types.Int64, types.UntypedInt:
i, exact := constant.Int64Val(o.Val())
if !exact {
g.errorf("const value %s for %s cannot be represented as %s", o.Val(), o.Name(), objcType)
return
}
if i == math.MinInt64 {
// -9223372036854775808LL does not work because 922337203685477508 is
// larger than max int64.
g.Printf("const int64_t %s = %dLL-1;\n", cName, i+1)
} else {
g.Printf("const int64_t %s = %dLL;\n", cName, i)
}
case types.Float32, types.Float64, types.UntypedFloat:
f, _ := constant.Float64Val(o.Val())
if math.IsInf(f, 0) || math.Abs(f) > math.MaxFloat64 {
g.errorf("const value %s for %s cannot be represented as double", o.Val(), o.Name())
return
}
g.Printf("const %s %s = %g;\n", objcType, cName, f)
default:
g.errorf("unsupported const type %s for %s", b, o.Name())
}
}
type funcSummary struct {
name string
goname string
ret string
sig *types.Signature
params, retParams []paramInfo
hasself bool
initName string
}
type paramInfo struct {
typ types.Type
name string
}
func (g *ObjcGen) funcSummary(obj *types.TypeName, f *types.Func) *funcSummary {
sig := f.Type().(*types.Signature)
s := &funcSummary{goname: f.Name(), sig: sig}
var om *objc.Func
var sigElems []string
oinf := g.ostructs[obj]
if oinf != nil {
om = oinf.methods[f.Name()]
}
if om != nil {
sigElems = strings.Split(om.Sig, ":")
s.name = sigElems[0]
} else {
s.name = f.Name()
}
params := sig.Params()
first := 0
if oinf != nil {
if params.Len() > 0 {
v := params.At(0)
if v.Name() == "self" {
t := v.Type()
if t, ok := t.(*types.Named); ok {
if pkg := t.Obj().Pkg(); pkgFirstElem(pkg) == "ObjC" {
s.hasself = true
module := pkg.Path()[len("ObjC/"):]
typName := module + "." + t.Obj().Name()
exp := g.namePrefix + "." + obj.Name()
if typName != exp {
g.errorf("the type %s of the `this` argument to method %s is not %s", typName, f.Name(), exp)
}
}
}
}
}
}
for i := first; i < params.Len(); i++ {
p := params.At(i)
v := paramInfo{
typ: p.Type(),
}
if om != nil {
v.name = sigElems[i-first]
} else {
v.name = g.paramName(params, i)
}
s.params = append(s.params, v)
}
if obj != nil {
if pref := "New" + obj.Name(); strings.Index(f.Name(), pref) != -1 {
s.initName = "init" + f.Name()[len(pref):]
}
}
res := sig.Results()
switch res.Len() {
case 0:
s.ret = "void"
case 1:
p := res.At(0)
if isErrorType(p.Type()) {
s.retParams = append(s.retParams, paramInfo{
typ: p.Type(),
name: "error",
})
s.ret = "BOOL"
} else {
name := p.Name()
if name == "" || paramRE.MatchString(name) {
name = "ret0_"
}
typ := p.Type()
s.retParams = append(s.retParams, paramInfo{typ: typ, name: name})
s.ret = g.objcType(typ)
}
case 2:
name := res.At(0).Name()
if name == "" || paramRE.MatchString(name) {
name = "ret0_"
}
typ := res.At(0).Type()
s.retParams = append(s.retParams, paramInfo{
typ: typ,
name: name,
})
if isNullableType(typ) {
s.ret = g.objcType(typ) // Return is nullable, so satisfies the ObjC/Swift error protocol
} else {
s.ret = "BOOL" // Return is not nullable, must use an output parameter and return bool
}
if !isErrorType(res.At(1).Type()) {
g.errorf("second result value must be of type error: %s", f)
return nil
}
s.retParams = append(s.retParams, paramInfo{
typ: res.At(1).Type(),
name: "error", // TODO(hyangah): name collision check.
})
default:
// TODO(hyangah): relax the constraint on multiple return params.
g.errorf("too many result values: %s", f)
return nil
}
return s
}
func (s *funcSummary) asFunc(g *ObjcGen) string {
var params []string
for _, p := range s.params {
params = append(params, g.objcParamType(p.typ)+" "+p.name)
}
skip := 0
if s.returnsVal() {
skip = 1
}
for _, p := range s.retParams[skip:] {
params = append(params, g.objcType(p.typ)+"* _Nullable "+p.name)
}
paramContents := "void"
if len(params) > 0 {
paramContents = strings.Join(params, ", ")
}
return fmt.Sprintf("%s %s%s(%s)", s.ret, g.namePrefix, s.name, paramContents)
}
func (s *funcSummary) asMethod(g *ObjcGen) string {
return fmt.Sprintf("(%s)%s%s", s.ret, objcNameReplacer(lowerFirst(s.name)), s.asSignature(g))
}
func (s *funcSummary) asSignature(g *ObjcGen) string {
var params []string
skip := 0
if s.hasself {
skip = 1
}
for i, p := range s.params[skip:] {
var key string
if i != 0 {
key = p.name
}
params = append(params, fmt.Sprintf("%s:(%s)%s", key, g.objcParamType(p.typ), p.name))
}
skip = 0
if s.returnsVal() {
skip = 1
}
for _, p := range s.retParams[skip:] {
var key string
if len(params) > 0 {
key = p.name
}
params = append(params, fmt.Sprintf("%s:(%s)%s", key, g.objcType(p.typ)+"* _Nullable", p.name))
}
return strings.Join(params, " ")
}
func (s *funcSummary) asInitSignature(g *ObjcGen) string {
var params []string
for i, p := range s.params {
var key string
if i > 0 {
key = p.name
}
params = append(params, fmt.Sprintf("%s:(%s)%s", key, g.objcParamType(p.typ), p.name))
}
return strings.Join(params, " ")
}
func (s *funcSummary) callMethod(g *ObjcGen) string {
var params []string
for i, p := range s.params {
var key string
if i != 0 {
key = p.name
}
params = append(params, fmt.Sprintf("%s:_%s", key, p.name))
}
skip := 0
if s.returnsVal() {
skip = 1
}
for _, p := range s.retParams[skip:] {
var key string
if len(params) > 0 {
key = p.name
}
params = append(params, fmt.Sprintf("%s:&%s", key, p.name))
}
return fmt.Sprintf("%s%s", objcNameReplacer(lowerFirst(s.name)), strings.Join(params, " "))
}
func (s *funcSummary) returnsVal() bool {
return (len(s.retParams) == 1 && !isErrorType(s.retParams[0].typ)) || (len(s.retParams) == 2 && isNullableType(s.retParams[0].typ))
}
func (g *ObjcGen) paramName(params *types.Tuple, pos int) string {
name := basicParamName(params, pos)
return objcNameReplacer(name)
}
func (g *ObjcGen) genFuncH(obj *types.Func) {
if !g.isSigSupported(obj.Type()) {
g.Printf("// skipped function %s with unsupported parameter or return types\n\n", obj.Name())
return
}
if s := g.funcSummary(nil, obj); s != nil {
g.objcdoc(g.docs[obj.Name()].Doc())
g.Printf("FOUNDATION_EXPORT %s;\n", s.asFunc(g))
}
}
func (g *ObjcGen) genFuncM(obj *types.Func) {
s := g.funcSummary(nil, obj)
if s == nil {
return
}
g.Printf("%s {\n", s.asFunc(g))
g.Indent()
g.genFunc(s, "")
g.Outdent()
g.Printf("}\n")
}
func (g *ObjcGen) genGetter(oName string, f *types.Var) {
t := f.Type()
g.Printf("- (%s)%s {\n", g.objcType(t), objcNameReplacer(lowerFirst(f.Name())))
g.Indent()
g.Printf("int32_t refnum = go_seq_go_to_refnum(self._ref);\n")
g.Printf("%s r0 = ", g.cgoType(f.Type()))
g.Printf("proxy%s_%s_%s_Get(refnum);\n", g.pkgPrefix, oName, f.Name())
g.genRead("_r0", "r0", f.Type(), modeRetained)
g.Printf("return _r0;\n")
g.Outdent()
g.Printf("}\n\n")
}
func (g *ObjcGen) genSetter(oName string, f *types.Var) {
t := f.Type()
g.Printf("- (void)set%s:(%s)v {\n", f.Name(), g.objcType(t))
g.Indent()
g.Printf("int32_t refnum = go_seq_go_to_refnum(self._ref);\n")
g.genWrite("v", f.Type(), modeRetained)
g.Printf("proxy%s_%s_%s_Set(refnum, _v);\n", g.pkgPrefix, oName, f.Name())
g.genRelease("v", f.Type(), modeRetained)
g.Outdent()
g.Printf("}\n\n")
}
func (g *ObjcGen) genWrite(varName string, t types.Type, mode varMode) {
switch t := t.(type) {
case *types.Basic:
switch t.Kind() {
case types.String:
g.Printf("nstring _%s = go_seq_from_objc_string(%s);\n", varName, varName)
default:
g.Printf("%s _%s = (%s)%s;\n", g.cgoType(t), varName, g.cgoType(t), varName)
}
case *types.Slice:
switch e := t.Elem().(type) {
case *types.Basic:
switch e.Kind() {
case types.Uint8: // Byte.
g.Printf("nbyteslice _%s = go_seq_from_objc_bytearray(%s, %d);\n", varName, varName, toCFlag(mode == modeRetained))
default:
g.errorf("unsupported type: %s", t)
}
default:
g.errorf("unsupported type: %s", t)
}
case *types.Named:
switch u := t.Underlying().(type) {
case *types.Interface:
g.genRefWrite(varName)
default:
g.errorf("unsupported named type: %s / %T", u, u)
}
case *types.Pointer:
g.genRefWrite(varName)
default:
g.Printf("%s _%s = (%s)%s;\n", g.cgoType(t), varName, g.cgoType(t), varName)
}
}
func (g *ObjcGen) genRefWrite(varName string) {
g.Printf("int32_t _%s;\n", varName)
g.Printf("if ([%s conformsToProtocol:@protocol(goSeqRefInterface)]) {\n", varName)
g.Indent()
g.Printf("id<goSeqRefInterface> %[1]s_proxy = (id<goSeqRefInterface>)(%[1]s);\n", varName)
g.Printf("_%s = go_seq_go_to_refnum(%s_proxy._ref);\n", varName, varName)
g.Outdent()
g.Printf("} else {\n")
g.Indent()
g.Printf("_%s = go_seq_to_refnum(%s);\n", varName, varName)
g.Outdent()
g.Printf("}\n")
}
func (g *ObjcGen) genRefRead(toName, fromName string, t types.Type) {
ptype := g.refTypeBase(t)
g.Printf("%s* %s = nil;\n", ptype, toName)
g.Printf("GoSeqRef* %s_ref = go_seq_from_refnum(%s);\n", toName, fromName)
g.Printf("if (%s_ref != NULL) {\n", toName)
g.Printf(" %s = %s_ref.obj;\n", toName, toName)
g.Printf(" if (%s == nil) {\n", toName)
if isObjcType(t) {
g.Printf(" LOG_FATAL(@\"unexpected NULL reference\");\n")
} else {
g.Printf(" %s = [[%s alloc] initWithRef:%s_ref];\n", toName, ptype, toName)
}
g.Printf(" }\n")
g.Printf("}\n")
}
func (g *ObjcGen) genRead(toName, fromName string, t types.Type, mode varMode) {
switch t := t.(type) {
case *types.Basic:
switch t.Kind() {
case types.String:
g.Printf("NSString *%s = go_seq_to_objc_string(%s);\n", toName, fromName)
case types.Bool:
g.Printf("BOOL %s = %s ? YES : NO;\n", toName, fromName)
default:
g.Printf("%s %s = (%s)%s;\n", g.objcType(t), toName, g.objcType(t), fromName)
}
case *types.Slice:
switch e := t.Elem().(type) {
case *types.Basic:
switch e.Kind() {
case types.Uint8: // Byte.
g.Printf("NSData *%s = go_seq_to_objc_bytearray(%s, %d);\n", toName, fromName, toCFlag(mode == modeRetained))
default:
g.errorf("unsupported type: %s", t)
}
default:
g.errorf("unsupported type: %s", t)
}
case *types.Pointer:
switch t := t.Elem().(type) {
case *types.Named:
g.genRefRead(toName, fromName, types.NewPointer(t))
default:
g.errorf("unsupported type %s", t)
}
case *types.Named:
switch t.Underlying().(type) {
case *types.Interface, *types.Pointer:
g.genRefRead(toName, fromName, t)
default:
g.errorf("unsupported, direct named type %s", t)
}
default:
g.Printf("%s %s = (%s)%s;\n", g.objcType(t), toName, g.objcType(t), fromName)
}
}
func (g *ObjcGen) genFunc(s *funcSummary, objName string) {
skip := 0
if objName != "" {
g.Printf("int32_t refnum = go_seq_go_to_refnum(self._ref);\n")
if s.hasself {
skip = 1
g.Printf("int32_t _self = go_seq_to_refnum(self);\n")
}
}
for _, p := range s.params[skip:] {
g.genWrite(p.name, p.typ, modeTransient)
}
resPrefix := ""
if len(s.retParams) > 0 {
if len(s.retParams) == 1 {
g.Printf("%s r0 = ", g.cgoType(s.retParams[0].typ))
} else {
resPrefix = "res."
g.Printf("struct proxy%s_%s_%s_return res = ", g.pkgPrefix, objName, s.goname)
}
}
g.Printf("proxy%s_%s_%s(", g.pkgPrefix, objName, s.goname)
if objName != "" {
g.Printf("refnum")
if s.hasself {
g.Printf(", _self")
}
}
for i, p := range s.params[skip:] {
if i > 0 || objName != "" {
g.Printf(", ")
}
g.Printf("_%s", p.name)
}
g.Printf(");\n")
for _, p := range s.params {
g.genRelease(p.name, p.typ, modeTransient)
}
for i, r := range s.retParams {
g.genRead("_"+r.name, fmt.Sprintf("%sr%d", resPrefix, i), r.typ, modeRetained)
}
skip = 0
if s.returnsVal() {
skip = 1
}
for _, p := range s.retParams[skip:] {
if isErrorType(p.typ) {
g.Printf("if (_%s != nil && %s != nil) {\n", p.name, p.name)
g.Indent()
g.Printf("*%s = _%s;\n", p.name, p.name)
g.Outdent()
g.Printf("}\n")
} else {
g.Printf("*%s = _%s;\n", p.name, p.name)
}
}
if n := len(s.retParams); n > 0 {
var (
first = s.retParams[0]
last = s.retParams[n-1]
)
if (n == 1 && isErrorType(last.typ)) || (n == 2 && !isNullableType(first.typ) && isErrorType(last.typ)) {
g.Printf("return (_%s == nil);\n", last.name)
} else {
if s.returnsVal() && isErrorType(last.typ) {
g.Printf("if (_%s != nil) {\n", last.name)
g.Indent()
g.Printf("return nil;\n")
g.Outdent()
g.Printf("}\n")
}
g.Printf("return _%s;\n", first.name)
}
}
}
func (g *ObjcGen) genInterfaceInterface(obj *types.TypeName, summary ifaceSummary, isProtocol bool) {
doc := g.docs[obj.Name()]
g.objcdoc(doc.Doc())
g.Printf("@interface %[1]s%[2]s : ", g.namePrefix, obj.Name())
if isErrorType(obj.Type()) {
g.Printf("NSError")
} else {
g.Printf("NSObject")
}
prots := []string{"goSeqRefInterface"}
if isProtocol {
prots = append(prots, fmt.Sprintf("%[1]s%[2]s", g.namePrefix, obj.Name()))
}
g.Printf(" <%s>", strings.Join(prots, ", "))
g.Printf(" {\n}\n")
g.Printf("@property(strong, readonly) _Nonnull id _ref;\n")
g.Printf("\n")
g.Printf("- (nonnull instancetype)initWithRef:(_Nonnull id)ref;\n")
for _, m := range summary.callable {
if !g.isSigSupported(m.Type()) {
g.Printf("// skipped method %s.%s with unsupported parameter or return types\n\n", obj.Name(), m.Name())
continue
}
s := g.funcSummary(nil, m)
g.objcdoc(doc.Member(m.Name()))
g.Printf("- %s;\n", s.asMethod(g))
}
g.Printf("@end\n")
}
func (g *ObjcGen) genInterfaceH(obj *types.TypeName, t *types.Interface) {
summary := makeIfaceSummary(t)
if !summary.implementable {
g.genInterfaceInterface(obj, summary, false)
return
}
g.Printf("@protocol %s%s <NSObject>\n", g.namePrefix, obj.Name())
for _, m := range makeIfaceSummary(t).callable {
if !g.isSigSupported(m.Type()) {
g.Printf("// skipped method %s.%s with unsupported parameter or return types\n\n", obj.Name(), m.Name())
continue
}
s := g.funcSummary(nil, m)
g.Printf("- %s;\n", s.asMethod(g))
}
g.Printf("@end\n")
}
func (g *ObjcGen) genInterfaceM(obj *types.TypeName, t *types.Interface) bool {
summary := makeIfaceSummary(t)
// @implementation Interface -- similar to what genStructM does.
g.Printf("@implementation %s%s {\n", g.namePrefix, obj.Name())
g.Printf("}\n")
g.Printf("\n")
g.Printf("- (nonnull instancetype)initWithRef:(id)ref {\n")
g.Indent()
if isErrorType(obj.Type()) {
g.Printf("if (self) {\n")
g.Printf(" __ref = ref;\n")
g.Printf(" self = [super initWithDomain:@\"go\" code:1 userInfo:@{NSLocalizedDescriptionKey: [self error]}];\n")
g.Printf("}\n")
} else {
g.Printf("self = [super init];\n")
g.Printf("if (self) { __ref = ref; }\n")
}
g.Printf("return self;\n")
g.Outdent()
g.Printf("}\n")
g.Printf("\n")
for _, m := range summary.callable {
if !g.isSigSupported(m.Type()) {
g.Printf("// skipped method %s.%s with unsupported parameter or return types\n\n", obj.Name(), m.Name())
continue
}
s := g.funcSummary(nil, m)
g.Printf("- %s {\n", s.asMethod(g))
g.Indent()
g.genFunc(s, obj.Name())
g.Outdent()
g.Printf("}\n\n")
}
g.Printf("@end\n")
g.Printf("\n")
return summary.implementable
}
func (g *ObjcGen) genInterfaceMethodProxy(obj *types.TypeName, m *types.Func) {
oName := obj.Name()
s := g.funcSummary(nil, m)
g.genInterfaceMethodSignature(m, oName, false, g.paramName)
g.Indent()
g.Printf("@autoreleasepool {\n")
g.Indent()
g.Printf("%s* o = go_seq_objc_from_refnum(refnum);\n", g.refTypeBase(obj.Type()))
for _, p := range s.params {
g.genRead("_"+p.name, p.name, p.typ, modeTransient)
}
// call method
for _, p := range s.retParams {
if isErrorType(p.typ) {
g.Printf("NSError* %s = nil;\n", p.name)
} else {
g.Printf("%s %s;\n", g.objcType(p.typ), p.name)
}
}
if isErrorType(obj.Type()) && m.Name() == "Error" {
// As a special case, ObjC NSErrors are passed to Go pretending to implement the Go error interface.
// They don't actually have an Error method, so calls to to it needs to be rerouted.
g.Printf("%s = [o localizedDescription];\n", s.retParams[0].name)
} else {
if s.ret == "void" {
g.Printf("[o %s];\n", s.callMethod(g))
} else if !s.returnsVal() {
g.Printf("%s returnVal = [o %s];\n", s.ret, s.callMethod(g))
} else {
g.Printf("%s = [o %s];\n", s.retParams[0].name, s.callMethod(g))
}
}
if len(s.retParams) > 0 {
if len(s.retParams) == 1 && !isErrorType(s.retParams[0].typ) {
p := s.retParams[0]
g.genWrite(p.name, p.typ, modeRetained)
g.Printf("return _%s;\n", p.name)
} else {
var rets []string
for _, p := range s.retParams {
if isErrorType(p.typ) {
g.Printf("NSError *_%s = nil;\n", p.name)
if !s.returnsVal() {
g.Printf("if (!returnVal) {\n")
} else {
g.Printf("if (%s != nil) {\n", p.name)
}
g.Indent()
g.Printf("_%[1]s = %[1]s;\n", p.name)
g.Outdent()
g.Printf("}\n")
g.genWrite("_"+p.name, p.typ, modeRetained)
rets = append(rets, "__"+p.name)
} else {
g.genWrite(p.name, p.typ, modeRetained)
rets = append(rets, "_"+p.name)
}
}
if len(rets) > 1 {
g.Printf("cproxy%s_%s_%s_return _sres = {\n", g.pkgPrefix, oName, m.Name())
g.Printf(" %s\n", strings.Join(rets, ", "))
g.Printf("};\n")
g.Printf("return _sres;\n")
} else {
g.Printf("return %s;\n", rets[0])
}
}
}
g.Outdent()
g.Printf("}\n")
g.Outdent()
g.Printf("}\n\n")
}
// genRelease cleans up arguments that weren't copied in genWrite.
func (g *ObjcGen) genRelease(varName string, t types.Type, mode varMode) {
switch t := t.(type) {
case *types.Slice:
switch e := t.Elem().(type) {
case *types.Basic:
switch e.Kind() {
case types.Uint8: // Byte.
if mode == modeTransient {
// If the argument was not mutable, go_seq_from_objc_bytearray created a copy.
// Free it here.
g.Printf("if (![%s isKindOfClass:[NSMutableData class]]) {\n", varName)
g.Printf(" free(_%s.ptr);\n", varName)
g.Printf("}\n")
}
}
}
}
}
func (g *ObjcGen) genStructH(obj *types.TypeName, t *types.Struct) {
doc := g.docs[obj.Name()]
g.objcdoc(doc.Doc())
g.Printf("@interface %s%s : ", g.namePrefix, obj.Name())
oinf := g.ostructs[obj]
var prots []string
if oinf != nil {
for _, sup := range oinf.supers {
if !sup.Protocol {
g.Printf(sup.Name)
} else {
prots = append(prots, sup.Name)
}
}
} else {
g.Printf("NSObject")
prots = append(prots, "goSeqRefInterface")
}
pT := types.NewPointer(obj.Type())
for _, iface := range g.allIntf {
p := iface.obj.Pkg()
if g.Pkg != nil && g.Pkg != p {
// To avoid header include cycles, only declare implementation of interfaces
// from imported packages. TODO(elias.naur): Include every interface that
// doesn't introduce an include cycle.
found := false
for _, imp := range g.Pkg.Imports() {
if imp == p {
found = true
break
}
}
if !found {
continue
}
}
obj := iface.obj
if types.AssignableTo(pT, obj.Type()) {
n := fmt.Sprintf("%s%s", g.namePrefixOf(obj.Pkg()), obj.Name())
prots = append(prots, n)
}
}
if len(prots) > 0 {
g.Printf(" <%s>", strings.Join(prots, ", "))
}
g.Printf(" {\n")
g.Printf("}\n")
g.Printf("@property(strong, readonly) _Nonnull id _ref;\n")
g.Printf("\n")
g.Printf("- (nonnull instancetype)initWithRef:(_Nonnull id)ref;\n")
cons := g.constructors[obj]
if oinf == nil {
for _, f := range cons {
if !g.isSigSupported(f.Type()) {
g.Printf("// skipped constructor %s.%s with unsupported parameter or return types\n\n", obj.Name(), f.Name())
continue
}
g.genInitH(obj, f)
}
}
if oinf != nil || len(cons) == 0 {
// default constructor won't return nil
g.Printf("- (nonnull instancetype)init;\n")
}
// accessors to exported fields.
for _, f := range exportedFields(t) {
if t := f.Type(); !g.isSupported(t) {
g.Printf("// skipped field %s.%s with unsupported type: %s\n\n", obj.Name(), f.Name(), t)
continue
}
name, typ := f.Name(), g.objcType(f.Type())
g.objcdoc(doc.Member(f.Name()))
// properties are atomic by default so explicitly say otherwise
g.Printf("@property (nonatomic) %s %s;\n", typ, objcNameReplacer(lowerFirst(name)))
}
// exported methods
for _, m := range exportedMethodSet(types.NewPointer(obj.Type())) {
if !g.isSigSupported(m.Type()) {
g.Printf("// skipped method %s.%s with unsupported parameter or return types\n\n", obj.Name(), m.Name())
continue
}
s := g.funcSummary(obj, m)
g.objcdoc(doc.Member(m.Name()))
g.Printf("- %s;\n", s.asMethod(g))
}
g.Printf("@end\n")
}
func (g *ObjcGen) objcdoc(doc string) {
if doc == "" {
return
}
g.Printf("/**\n * %s */\n", doc)
}
func (g *ObjcGen) genStructM(obj *types.TypeName, t *types.Struct) {
fields := exportedFields(t)
methods := exportedMethodSet(types.NewPointer(obj.Type()))
g.Printf("\n")
oinf := g.ostructs[obj]
g.Printf("@implementation %s%s {\n", g.namePrefix, obj.Name())
g.Printf("}\n\n")
g.Printf("- (nonnull instancetype)initWithRef:(_Nonnull id)ref {\n")
g.Indent()
g.Printf("self = [super init];\n")
g.Printf("if (self) { __ref = ref; }\n")
g.Printf("return self;\n")
g.Outdent()
g.Printf("}\n\n")
cons := g.constructors[obj]
if oinf == nil {
for _, f := range cons {
if !g.isSigSupported(f.Type()) {
g.Printf("// skipped constructor %s.%s with unsupported parameter or return types\n\n", obj, f.Name())
continue
}
g.genInitM(obj, f)
}
}
if oinf != nil || len(cons) == 0 {
g.Printf("- (nonnull instancetype)init {\n")
g.Indent()
g.Printf("self = [super init];\n")
g.Printf("if (self) {\n")
g.Indent()
g.Printf("__ref = go_seq_from_refnum(new_%s_%s());\n", g.pkgPrefix, obj.Name())
g.Outdent()
g.Printf("}\n")
g.Printf("return self;\n")
g.Outdent()
g.Printf("}\n\n")
}
for _, f := range fields {
if !g.isSupported(f.Type()) {
g.Printf("// skipped unsupported field %s with type %s\n\n", f.Name(), f.Type())
continue
}
g.genGetter(obj.Name(), f)
g.genSetter(obj.Name(), f)
}
for _, m := range methods {
if !g.isSigSupported(m.Type()) {
g.Printf("// skipped method %s.%s with unsupported parameter or return types\n\n", obj.Name(), m.Name())
continue
}
s := g.funcSummary(obj, m)
g.Printf("- %s {\n", s.asMethod(g))
g.Indent()
g.genFunc(s, obj.Name())
g.Outdent()
g.Printf("}\n\n")
}
g.Printf("@end\n\n")
}
func (g *ObjcGen) genInitH(obj *types.TypeName, f *types.Func) {
s := g.funcSummary(obj, f)
doc := g.docs[f.Name()]
g.objcdoc(doc.Doc())
// custom inits can return nil in Go so make them nullable
g.Printf("- (nullable instancetype)%s%s;\n", s.initName, s.asInitSignature(g))
}
func (g *ObjcGen) genInitM(obj *types.TypeName, f *types.Func) {
s := g.funcSummary(obj, f)
g.Printf("- (instancetype)%s%s {\n", s.initName, s.asInitSignature(g))
g.Indent()
g.Printf("self = [super init];\n")
g.Printf("if (!self) return nil;\n")
for _, p := range s.params {
g.genWrite(p.name, p.typ, modeTransient)
}
// Constructors always return a mandatory *T and an optional error
if len(s.retParams) == 1 {
g.Printf("%s refnum = ", g.cgoType(s.retParams[0].typ))
} else {
g.Printf("struct proxy%s__%s_return res = ", g.pkgPrefix, s.goname)
}
g.Printf("proxy%s__%s(", g.pkgPrefix, s.goname)
for i, p := range s.params {
if i > 0 {
g.Printf(", ")
}
g.Printf("_%s", p.name)
}
g.Printf(");\n")
for _, p := range s.params {
g.genRelease(p.name, p.typ, modeTransient)
}
if len(s.retParams) == 2 {
g.Printf("int32_t refnum = res.r0;\n")
g.Printf("GoSeqRef *_err = go_seq_from_refnum(res.r1);\n")
}
g.Printf("__ref = go_seq_from_refnum(refnum);\n")
if len(s.retParams) == 2 {
g.Printf("if (_err != NULL)\n")
g.Printf(" return nil;\n")
}
g.Printf("return self;\n")
g.Outdent()
g.Printf("}\n\n")
}
func (g *ObjcGen) errorf(format string, args ...interface{}) {
g.err = append(g.err, fmt.Errorf(format, args...))
}
func (g *ObjcGen) refTypeBase(typ types.Type) string {
switch typ := typ.(type) {
case *types.Pointer:
if _, ok := typ.Elem().(*types.Named); ok {
return g.objcType(typ.Elem())
}
case *types.Named:
n := typ.Obj()
if isObjcType(typ) {
return g.wrapMap[n.Name()].Name
}
if isErrorType(typ) || g.validPkg(n.Pkg()) {
switch typ.Underlying().(type) {
case *types.Interface, *types.Struct:
return g.namePrefixOf(n.Pkg()) + n.Name()
}
}
}
// fallback to whatever objcType returns. This must not happen.
return g.objcType(typ)
}
func (g *ObjcGen) objcParamType(t types.Type) string {
switch typ := t.(type) {
case *types.Basic:
switch typ.Kind() {
case types.String, types.UntypedString:
return "NSString* _Nullable"
}
}
return g.objcType(t)
}
func (g *ObjcGen) objcType(typ types.Type) string {
if isErrorType(typ) {
return "NSError* _Nullable"
}
switch typ := typ.(type) {
case *types.Basic:
switch typ.Kind() {
case types.Bool, types.UntypedBool:
return "BOOL"
case types.Int:
return "long"
case types.Int8:
return "int8_t"
case types.Int16:
return "int16_t"
case types.Int32, types.UntypedRune: // types.Rune
return "int32_t"
case types.Int64, types.UntypedInt:
return "int64_t"
case types.Uint8:
// byte is an alias of uint8, and the alias is lost.
return "byte"
case types.Uint16:
return "uint16_t"
case types.Uint32:
return "uint32_t"
case types.Uint64:
return "uint64_t"
case types.Float32:
return "float"
case types.Float64, types.UntypedFloat:
return "double"
case types.String, types.UntypedString:
return "NSString* _Nonnull"
default:
g.errorf("unsupported type: %s", typ)
return "TODO"
}
case *types.Slice:
elem := g.objcType(typ.Elem())
// Special case: NSData seems to be a better option for byte slice.
if elem == "byte" {
return "NSData* _Nullable"
}
// TODO(hyangah): support other slice types: NSArray or CFArrayRef.
// Investigate the performance implication.
g.errorf("unsupported type: %s", typ)
return "TODO"
case *types.Pointer:
if _, ok := typ.Elem().(*types.Named); ok {
return g.objcType(typ.Elem()) + "* _Nullable"
}
g.errorf("unsupported pointer to type: %s", typ)
return "TODO"
case *types.Named:
n := typ.Obj()
if isObjcType(typ) {
w := g.wrapMap[n.Name()]
return w.ObjcType()
}
if !isErrorType(typ) && !g.validPkg(n.Pkg()) {
g.errorf("type %s is in package %s, which is not bound", n.Name(), n.Pkg().Name())
return "TODO"
}
switch t := typ.Underlying().(type) {
case *types.Interface:
if makeIfaceSummary(t).implementable {
return "id<" + g.namePrefixOf(n.Pkg()) + n.Name() + "> _Nullable"
} else {
return g.namePrefixOf(n.Pkg()) + n.Name() + "* _Nullable"
}
case *types.Struct:
return g.namePrefixOf(n.Pkg()) + n.Name()
}
g.errorf("unsupported, named type %s", typ)
return "TODO"
default:
g.errorf("unsupported type: %#+v, %s", typ, typ)
return "TODO"
}
}
// embeddedObjcTypes returns the possible empty list of Objc types embedded
// in the given struct type.
func embeddedObjcTypes(t *types.Struct) []string {
typeSet := make(map[string]struct{})
var typs []string
for i := 0; i < t.NumFields(); i++ {
f := t.Field(i)
if !f.Exported() {
continue
}
if ft := f.Type(); isObjcType(ft) {
name := ft.(*types.Named).Obj().Name()
if _, exists := typeSet[name]; !exists {
typeSet[name] = struct{}{}
typs = append(typs, name)
}
}
}
return typs
}
func isObjcType(t types.Type) bool {
return typePkgFirstElem(t) == "ObjC"
}
var objcNameReplacer = newNameSanitizer([]string{
"bool", "bycopy", "byref", "char", "const", "double", "float",
"id", "in", "init", "inout", "int", "long", "nil", "oneway",
"out", "self", "short", "signed", "super", "unsigned", "void",
"volatile"})
const (
objcPreamble = `// Objective-C API for talking to %[1]s Go package.
// gobind %[2]s %[3]s
//
// File is generated by gobind. Do not edit.
`
)