func CairoCgoToGoForInterface(bi *gi.BaseInfo, arg1, arg2 string, flags ConvFlags) string {
var out bytes.Buffer
p := PrinterTo(&out)
name := bi.Name()
switch name {
case "Path", "FontOptions":
if flags&ConvPointer == 0 {
panic("unexpected non-pointer type")
}
p("%s = (*cairo.%s)(cairo.%sWrap(unsafe.Pointer(%s)))", arg2, name, name, arg1)
case "Surface", "Region", "Pattern", "Context", "FontFace", "ScaledFont":
if flags&ConvPointer == 0 {
panic("unexpected non-pointer type")
}
grab := "true"
if flags&ConvOwnEverything != 0 {
grab = "false"
}
p("%s = (*cairo.%s)(cairo.%sWrap(unsafe.Pointer(%s), %s))", arg2, name, name, arg1, grab)
default:
gotype := GoTypeForInterface(bi, TypeReturn)
if flags&ConvPointer != 0 {
p("%s = (*%s)(unsafe.Pointer(%s))",
arg2, gotype, arg1)
} else {
p("%s = *(*%s)(unsafe.Pointer(&%s))",
arg2, gotype, arg1)
}
}
return out.String()
}
func CForwardDeclaration20(bi *gi.BaseInfo) {
switch bi.Type() {
case gi.INFO_TYPE_FUNCTION:
fi := gi.ToFunctionInfo(bi)
CFuncForwardDeclaration(fi, nil)
case gi.INFO_TYPE_OBJECT:
oi := gi.ToObjectInfo(bi)
for i, n := 0, oi.NumMethod(); i < n; i++ {
meth := oi.Method(i)
CFuncForwardDeclaration(meth, bi)
}
printf("extern GType %s();\n", oi.TypeInit())
case gi.INFO_TYPE_INTERFACE:
ii := gi.ToInterfaceInfo(bi)
for i, n := 0, ii.NumMethod(); i < n; i++ {
meth := ii.Method(i)
CFuncForwardDeclaration(meth, bi)
}
printf("extern GType %s();\n", ii.TypeInit())
case gi.INFO_TYPE_STRUCT:
si := gi.ToStructInfo(bi)
for i, n := 0, si.NumMethod(); i < n; i++ {
meth := si.Method(i)
CFuncForwardDeclaration(meth, bi)
}
case gi.INFO_TYPE_UNION:
ui := gi.ToUnionInfo(bi)
for i, n := 0, ui.NumMethod(); i < n; i++ {
meth := ui.Method(i)
CFuncForwardDeclaration(meth, bi)
}
}
}
func CairoGoToCgoForInterface(bi *gi.BaseInfo, arg0, arg1 string, flags ConvFlags) string {
var out bytes.Buffer
p := PrinterTo(&out)
name := bi.Name()
switch name {
case "Surface", "Pattern":
p("if %s != nil {\n", arg0)
p("\t%s = (*C.cairo%s)(%s.InheritedFromCairo%s().C)\n", arg1, name, arg0, name)
p("}")
case "RectangleInt", "Rectangle", "TextCluster", "Matrix":
ctype := CgoTypeForInterface(bi, TypeNone)
if flags&ConvPointer != 0 {
p("%s = (*%s)(unsafe.Pointer(%s))",
arg1, ctype, arg0)
} else {
p("%s = *(*%s)(unsafe.Pointer(&%s))",
arg1, ctype, arg0)
}
default:
p("if %s != nil {\n", arg0)
p("\t%s = (*C.cairo%s)(%s.C)\n", arg1, name, arg0)
p("}")
}
return out.String()
}
func (this *binding_generator) c_forward_declaration20(bi *gi.BaseInfo) {
p := printer_to(this.out_h)
switch bi.Type() {
case gi.INFO_TYPE_FUNCTION:
fi := gi.ToFunctionInfo(bi)
this.c_func_forward_declaration(fi)
case gi.INFO_TYPE_OBJECT:
oi := gi.ToObjectInfo(bi)
for i, n := 0, oi.NumMethod(); i < n; i++ {
meth := oi.Method(i)
this.c_func_forward_declaration(meth)
}
p("extern GType %s();\n", oi.TypeInit())
case gi.INFO_TYPE_INTERFACE:
ii := gi.ToInterfaceInfo(bi)
for i, n := 0, ii.NumMethod(); i < n; i++ {
meth := ii.Method(i)
this.c_func_forward_declaration(meth)
}
p("extern GType %s();\n", ii.TypeInit())
case gi.INFO_TYPE_STRUCT:
si := gi.ToStructInfo(bi)
for i, n := 0, si.NumMethod(); i < n; i++ {
meth := si.Method(i)
this.c_func_forward_declaration(meth)
}
case gi.INFO_TYPE_UNION:
ui := gi.ToUnionInfo(bi)
for i, n := 0, ui.NumMethod(); i < n; i++ {
meth := ui.Method(i)
this.c_func_forward_declaration(meth)
}
}
}
func (this *binding_generator) process_base_info(bi *gi.BaseInfo) {
p := printer_to(&this.go_bindings)
if config.is_object_blacklisted(bi) {
p("// blacklisted: %s (%s)\n", bi.Name(), bi.Type())
return
}
switch bi.Type() {
case gi.INFO_TYPE_UNION:
this.process_union_info(gi.ToUnionInfo(bi))
case gi.INFO_TYPE_STRUCT:
this.process_struct_info(gi.ToStructInfo(bi))
case gi.INFO_TYPE_ENUM, gi.INFO_TYPE_FLAGS:
this.process_enum_info(gi.ToEnumInfo(bi))
case gi.INFO_TYPE_CONSTANT:
this.process_constant_info(gi.ToConstantInfo(bi))
case gi.INFO_TYPE_CALLBACK:
this.process_callback_info(gi.ToCallableInfo(bi))
case gi.INFO_TYPE_FUNCTION:
this.process_function_info(gi.ToFunctionInfo(bi))
case gi.INFO_TYPE_INTERFACE:
this.process_interface_info(gi.ToInterfaceInfo(bi))
case gi.INFO_TYPE_OBJECT:
this.process_object_info(gi.ToObjectInfo(bi))
default:
p("// TODO: %s (%s)\n", bi.Name(), bi.Type())
}
}
func CairoGoTypeForInterface(bi *gi.BaseInfo, flags TypeFlags) string {
var out bytes.Buffer
p := PrinterTo(&out)
name := bi.Name()
switch name {
case "Surface", "Pattern":
if flags&(TypeReturn) == 0 {
p("cairo.%sLike", name)
break
}
fallthrough
default:
if flags&TypePointer != 0 {
p("*")
}
p("cairo.%s", name)
}
return out.String()
}
func (this *binding_generator) c_forward_declaration10(bi *gi.BaseInfo) {
p := printer_to(this.out_h)
switch bi.Type() {
case gi.INFO_TYPE_OBJECT:
cctype := c_type_for_interface(bi, type_none)
p("typedef struct _%s %s;\n", cctype, cctype)
case gi.INFO_TYPE_FLAGS, gi.INFO_TYPE_ENUM:
ei := gi.ToEnumInfo(bi)
p("typedef %s %s;\n", c_type_for_tag(ei.StorageType(), type_none),
c_type_for_interface(bi, type_none))
case gi.INFO_TYPE_STRUCT, gi.INFO_TYPE_INTERFACE, gi.INFO_TYPE_UNION:
fullnm := strings.ToLower(bi.Namespace()) + "." + bi.Name()
cctype := c_type_for_interface(bi, type_none)
if config.is_disguised(fullnm) {
p("typedef void *%s;\n", cctype)
} else {
p("typedef struct _%s %s;\n", cctype, cctype)
}
case gi.INFO_TYPE_CALLBACK:
pc := printer_to(this.out_c)
ctype := c_type_for_interface(bi, type_none)
// type doesn't matter here, it's just a pointer after all
p("typedef void* %s;\n", ctype)
// and wrapper declarations for .c file only (cgo has problems
// with that)
pc("extern void _%s_c_wrapper();\n", ctype)
pc("extern void _%s_c_wrapper_once();\n", ctype)
}
}
func CForwardDeclaration10(bi *gi.BaseInfo) {
switch bi.Type() {
case gi.INFO_TYPE_OBJECT:
cctype := CTypeForInterface(bi, TypeNone)
printf("typedef struct _%s %s;\n", cctype, cctype)
case gi.INFO_TYPE_FLAGS, gi.INFO_TYPE_ENUM:
ei := gi.ToEnumInfo(bi)
printf("typedef %s %s;\n", CTypeForTag(ei.StorageType(), TypeNone),
CTypeForInterface(bi, TypeNone))
case gi.INFO_TYPE_STRUCT, gi.INFO_TYPE_INTERFACE, gi.INFO_TYPE_UNION:
fullnm := strings.ToLower(bi.Namespace()) + "." + bi.Name()
cctype := CTypeForInterface(bi, TypeNone)
if _, ok := GConfig.Sys.DisguisedTypes[fullnm]; ok {
printf("typedef void *%s;\n", cctype)
} else {
printf("typedef struct _%s %s;\n", cctype, cctype)
}
case gi.INFO_TYPE_CALLBACK:
ctype := CTypeForInterface(bi, TypeNone)
// type doesn't matter here, it's just a pointer after all
printf("typedef void* %s;\n", ctype)
// also generate wrapper declarations
printf("extern void _%s_c_wrapper();\n", ctype)
printf("extern void _%s_c_wrapper_once();\n", ctype)
}
}
func CForwardDeclaration30(bi *gi.BaseInfo) {
fullnm := strings.ToLower(bi.Namespace()) + "." + bi.Name()
switch bi.Type() {
case gi.INFO_TYPE_STRUCT:
si := gi.ToStructInfo(bi)
size := si.Size()
if _, ok := GConfig.Sys.DisguisedTypes[fullnm]; ok {
return
}
cctype := CTypeForInterface(bi, TypeNone)
if size == 0 {
printf("struct _%s {};\n", cctype)
} else {
printf("struct _%s { uint8_t _data[%d]; };\n", cctype, size)
}
case gi.INFO_TYPE_UNION:
ui := gi.ToUnionInfo(bi)
size := ui.Size()
cctype := CTypeForInterface(bi, TypeNone)
if size == 0 {
printf("struct _%s {};\n", cctype)
} else {
printf("struct _%s { uint8_t _data[%d]; };\n", cctype, size)
}
}
}
func (this *binding_generator) c_forward_declaration30(bi *gi.BaseInfo) {
p := printer_to(this.out_h)
fullnm := strings.ToLower(bi.Namespace()) + "." + bi.Name()
switch bi.Type() {
case gi.INFO_TYPE_STRUCT:
si := gi.ToStructInfo(bi)
size := si.Size()
if config.is_disguised(fullnm) {
return
}
cctype := c_type_for_interface(bi, type_none)
if size == 0 {
p("struct _%s {};\n", cctype)
} else {
p("struct _%s { uint8_t _data[%d]; };\n", cctype, size)
}
case gi.INFO_TYPE_UNION:
ui := gi.ToUnionInfo(bi)
size := ui.Size()
cctype := c_type_for_interface(bi, type_none)
if size == 0 {
p("struct _%s {};\n", cctype)
} else {
p("struct _%s { uint8_t _data[%d]; };\n", cctype, size)
}
}
}
func TypeSizeForInterface(bi *gi.BaseInfo, flags TypeFlags) int {
ptrsize := int(unsafe.Sizeof(unsafe.Pointer(nil)))
if flags&TypePointer != 0 {
return ptrsize
}
switch t := bi.Type(); t {
case gi.INFO_TYPE_OBJECT, gi.INFO_TYPE_INTERFACE:
return ptrsize
case gi.INFO_TYPE_STRUCT:
si := gi.ToStructInfo(bi)
return si.Size()
case gi.INFO_TYPE_UNION:
ui := gi.ToUnionInfo(bi)
return ui.Size()
case gi.INFO_TYPE_ENUM, gi.INFO_TYPE_FLAGS:
ei := gi.ToEnumInfo(bi)
return TypeSizeForTag(ei.StorageType(), flags)
case gi.INFO_TYPE_CALLBACK:
return ptrsize
}
panic("unreachable: " + bi.Type().String())
}
func cgo_type_for_interface(bi *gi.BaseInfo, flags type_flags) string {
var out bytes.Buffer
switch bi.Type() {
case gi.INFO_TYPE_CALLBACK:
out.WriteString("unsafe.Pointer")
default:
ns := bi.Namespace()
nm := bi.Name()
fullnm := strings.ToLower(ns) + "." + nm
if flags&type_pointer != 0 && !config.is_disguised(fullnm) {
out.WriteString("*")
}
out.WriteString("C.")
out.WriteString(gi.DefaultRepository().CPrefix(ns))
out.WriteString(bi.Name())
}
return out.String()
}
func CgoTypeForInterface(bi *gi.BaseInfo, flags TypeFlags) string {
var out bytes.Buffer
switch bi.Type() {
case gi.INFO_TYPE_CALLBACK:
out.WriteString("unsafe.Pointer")
default:
ns := bi.Namespace()
nm := bi.Name()
fullnm := strings.ToLower(ns) + "." + nm
_, disguised := GConfig.Sys.DisguisedTypes[fullnm]
if flags&TypePointer != 0 && !disguised {
out.WriteString("*")
}
out.WriteString("C.")
out.WriteString(gi.DefaultRepository().CPrefix(ns))
out.WriteString(bi.Name())
}
return out.String()
}
func CgoToGoForInterface(bi *gi.BaseInfo, arg1, arg2 string, flags ConvFlags) string {
var out bytes.Buffer
printf := PrinterTo(&out)
switch bi.Type() {
case gi.INFO_TYPE_OBJECT, gi.INFO_TYPE_INTERFACE:
gotype := GoTypeForInterface(bi, TypeReturn)
if flags&ConvOwnEverything != 0 {
printf("%s = (*%s)(%sObjectWrap(unsafe.Pointer(%s), false))",
arg2, gotype, Config.Sys.GNS, arg1)
} else {
printf("%s = (*%s)(%sObjectWrap(unsafe.Pointer(%s), true))",
arg2, gotype, Config.Sys.GNS, arg1)
}
case gi.INFO_TYPE_ENUM, gi.INFO_TYPE_FLAGS:
gotype := GoTypeForInterface(bi, TypeReturn)
printf("%s = %s(%s)", arg2, gotype, arg1)
case gi.INFO_TYPE_STRUCT, gi.INFO_TYPE_UNION:
ns := bi.Namespace()
if ns == "cairo" {
printf(CairoCgoToGoForInterface(bi, arg1, arg2, flags))
break
}
fullnm := strings.ToLower(ns) + "." + bi.Name()
gotype := GoTypeForInterface(bi, TypeReturn)
if flags&ConvListMember != 0 {
printf("%s = *(*%s)(unsafe.Pointer(%s))",
arg2, gotype, arg1)
break
}
if _, ok := GConfig.Sys.DisguisedTypes[fullnm]; ok {
printf("%s = %s{unsafe.Pointer(%s)}",
arg2, gotype, arg1)
break
}
if flags&ConvPointer != 0 {
printf("%s = (*%s)(unsafe.Pointer(%s))",
arg2, gotype, arg1)
} else {
printf("%s = *(*%s)(unsafe.Pointer(&%s))",
arg2, gotype, arg1)
}
}
return out.String()
}
func c_type_for_interface(bi *gi.BaseInfo, flags type_flags) string {
var out bytes.Buffer
ns := bi.Namespace()
nm := bi.Name()
fullnm := strings.ToLower(ns) + "." + nm
out.WriteString(gi.DefaultRepository().CPrefix(ns))
out.WriteString(bi.Name())
if flags&type_pointer != 0 && !config.is_disguised(fullnm) {
out.WriteString("*")
}
return out.String()
}
func CTypeForInterface(bi *gi.BaseInfo, flags TypeFlags) string {
var out bytes.Buffer
ns := bi.Namespace()
nm := bi.Name()
fullnm := strings.ToLower(ns) + "." + nm
out.WriteString(gi.DefaultRepository().CPrefix(ns))
out.WriteString(bi.Name())
_, disguised := GConfig.Sys.DisguisedTypes[fullnm]
if flags&TypePointer != 0 && !disguised {
out.WriteString("*")
}
return out.String()
}
func ProcessBaseInfo(bi *gi.BaseInfo) {
switch bi.Type() {
case gi.INFO_TYPE_UNION:
if IsBlacklisted("unions", bi.Name()) {
goto blacklisted
}
ProcessUnionInfo(gi.ToUnionInfo(bi))
case gi.INFO_TYPE_STRUCT:
if IsBlacklisted("structs", bi.Name()) {
goto blacklisted
}
ProcessStructInfo(gi.ToStructInfo(bi))
case gi.INFO_TYPE_ENUM, gi.INFO_TYPE_FLAGS:
if IsBlacklisted("enums", bi.Name()) {
goto blacklisted
}
ProcessEnumInfo(gi.ToEnumInfo(bi))
case gi.INFO_TYPE_CONSTANT:
if IsBlacklisted("constants", bi.Name()) {
goto blacklisted
}
ProcessConstantInfo(gi.ToConstantInfo(bi))
case gi.INFO_TYPE_CALLBACK:
if IsBlacklisted("callbacks", bi.Name()) {
goto blacklisted
}
ProcessCallbackInfo(gi.ToCallableInfo(bi))
case gi.INFO_TYPE_FUNCTION:
if IsBlacklisted("functions", bi.Name()) {
goto blacklisted
}
ProcessFunctionInfo(gi.ToFunctionInfo(bi), nil)
case gi.INFO_TYPE_INTERFACE:
if IsBlacklisted("interfaces", bi.Name()) {
goto blacklisted
}
ProcessInterfaceInfo(gi.ToInterfaceInfo(bi))
case gi.INFO_TYPE_OBJECT:
if IsBlacklisted("objects", bi.Name()) {
goto blacklisted
}
ProcessObjectInfo(gi.ToObjectInfo(bi))
default:
printf("// TODO: %s (%s)\n", bi.Name(), bi.Type())
}
return
blacklisted:
printf("// blacklisted: %s (%s)\n", bi.Name(), bi.Type())
}
func ProcessFunctionInfo(fi *gi.FunctionInfo, container *gi.BaseInfo) {
var fullnm string
flags := fi.Flags()
name := fi.Name()
// --- header
fb := NewFunctionBuilder(fi)
printf("func ")
if flags&gi.FUNCTION_IS_METHOD != 0 {
// add receiver if it's a method
printf("(this0 %s) ",
GoTypeForInterface(container, TypePointer|TypeReceiver))
fullnm = container.Name() + "."
}
switch {
case flags&gi.FUNCTION_IS_CONSTRUCTOR != 0:
// special names for constructors
name = fmt.Sprintf("New%s%s", container.Name(), CtorSuffix(name))
case flags&gi.FUNCTION_IS_METHOD == 0 && container != nil:
name = fmt.Sprintf("%s%s", container.Name(), LowerCaseToCamelCase(name))
default:
name = fmt.Sprintf("%s", LowerCaseToCamelCase(name))
}
fullnm += name
name = Rename(fullnm, name)
printf("%s(", name)
for i, arg := range fb.Args {
printf("%s0 %s", arg.ArgInfo.Name(), GoType(arg.TypeInfo, TypeNone))
if i != len(fb.Args)-1 {
printf(", ")
}
}
printf(")")
switch len(fb.Rets) {
case 0:
// do nothing if there are not return values
case 1:
if flags&gi.FUNCTION_IS_CONSTRUCTOR != 0 {
// override return types for constructors, We can't
// return generic widget here as C does. Go's type
// system is stronger.
printf(" %s",
GoTypeForInterface(container, TypePointer|TypeReturn))
break
}
if fb.Rets[0].Index == -2 {
printf(" error")
} else {
printf(" %s", GoType(fb.Rets[0].TypeInfo, TypeReturn))
}
default:
printf(" (")
for i, ret := range fb.Rets {
if ret.Index == -2 {
// special error type in Go to represent GError
printf("error")
continue
}
printf(GoType(ret.TypeInfo, TypeReturn))
if i != len(fb.Rets)-1 {
printf(", ")
}
}
printf(")")
}
printf(" {\n")
// --- body stage 1 (Go to C conversions)
// var declarations
if flags&gi.FUNCTION_IS_METHOD != 0 {
printf("\tvar this1 %s\n", CgoTypeForInterface(container, TypePointer))
}
for _, arg := range fb.Args {
printf("\tvar %s1 %s\n", arg.ArgInfo.Name(),
CgoType(arg.TypeInfo, TypeNone))
if al := arg.TypeInfo.ArrayLength(); al != -1 {
arg := fb.OrigArgs[al]
printf("\tvar %s1 %s\n", arg.Name(),
CgoType(arg.Type(), TypeNone))
}
}
for _, ret := range fb.Rets {
if ret.Index == -1 {
continue
}
if ret.Index == -2 {
printf("\tvar err1 *C.GError\n")
continue
}
if ret.ArgInfo.Direction() == gi.DIRECTION_INOUT {
continue
}
printf("\tvar %s1 %s\n", ret.ArgInfo.Name(),
CgoType(ret.TypeInfo, TypeNone))
if al := ret.TypeInfo.ArrayLength(); al != -1 {
arg := fb.OrigArgs[al]
printf("\tvar %s1 %s\n", arg.Name(),
CgoType(arg.Type(), TypeNone))
}
}
// conversions
if flags&gi.FUNCTION_IS_METHOD != 0 {
conv := GoToCgoForInterface(container, "this0", "this1", ConvPointer)
printf("%s", PrintLinesWithIndent(conv))
}
for _, arg := range fb.Args {
nm := arg.ArgInfo.Name()
conv := GoToCgo(arg.TypeInfo, nm+"0", nm+"1", ConvNone)
printf("%s", PrintLinesWithIndent(conv))
// register callback in the global map
if arg.TypeInfo.Tag() == gi.TYPE_TAG_INTERFACE {
bi := arg.TypeInfo.Interface()
if bi.Type() == gi.INFO_TYPE_CALLBACK {
if arg.ArgInfo.Scope() != gi.SCOPE_TYPE_CALL {
printf("\t%sHolder.Grab(%s1)\n", Config.Sys.GNS, nm)
}
}
}
// array length
if len := arg.TypeInfo.ArrayLength(); len != -1 {
lenarg := fb.OrigArgs[len]
conv = GoToCgo(lenarg.Type(),
"len("+nm+"0)", lenarg.Name()+"1", ConvNone)
printf("\t%s\n", conv)
}
}
// --- body stage 2 (the function call)
printf("\t")
if fb.HasReturnValue() {
printf("ret1 := ")
}
userdata, destroy, scope := fb.HasClosureArgument()
printf("C.")
if scope != gi.SCOPE_TYPE_INVALID {
printf("_")
}
printf("%s(", fi.Symbol())
if flags&gi.FUNCTION_IS_METHOD != 0 {
printf("this1")
if len(fb.OrigArgs) > 0 {
printf(", ")
}
}
for i, ri, n := 0, 0, len(fb.OrigArgs); i < n; i++ {
if i == userdata || i == destroy {
continue
}
oarg := fb.OrigArgs[i]
var arg string
dir := oarg.Direction()
if dir == gi.DIRECTION_INOUT || dir == gi.DIRECTION_OUT {
arg = fmt.Sprintf("&%s1", oarg.Name())
} else {
arg = fmt.Sprintf("%s1", oarg.Name())
}
if ri != 0 {
printf(", ")
}
printf("%s", arg)
ri++
}
if flags&gi.FUNCTION_THROWS != 0 {
printf(", &err1")
}
printf(")\n")
// --- body stage 3 (C to Go conversions)
// var declarations
for _, ret := range fb.Rets {
switch ret.Index {
case -1:
if flags&gi.FUNCTION_IS_CONSTRUCTOR != 0 {
printf("\tvar ret2 %s\n",
GoTypeForInterface(container, TypePointer|TypeReturn))
} else {
printf("\tvar ret2 %s\n", GoType(ret.TypeInfo, TypeReturn))
}
case -2:
printf("\tvar err2 error\n")
default:
printf("\tvar %s2 %s\n", ret.ArgInfo.Name(),
GoType(ret.TypeInfo, TypeReturn))
}
}
// conversions
for _, ret := range fb.Rets {
if ret.Index == -2 {
printf("\tif err1 != nil {\n")
printf("\t\terr2 = errors.New(C.GoString(((*_GError)(unsafe.Pointer(err1))).message))\n")
printf("\t\tC.g_error_free(err1)\n")
printf("\t}\n")
continue
}
var nm string
if ret.Index == -1 {
nm = "ret"
} else {
nm = ret.ArgInfo.Name()
}
// array length
if len := ret.TypeInfo.ArrayLength(); len != -1 {
lenarg := fb.OrigArgs[len]
printf("\t%s2 = make(%s, %s)\n",
nm, GoType(ret.TypeInfo, TypeReturn),
lenarg.Name()+"1")
}
var ownership gi.Transfer
if ret.Index == -1 {
ownership = fi.CallerOwns()
} else {
ownership = ret.ArgInfo.OwnershipTransfer()
if ret.ArgInfo.Direction() == gi.DIRECTION_INOUT {
// not sure if it's true in all cases, but so far
ownership = gi.TRANSFER_NOTHING
}
}
var conv string
if flags&gi.FUNCTION_IS_CONSTRUCTOR != 0 && ret.Index == -1 {
conv = CgoToGoForInterface(container, "ret1", "ret2",
ConvPointer|OwnershipToConvFlags(ownership))
} else {
conv = CgoToGo(ret.TypeInfo, nm+"1", nm+"2",
OwnershipToConvFlags(ownership))
}
printf("%s", PrintLinesWithIndent(conv))
}
// --- body stage 4 (return)
if len(fb.Rets) == 0 {
printf("}\n")
return
}
printf("\treturn ")
for i, ret := range fb.Rets {
var nm string
switch ret.Index {
case -1:
nm = "ret2"
case -2:
nm = "err2"
default:
nm = ret.ArgInfo.Name() + "2"
}
if i != 0 {
printf(", ")
}
printf(nm)
}
printf("\n}\n")
}
func go_type_for_interface(bi *gi.BaseInfo, flags type_flags) string {
var out bytes.Buffer
printf := printer_to(&out)
ns := bi.Namespace()
fullnm := strings.ToLower(ns) + "." + bi.Name()
if flags&type_list_member != 0 {
switch bi.Type() {
case gi.INFO_TYPE_OBJECT, gi.INFO_TYPE_INTERFACE:
return go_type_for_interface(bi, type_pointer|type_return)
default:
return go_type_for_interface(bi, type_return)
}
}
switch t := bi.Type(); t {
case gi.INFO_TYPE_OBJECT, gi.INFO_TYPE_INTERFACE:
if flags&type_exact != 0 {
// exact type for object/interface is always an unsafe.Pointer
printf("unsafe.Pointer")
break
}
if flags&(type_return|type_receiver) != 0 && flags&type_pointer != 0 {
// receivers and return values are actual types,
// and a pointer most likely
printf("*")
}
if ns != config.namespace {
// prepend foreign types with appropriate namespace
printf("%s.", strings.ToLower(ns))
}
printf(bi.Name())
if flags&(type_return|type_receiver) == 0 {
// ordinary function arguments are substituted by their *Like
// counterparts
printf("Like")
}
if flags&type_receiver != 0 && t == gi.INFO_TYPE_INTERFACE {
// special case for interfaces, we use *Impl structures
// as receivers
printf("Impl")
}
case gi.INFO_TYPE_CALLBACK:
if flags&type_exact != 0 {
printf("unsafe.Pointer")
break
}
goto handle_default
case gi.INFO_TYPE_STRUCT:
if ns == "cairo" {
printf(cairo_go_type_for_interface(bi, flags))
break
}
goto handle_default
default:
goto handle_default
}
return out.String()
handle_default:
if flags&type_pointer != 0 && !config.is_disguised(fullnm) {
printf("*")
}
if ns != config.namespace {
printf("%s.", strings.ToLower(ns))
}
printf(bi.Name())
return out.String()
}
func GoToCgoForInterface(bi *gi.BaseInfo, arg0, arg1 string, flags ConvFlags) string {
var out bytes.Buffer
printf := PrinterTo(&out)
switch bi.Type() {
case gi.INFO_TYPE_OBJECT:
prefix := gi.DefaultRepository().CPrefix(bi.Namespace())
printf("if %s != nil {\n", arg0)
printf("\t%s = %s.InheritedFrom%s%s()\n",
arg1, arg0, prefix, bi.Name())
printf("}")
case gi.INFO_TYPE_ENUM, gi.INFO_TYPE_FLAGS:
ctype := CgoTypeForInterface(bi, TypeNone)
printf("%s = %s(%s)", arg1, ctype, arg0)
case gi.INFO_TYPE_INTERFACE:
prefix := gi.DefaultRepository().CPrefix(bi.Namespace())
printf("if %s != nil {\n", arg0)
printf("\t%s = %s.Implements%s%s()",
arg1, arg0, prefix, bi.Name())
printf("}")
case gi.INFO_TYPE_STRUCT:
ns := bi.Namespace()
if ns == "cairo" {
printf(CairoGoToCgoForInterface(bi, arg0, arg1, flags))
break
}
fullnm := strings.ToLower(ns) + "." + bi.Name()
if _, ok := GConfig.Sys.DisguisedTypes[fullnm]; ok {
flags &^= ConvPointer
}
ctype := CgoTypeForInterface(bi, TypeNone)
if flags&ConvPointer != 0 {
printf("%s = (*%s)(unsafe.Pointer(%s))",
arg1, ctype, arg0)
} else {
printf("%s = *(*%s)(unsafe.Pointer(&%s))",
arg1, ctype, arg0)
}
case gi.INFO_TYPE_CALLBACK:
printf("if %s != nil {\n", arg0)
printf("\t%s = unsafe.Pointer(&%s)", arg1, arg0)
printf("}")
}
return out.String()
}
func (this *config_type) is_object_blacklisted(bi *gi.BaseInfo) bool {
switch bi.Type() {
case gi.INFO_TYPE_UNION:
return config.is_blacklisted("unions", bi.Name())
case gi.INFO_TYPE_STRUCT:
return config.is_blacklisted("structs", bi.Name())
case gi.INFO_TYPE_ENUM, gi.INFO_TYPE_FLAGS:
return config.is_blacklisted("enums", bi.Name())
case gi.INFO_TYPE_CONSTANT:
return config.is_blacklisted("constants", bi.Name())
case gi.INFO_TYPE_CALLBACK:
return config.is_blacklisted("callbacks", bi.Name())
case gi.INFO_TYPE_FUNCTION:
c := bi.Container()
if c != nil {
return config.is_method_blacklisted(c.Name(), bi.Name())
}
return config.is_blacklisted("functions", bi.Name())
case gi.INFO_TYPE_INTERFACE:
return config.is_blacklisted("interfaces", bi.Name())
case gi.INFO_TYPE_OBJECT:
return config.is_blacklisted("objects", bi.Name())
default:
println("TODO: %s (%s)\n", bi.Name(), bi.Type())
return true
}
panic("unreachable")
}
func GoTypeForInterface(bi *gi.BaseInfo, flags TypeFlags) string {
var out bytes.Buffer
printf := PrinterTo(&out)
ns := bi.Namespace()
fullnm := strings.ToLower(ns) + "." + bi.Name()
if flags&TypeListMember != 0 {
switch bi.Type() {
case gi.INFO_TYPE_OBJECT, gi.INFO_TYPE_INTERFACE:
return GoTypeForInterface(bi, TypePointer|TypeReturn)
default:
return GoTypeForInterface(bi, TypeReturn)
}
}
switch t := bi.Type(); t {
case gi.INFO_TYPE_OBJECT, gi.INFO_TYPE_INTERFACE:
if flags&TypeExact != 0 {
// exact type for object/interface is always an unsafe.Pointer
printf("unsafe.Pointer")
break
}
if flags&(TypeReturn|TypeReceiver) != 0 && flags&TypePointer != 0 {
// receivers and return values are actual types,
// and a pointer most likely
printf("*")
}
if ns != Config.Namespace {
// prepend foreign types with appropriate namespace
printf("%s.", strings.ToLower(ns))
}
printf(bi.Name())
if flags&(TypeReturn|TypeReceiver) == 0 {
// ordinary function arguments are substituted by their *Like
// counterparts
printf("Like")
}
if flags&TypeReceiver != 0 && t == gi.INFO_TYPE_INTERFACE {
// special case for interfaces, we use *Impl structures
// as receivers
printf("Impl")
}
case gi.INFO_TYPE_CALLBACK:
if flags&TypeExact != 0 {
printf("unsafe.Pointer")
break
}
goto handle_default
case gi.INFO_TYPE_STRUCT:
if ns == "cairo" {
printf(CairoGoTypeForInterface(bi, flags))
break
}
goto handle_default
default:
goto handle_default
}
return out.String()
handle_default:
_, disguised := GConfig.Sys.DisguisedTypes[fullnm]
if flags&TypePointer != 0 && !disguised {
printf("*")
}
if ns != Config.Namespace {
printf("%s.", strings.ToLower(ns))
}
printf(bi.Name())
return out.String()
}
