eb0e2e4 Gen: Re-run script · purego

M v4/adw/adw-animation-target.go +22 -18

 func NewCallbackAnimationTarget(CallbackVar *AnimationTargetFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) *CallbackAnimationTarget {
 	var cls *CallbackAnimationTarget
-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
 	var CallbackVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
+	if CallbackVar != nil {
-		CallbackVarRef = cbRefPtr
+		CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
-		fcb := func(arg0 float64, arg1 uintptr) {
+			CallbackVarRef = cbRefPtr
-			cbFn := *CallbackVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 float64, arg1 uintptr) {
+				cbFn := *CallbackVar
+				cbFn(arg0, arg1)
+			}
+			CallbackVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 		}
-		CallbackVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 	}
-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
 	var DestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
+	if DestroyVar != nil {
-		DestroyVarRef = cbRefPtr
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyVarRef = cbRefPtr
-			cbFn := *DestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 		}
-		DestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 	}
 	cret := xNewCallbackAnimationTarget(CallbackVarRef, UserDataVar, DestroyVarRef)

M v4/adw/adw-preferences-group.go +11 -9

 		}
 	}
-	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
 	var UserDataFreeFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
+	if UserDataFreeFuncVar != nil {
-		UserDataFreeFuncVarRef = cbRefPtr
+		UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			UserDataFreeFuncVarRef = cbRefPtr
-			cbFn := *UserDataFreeFuncVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *UserDataFreeFuncVar
+				cbFn(arg0)
+			}
+			UserDataFreeFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
 		}
-		UserDataFreeFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
 	}
 	xPreferencesGroupBindModel(x.GoPointer(), ModelVar.GoPointer(), CreateRowFuncVarRef, UserDataVar, UserDataFreeFuncVarRef)

M v4/gdk/gdkcontentdeserializer.go +33 -27

 // so applications can override the built-in deserializers.
 func ContentRegisterDeserializer(MimeTypeVar string, TypeVar types.GType, DeserializeVar *ContentDeserializeFunc, DataVar uintptr, NotifyVar *glib.DestroyNotify) {
-	DeserializeVarPtr := uintptr(unsafe.Pointer(DeserializeVar))
 	var DeserializeVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DeserializeVarPtr); ok {
+	if DeserializeVar != nil {
-		DeserializeVarRef = cbRefPtr
+		DeserializeVarPtr := uintptr(unsafe.Pointer(DeserializeVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DeserializeVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DeserializeVarRef = cbRefPtr
-			cbFn := *DeserializeVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DeserializeVar
+				cbFn(arg0)
+			}
+			DeserializeVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DeserializeVarPtr, DeserializeVarRef)
 		}
-		DeserializeVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DeserializeVarPtr, DeserializeVarRef)
 	}
-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
 	var NotifyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
+	if NotifyVar != nil {
-		NotifyVarRef = cbRefPtr
+		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			NotifyVarRef = cbRefPtr
-			cbFn := *NotifyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *NotifyVar
+				cbFn(arg0)
+			}
+			NotifyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 		}
-		NotifyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 	}
 	xContentRegisterDeserializer(MimeTypeVar, TypeVar, DeserializeVarRef, DataVar, NotifyVarRef)
 // Associate data with the current deserialization operation.
 func (x *ContentDeserializer) SetTaskData(DataVar uintptr, NotifyVar *glib.DestroyNotify) {
-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
 	var NotifyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
+	if NotifyVar != nil {
-		NotifyVarRef = cbRefPtr
+		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			NotifyVarRef = cbRefPtr
-			cbFn := *NotifyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *NotifyVar
+				cbFn(arg0)
+			}
+			NotifyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 		}
-		NotifyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 	}
 	xContentDeserializerSetTaskData(x.GoPointer(), DataVar, NotifyVarRef)

M v4/gdk/gdkcontentserializer.go +33 -27

 // so applications can override the built-in serializers.
 func ContentRegisterSerializer(TypeVar types.GType, MimeTypeVar string, SerializeVar *ContentSerializeFunc, DataVar uintptr, NotifyVar *glib.DestroyNotify) {
-	SerializeVarPtr := uintptr(unsafe.Pointer(SerializeVar))
 	var SerializeVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(SerializeVarPtr); ok {
+	if SerializeVar != nil {
-		SerializeVarRef = cbRefPtr
+		SerializeVarPtr := uintptr(unsafe.Pointer(SerializeVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(SerializeVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			SerializeVarRef = cbRefPtr
-			cbFn := *SerializeVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *SerializeVar
+				cbFn(arg0)
+			}
+			SerializeVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(SerializeVarPtr, SerializeVarRef)
 		}
-		SerializeVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(SerializeVarPtr, SerializeVarRef)
 	}
-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
 	var NotifyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
+	if NotifyVar != nil {
-		NotifyVarRef = cbRefPtr
+		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			NotifyVarRef = cbRefPtr
-			cbFn := *NotifyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *NotifyVar
+				cbFn(arg0)
+			}
+			NotifyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 		}
-		NotifyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 	}
 	xContentRegisterSerializer(TypeVar, MimeTypeVar, SerializeVarRef, DataVar, NotifyVarRef)
 // Associate data with the current serialization operation.
 func (x *ContentSerializer) SetTaskData(DataVar uintptr, NotifyVar *glib.DestroyNotify) {
-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
 	var NotifyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
+	if NotifyVar != nil {
-		NotifyVarRef = cbRefPtr
+		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			NotifyVarRef = cbRefPtr
-			cbFn := *NotifyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *NotifyVar
+				cbFn(arg0)
+			}
+			NotifyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 		}
-		NotifyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 	}
 	xContentSerializerSetTaskData(x.GoPointer(), DataVar, NotifyVarRef)

M v4/gdk/gdkcursor.go +22 -18

 func NewCursorFromCallback(CallbackVar *CursorGetTextureCallback, DataVar uintptr, DestroyVar *glib.DestroyNotify, FallbackVar *Cursor) *Cursor {
 	var cls *Cursor
-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
 	var CallbackVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
+	if CallbackVar != nil {
-		CallbackVarRef = cbRefPtr
+		CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 int, arg2 float64, arg3 *int, arg4 *int, arg5 *int, arg6 *int, arg7 uintptr) uintptr {
+			CallbackVarRef = cbRefPtr
-			cbFn := *CallbackVar
+		} else {
-			return cbFn(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+			fcb := func(arg0 uintptr, arg1 int, arg2 float64, arg3 *int, arg4 *int, arg5 *int, arg6 *int, arg7 uintptr) uintptr {
+				cbFn := *CallbackVar
+				return cbFn(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+			}
+			CallbackVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 		}
-		CallbackVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 	}
-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
 	var DestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
+	if DestroyVar != nil {
-		DestroyVarRef = cbRefPtr
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyVarRef = cbRefPtr
-			cbFn := *DestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 		}
-		DestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 	}
 	cret := xNewCursorFromCallback(CallbackVarRef, DataVar, DestroyVarRef, FallbackVar.GoPointer())

M v4/gdk/gdkgltexture.go +11 -9

 func NewGLTexture(ContextVar *GLContext, IdVar uint, WidthVar int, HeightVar int, DestroyVar *glib.DestroyNotify, DataVar uintptr) *GLTexture {
 	var cls *GLTexture
-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
 	var DestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
+	if DestroyVar != nil {
-		DestroyVarRef = cbRefPtr
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyVarRef = cbRefPtr
-			cbFn := *DestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 		}
-		DestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 	}
 	cret := xNewGLTexture(ContextVar.GoPointer(), IdVar, WidthVar, HeightVar, DestroyVarRef, DataVar)

M v4/gdkpixbuf/gdk-pixbuf.go +22 -18

 // See [method@GdkPixbuf.Pixbuf.save] for more details.
 func (x *Pixbuf) SaveToCallback(SaveFuncVar *PixbufSaveFunc, UserDataVar uintptr, TypeVar string, ErrorVar **glib.Error, varArgs ...interface{}) bool {
-	SaveFuncVarPtr := uintptr(unsafe.Pointer(SaveFuncVar))
 	var SaveFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(SaveFuncVarPtr); ok {
+	if SaveFuncVar != nil {
-		SaveFuncVarRef = cbRefPtr
+		SaveFuncVarPtr := uintptr(unsafe.Pointer(SaveFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(SaveFuncVarPtr); ok {
-		fcb := func(arg0 []byte, arg1 uint, arg2 **glib.Error, arg3 uintptr) bool {
+			SaveFuncVarRef = cbRefPtr
-			cbFn := *SaveFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2, arg3)
+			fcb := func(arg0 []byte, arg1 uint, arg2 **glib.Error, arg3 uintptr) bool {
+				cbFn := *SaveFuncVar
+				return cbFn(arg0, arg1, arg2, arg3)
+			}
+			SaveFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(SaveFuncVarPtr, SaveFuncVarRef)
 		}
-		SaveFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(SaveFuncVarPtr, SaveFuncVarRef)
 	}
 	cret := xPixbufSaveToCallback(x.GoPointer(), SaveFuncVarRef, UserDataVar, TypeVar, ErrorVar, varArgs...)
 func (x *Pixbuf) SaveToCallbackv(SaveFuncVar *PixbufSaveFunc, UserDataVar uintptr, TypeVar string, OptionKeysVar []string, OptionValuesVar []string) (bool, error) {
 	var cerr *glib.Error
-	SaveFuncVarPtr := uintptr(unsafe.Pointer(SaveFuncVar))
 	var SaveFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(SaveFuncVarPtr); ok {
+	if SaveFuncVar != nil {
-		SaveFuncVarRef = cbRefPtr
+		SaveFuncVarPtr := uintptr(unsafe.Pointer(SaveFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(SaveFuncVarPtr); ok {
-		fcb := func(arg0 []byte, arg1 uint, arg2 **glib.Error, arg3 uintptr) bool {
+			SaveFuncVarRef = cbRefPtr
-			cbFn := *SaveFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2, arg3)
+			fcb := func(arg0 []byte, arg1 uint, arg2 **glib.Error, arg3 uintptr) bool {
+				cbFn := *SaveFuncVar
+				return cbFn(arg0, arg1, arg2, arg3)
+			}
+			SaveFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(SaveFuncVarPtr, SaveFuncVarRef)
 		}
-		SaveFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(SaveFuncVarPtr, SaveFuncVarRef)
 	}
 	cret := xPixbufSaveToCallbackv(x.GoPointer(), SaveFuncVarRef, UserDataVar, TypeVar, OptionKeysVar, OptionValuesVar, &cerr)

M v4/gio/gcancellable.go +11 -9

 //   - [method@Gio.Cancellable.release_fd]
 func (x *Cancellable) Connect(CallbackVar *gobject.Callback, DataVar uintptr, DataDestroyFuncVar *glib.DestroyNotify) uint32 {
-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
 	var CallbackVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
+	if CallbackVar != nil {
-		CallbackVarRef = cbRefPtr
+		CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
-		fcb := func() {
+			CallbackVarRef = cbRefPtr
-			cbFn := *CallbackVar
+		} else {
-			cbFn()
+			fcb := func() {
+				cbFn := *CallbackVar
+				cbFn()
+			}
+			CallbackVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 		}
-		CallbackVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 	}
 	var DataDestroyFuncVarRef uintptr

M v4/gio/gdbusconnection.go +55 -45

 // destroyed.)
 func (x *DBusConnection) AddFilter(FilterFunctionVar *DBusMessageFilterFunction, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {
-	FilterFunctionVarPtr := uintptr(unsafe.Pointer(FilterFunctionVar))
 	var FilterFunctionVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FilterFunctionVarPtr); ok {
+	if FilterFunctionVar != nil {
-		FilterFunctionVarRef = cbRefPtr
+		FilterFunctionVarPtr := uintptr(unsafe.Pointer(FilterFunctionVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FilterFunctionVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 bool, arg3 uintptr) uintptr {
+			FilterFunctionVarRef = cbRefPtr
-			cbFn := *FilterFunctionVar
+		} else {
-			return cbFn(arg0, arg1, arg2, arg3)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 bool, arg3 uintptr) uintptr {
+				cbFn := *FilterFunctionVar
+				return cbFn(arg0, arg1, arg2, arg3)
+			}
+			FilterFunctionVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FilterFunctionVarPtr, FilterFunctionVarRef)
 		}
-		FilterFunctionVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FilterFunctionVarPtr, FilterFunctionVarRef)
 	}
-	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
 	var UserDataFreeFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
+	if UserDataFreeFuncVar != nil {
-		UserDataFreeFuncVarRef = cbRefPtr
+		UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			UserDataFreeFuncVarRef = cbRefPtr
-			cbFn := *UserDataFreeFuncVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *UserDataFreeFuncVar
+				cbFn(arg0)
+			}
+			UserDataFreeFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
 		}
-		UserDataFreeFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
 	}
 	cret := xDBusConnectionAddFilter(x.GoPointer(), FilterFunctionVarRef, UserDataVar, UserDataFreeFuncVarRef)
 func (x *DBusConnection) RegisterObject(ObjectPathVar string, InterfaceInfoVar *DBusInterfaceInfo, VtableVar *DBusInterfaceVTable, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) (uint, error) {
 	var cerr *glib.Error
-	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
 	var UserDataFreeFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
+	if UserDataFreeFuncVar != nil {
-		UserDataFreeFuncVarRef = cbRefPtr
+		UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			UserDataFreeFuncVarRef = cbRefPtr
-			cbFn := *UserDataFreeFuncVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *UserDataFreeFuncVar
+				cbFn(arg0)
+			}
+			UserDataFreeFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
 		}
-		UserDataFreeFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
 	}
 	cret := xDBusConnectionRegisterObject(x.GoPointer(), ObjectPathVar, InterfaceInfoVar, VtableVar, UserDataVar, UserDataFreeFuncVarRef, &cerr)
 func (x *DBusConnection) RegisterSubtree(ObjectPathVar string, VtableVar *DBusSubtreeVTable, FlagsVar DBusSubtreeFlags, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) (uint, error) {
 	var cerr *glib.Error
-	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
 	var UserDataFreeFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
+	if UserDataFreeFuncVar != nil {
-		UserDataFreeFuncVarRef = cbRefPtr
+		UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			UserDataFreeFuncVarRef = cbRefPtr
-			cbFn := *UserDataFreeFuncVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *UserDataFreeFuncVar
+				cbFn(arg0)
+			}
+			UserDataFreeFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
 		}
-		UserDataFreeFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
 	}
 	cret := xDBusConnectionRegisterSubtree(x.GoPointer(), ObjectPathVar, VtableVar, FlagsVar, UserDataVar, UserDataFreeFuncVarRef, &cerr)
 // This function can never fail.
 func (x *DBusConnection) SignalSubscribe(SenderVar string, InterfaceNameVar string, MemberVar string, ObjectPathVar string, Arg0Var string, FlagsVar DBusSignalFlags, CallbackVar *DBusSignalCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {
-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
 	var CallbackVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
+	if CallbackVar != nil {
-		CallbackVarRef = cbRefPtr
+		CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 string, arg2 string, arg3 string, arg4 string, arg5 *glib.Variant, arg6 uintptr) {
+			CallbackVarRef = cbRefPtr
-			cbFn := *CallbackVar
+		} else {
-			cbFn(arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+			fcb := func(arg0 uintptr, arg1 string, arg2 string, arg3 string, arg4 string, arg5 *glib.Variant, arg6 uintptr) {
+				cbFn := *CallbackVar
+				cbFn(arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+			}
+			CallbackVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 		}
-		CallbackVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 	}
 	var UserDataFreeFuncVarRef uintptr

M v4/gio/gioscheduler.go +11 -9

 // g_io_scheduler_cancel_all_jobs().
 func IoSchedulerPushJob(JobFuncVar *IOSchedulerJobFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify, IoPriorityVar int, CancellableVar *Cancellable) {
-	JobFuncVarPtr := uintptr(unsafe.Pointer(JobFuncVar))
 	var JobFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(JobFuncVarPtr); ok {
+	if JobFuncVar != nil {
-		JobFuncVarRef = cbRefPtr
+		JobFuncVarPtr := uintptr(unsafe.Pointer(JobFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(JobFuncVarPtr); ok {
-		fcb := func(arg0 *IOSchedulerJob, arg1 uintptr, arg2 uintptr) bool {
+			JobFuncVarRef = cbRefPtr
-			cbFn := *JobFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 *IOSchedulerJob, arg1 uintptr, arg2 uintptr) bool {
+				cbFn := *JobFuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			JobFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(JobFuncVarPtr, JobFuncVarRef)
 		}
-		JobFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(JobFuncVarPtr, JobFuncVarRef)
 	}
 	var NotifyVarRef uintptr

M v4/gio/giotypes.go +22 -18

 // blocking the I/O job).
 func (x *IOSchedulerJob) SendToMainloop(FuncVar *glib.SourceFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) bool {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr) bool {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0)
+			fcb := func(arg0 uintptr) bool {
+				cbFn := *FuncVar
+				return cbFn(arg0)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	var NotifyVarRef uintptr
 // g_io_scheduler_push_job() or by using refcounting for @user_data.
 func (x *IOSchedulerJob) SendToMainloopAsync(FuncVar *glib.SourceFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr) bool {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0)
+			fcb := func(arg0 uintptr) bool {
+				cbFn := *FuncVar
+				return cbFn(arg0)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	var NotifyVarRef uintptr

M v4/gio/gliststore.go +44 -36

 // Since GLib 2.76 it is possible to pass `NULL` for @item.
 func (x *ListStore) FindWithEqualFunc(ItemVar *gobject.Object, EqualFuncVar *glib.EqualFunc, PositionVar *uint) bool {
-	EqualFuncVarPtr := uintptr(unsafe.Pointer(EqualFuncVar))
 	var EqualFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(EqualFuncVarPtr); ok {
+	if EqualFuncVar != nil {
-		EqualFuncVarRef = cbRefPtr
+		EqualFuncVarPtr := uintptr(unsafe.Pointer(EqualFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(EqualFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) bool {
+			EqualFuncVarRef = cbRefPtr
-			cbFn := *EqualFuncVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) bool {
+				cbFn := *EqualFuncVar
+				return cbFn(arg0, arg1)
+			}
+			EqualFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(EqualFuncVarPtr, EqualFuncVarRef)
 		}
-		EqualFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(EqualFuncVarPtr, EqualFuncVarRef)
 	}
 	cret := xListStoreFindWithEqualFunc(x.GoPointer(), ItemVar.GoPointer(), EqualFuncVarRef, PositionVar)
 // Since GLib 2.76 it is possible to pass `NULL` for @item.
 func (x *ListStore) FindWithEqualFuncFull(ItemVar *gobject.Object, EqualFuncVar *glib.EqualFuncFull, UserDataVar uintptr, PositionVar *uint) bool {
-	EqualFuncVarPtr := uintptr(unsafe.Pointer(EqualFuncVar))
 	var EqualFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(EqualFuncVarPtr); ok {
+	if EqualFuncVar != nil {
-		EqualFuncVarRef = cbRefPtr
+		EqualFuncVarPtr := uintptr(unsafe.Pointer(EqualFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(EqualFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
+			EqualFuncVarRef = cbRefPtr
-			cbFn := *EqualFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
+				cbFn := *EqualFuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			EqualFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(EqualFuncVarPtr, EqualFuncVarRef)
 		}
-		EqualFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(EqualFuncVarPtr, EqualFuncVarRef)
 	}
 	cret := xListStoreFindWithEqualFuncFull(x.GoPointer(), ItemVar.GoPointer(), EqualFuncVarRef, UserDataVar, PositionVar)
 // This function takes a ref on @item.
 func (x *ListStore) InsertSorted(ItemVar *gobject.Object, CompareFuncVar *glib.CompareDataFunc, UserDataVar uintptr) uint {
-	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
 	var CompareFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CompareFuncVarPtr); ok {
+	if CompareFuncVar != nil {
-		CompareFuncVarRef = cbRefPtr
+		CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CompareFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+			CompareFuncVarRef = cbRefPtr
-			cbFn := *CompareFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+				cbFn := *CompareFuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			CompareFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
 		}
-		CompareFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
 	}
 	cret := xListStoreInsertSorted(x.GoPointer(), ItemVar.GoPointer(), CompareFuncVarRef, UserDataVar)
 // Sort the items in @store according to @compare_func.
 func (x *ListStore) Sort(CompareFuncVar *glib.CompareDataFunc, UserDataVar uintptr) {
-	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
 	var CompareFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CompareFuncVarPtr); ok {
+	if CompareFuncVar != nil {
-		CompareFuncVarRef = cbRefPtr
+		CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CompareFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+			CompareFuncVarRef = cbRefPtr
-			cbFn := *CompareFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+				cbFn := *CompareFuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			CompareFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
 		}
-		CompareFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
 	}
 	xListStoreSort(x.GoPointer(), CompareFuncVarRef, UserDataVar)

M v4/gio/gsettings.go +22 -18

 		}
 	}
-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
 	var DestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
+	if DestroyVar != nil {
-		DestroyVarRef = cbRefPtr
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyVarRef = cbRefPtr
-			cbFn := *DestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 		}
-		DestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 	}
 	xSettingsBindWithMapping(x.GoPointer(), KeyVar, ObjectVar.GoPointer(), PropertyVar, FlagsVar, GetMappingVarRef, SetMappingVarRef, UserDataVar, DestroyVarRef)
 // just as any other value would be.
 func (x *Settings) GetMapped(KeyVar string, MappingVar *SettingsGetMapping, UserDataVar uintptr) uintptr {
-	MappingVarPtr := uintptr(unsafe.Pointer(MappingVar))
 	var MappingVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(MappingVarPtr); ok {
+	if MappingVar != nil {
-		MappingVarRef = cbRefPtr
+		MappingVarPtr := uintptr(unsafe.Pointer(MappingVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(MappingVarPtr); ok {
-		fcb := func(arg0 *glib.Variant, arg1 *uintptr, arg2 uintptr) bool {
+			MappingVarRef = cbRefPtr
-			cbFn := *MappingVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 *glib.Variant, arg1 *uintptr, arg2 uintptr) bool {
+				cbFn := *MappingVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			MappingVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(MappingVarPtr, MappingVarRef)
 		}
-		MappingVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(MappingVarPtr, MappingVarRef)
 	}
 	cret := xSettingsGetMapped(x.GoPointer(), KeyVar, MappingVarRef, UserDataVar)

M v4/gio/gsimpleasyncresult.go +22 -18

 // is needed to run the job and report its completion.
 func (x *SimpleAsyncResult) RunInThread(FuncVar *SimpleAsyncThreadFunc, IoPriorityVar int, CancellableVar *Cancellable) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+				cbFn := *FuncVar
+				cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xSimpleAsyncResultRunInThread(x.GoPointer(), FuncVarRef, IoPriorityVar, CancellableVar.GoPointer())
 // Sets the operation result within the asynchronous result to a pointer.
 func (x *SimpleAsyncResult) SetOpResGpointer(OpResVar uintptr, DestroyOpResVar *glib.DestroyNotify) {
-	DestroyOpResVarPtr := uintptr(unsafe.Pointer(DestroyOpResVar))
 	var DestroyOpResVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DestroyOpResVarPtr); ok {
+	if DestroyOpResVar != nil {
-		DestroyOpResVarRef = cbRefPtr
+		DestroyOpResVarPtr := uintptr(unsafe.Pointer(DestroyOpResVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DestroyOpResVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyOpResVarRef = cbRefPtr
-			cbFn := *DestroyOpResVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyOpResVar
+				cbFn(arg0)
+			}
+			DestroyOpResVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyOpResVarPtr, DestroyOpResVarRef)
 		}
-		DestroyOpResVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DestroyOpResVarPtr, DestroyOpResVarRef)
 	}
 	xSimpleAsyncResultSetOpResGpointer(x.GoPointer(), OpResVar, DestroyOpResVarRef)

M v4/gio/gsubprocesslauncher.go +22 -18

 // Child setup functions are only available on UNIX.
 func (x *SubprocessLauncher) SetChildSetup(ChildSetupVar *glib.SpawnChildSetupFunc, UserDataVar uintptr, DestroyNotifyVar *glib.DestroyNotify) {
-	ChildSetupVarPtr := uintptr(unsafe.Pointer(ChildSetupVar))
 	var ChildSetupVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(ChildSetupVarPtr); ok {
+	if ChildSetupVar != nil {
-		ChildSetupVarRef = cbRefPtr
+		ChildSetupVarPtr := uintptr(unsafe.Pointer(ChildSetupVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(ChildSetupVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			ChildSetupVarRef = cbRefPtr
-			cbFn := *ChildSetupVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *ChildSetupVar
+				cbFn(arg0)
+			}
+			ChildSetupVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(ChildSetupVarPtr, ChildSetupVarRef)
 		}
-		ChildSetupVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(ChildSetupVarPtr, ChildSetupVarRef)
 	}
-	DestroyNotifyVarPtr := uintptr(unsafe.Pointer(DestroyNotifyVar))
 	var DestroyNotifyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DestroyNotifyVarPtr); ok {
+	if DestroyNotifyVar != nil {
-		DestroyNotifyVarRef = cbRefPtr
+		DestroyNotifyVarPtr := uintptr(unsafe.Pointer(DestroyNotifyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DestroyNotifyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyNotifyVarRef = cbRefPtr
-			cbFn := *DestroyNotifyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyNotifyVar
+				cbFn(arg0)
+			}
+			DestroyNotifyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyNotifyVarPtr, DestroyNotifyVarRef)
 		}
-		DestroyNotifyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DestroyNotifyVarPtr, DestroyNotifyVarRef)
 	}
 	xSubprocessLauncherSetChildSetup(x.GoPointer(), ChildSetupVarRef, UserDataVar, DestroyNotifyVarRef)

M v4/gio/gtask.go +33 -27

 // This takes a reference on @task until @source is destroyed.
 func (x *Task) AttachSource(SourceVar *glib.Source, CallbackVar *glib.SourceFunc) {
-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
 	var CallbackVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
+	if CallbackVar != nil {
-		CallbackVarRef = cbRefPtr
+		CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
-		fcb := func(arg0 uintptr) bool {
+			CallbackVarRef = cbRefPtr
-			cbFn := *CallbackVar
+		} else {
-			return cbFn(arg0)
+			fcb := func(arg0 uintptr) bool {
+				cbFn := *CallbackVar
+				return cbFn(arg0)
+			}
+			CallbackVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 		}
-		CallbackVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 	}
 	xTaskAttachSource(x.GoPointer(), SourceVar, CallbackVarRef)
 // g_task_run_in_thread().
 func (x *Task) RunInThread(TaskFuncVar *TaskThreadFunc) {
-	TaskFuncVarPtr := uintptr(unsafe.Pointer(TaskFuncVar))
 	var TaskFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(TaskFuncVarPtr); ok {
+	if TaskFuncVar != nil {
-		TaskFuncVarRef = cbRefPtr
+		TaskFuncVarPtr := uintptr(unsafe.Pointer(TaskFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(TaskFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr, arg3 uintptr) {
+			TaskFuncVarRef = cbRefPtr
-			cbFn := *TaskFuncVar
+		} else {
-			cbFn(arg0, arg1, arg2, arg3)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr, arg3 uintptr) {
+				cbFn := *TaskFuncVar
+				cbFn(arg0, arg1, arg2, arg3)
+			}
+			TaskFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(TaskFuncVarPtr, TaskFuncVarRef)
 		}
-		TaskFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(TaskFuncVarPtr, TaskFuncVarRef)
 	}
 	xTaskRunInThread(x.GoPointer(), TaskFuncVarRef)
 // limited number of them at a time.
 func (x *Task) RunInThreadSync(TaskFuncVar *TaskThreadFunc) {
-	TaskFuncVarPtr := uintptr(unsafe.Pointer(TaskFuncVar))
 	var TaskFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(TaskFuncVarPtr); ok {
+	if TaskFuncVar != nil {
-		TaskFuncVarRef = cbRefPtr
+		TaskFuncVarPtr := uintptr(unsafe.Pointer(TaskFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(TaskFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr, arg3 uintptr) {
+			TaskFuncVarRef = cbRefPtr
-			cbFn := *TaskFuncVar
+		} else {
-			cbFn(arg0, arg1, arg2, arg3)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr, arg3 uintptr) {
+				cbFn := *TaskFuncVar
+				cbFn(arg0, arg1, arg2, arg3)
+			}
+			TaskFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(TaskFuncVarPtr, TaskFuncVarRef)
 		}
-		TaskFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(TaskFuncVarPtr, TaskFuncVarRef)
 	}
 	xTaskRunInThreadSync(x.GoPointer(), TaskFuncVarRef)

M v4/glib/garray.go +33 -27

 // @data may be `NULL` if @size is 0.
 func NewBytesWithFreeFunc(DataVar []byte, SizeVar uint, FreeFuncVar *DestroyNotify, UserDataVar uintptr) *Bytes {
-	FreeFuncVarPtr := uintptr(unsafe.Pointer(FreeFuncVar))
 	var FreeFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FreeFuncVarPtr); ok {
+	if FreeFuncVar != nil {
-		FreeFuncVarRef = cbRefPtr
+		FreeFuncVarPtr := uintptr(unsafe.Pointer(FreeFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FreeFuncVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			FreeFuncVarRef = cbRefPtr
-			cbFn := *FreeFuncVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *FreeFuncVar
+				cbFn(arg0)
+			}
+			FreeFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FreeFuncVarPtr, FreeFuncVarRef)
 		}
-		FreeFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FreeFuncVarPtr, FreeFuncVarRef)
 	}
 	cret := xNewBytesWithFreeFunc(DataVar, SizeVar, FreeFuncVarRef, UserDataVar)
 // their addresses.
 func ByteArraySort(ArrayVar []byte, CompareFuncVar *CompareFunc) {
-	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
 	var CompareFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
+	if CompareFuncVar != nil {
-		CompareFuncVarRef = cbRefPtr
+		CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) int {
+			CompareFuncVarRef = cbRefPtr
-			cbFn := *CompareFuncVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) int {
+				cbFn := *CompareFuncVar
+				return cbFn(arg0, arg1)
+			}
+			CompareFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
 		}
-		CompareFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
 	}
 	xByteArraySort(ArrayVar, CompareFuncVarRef)
 // user data argument.
 func ByteArraySortWithData(ArrayVar []byte, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {
-	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
 	var CompareFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
+	if CompareFuncVar != nil {
-		CompareFuncVarRef = cbRefPtr
+		CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+			CompareFuncVarRef = cbRefPtr
-			cbFn := *CompareFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+				cbFn := *CompareFuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			CompareFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
 		}
-		CompareFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
 	}
 	xByteArraySortWithData(ArrayVar, CompareFuncVarRef, UserDataVar)

M v4/glib/gasyncqueue.go +44 -36

 // For an example of @func see g_async_queue_sort().
 func (x *AsyncQueue) PushSorted(DataVar uintptr, FuncVar *CompareDataFunc, UserDataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xAsyncQueuePushSorted(x.GoPointer(), DataVar, FuncVarRef, UserDataVar)
 // For an example of @func see g_async_queue_sort().
 func (x *AsyncQueue) PushSortedUnlocked(DataVar uintptr, FuncVar *CompareDataFunc, UserDataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xAsyncQueuePushSortedUnlocked(x.GoPointer(), DataVar, FuncVarRef, UserDataVar)
 // ]|
 func (x *AsyncQueue) Sort(FuncVar *CompareDataFunc, UserDataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xAsyncQueueSort(x.GoPointer(), FuncVarRef, UserDataVar)
 // This function must be called while holding the @queue's lock.
 func (x *AsyncQueue) SortUnlocked(FuncVar *CompareDataFunc, UserDataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xAsyncQueueSortUnlocked(x.GoPointer(), FuncVarRef, UserDataVar)

M v4/glib/gcache.go +22 -18

 // pairs to its callback function !
 func (x *Cache) KeyForeach(FuncVar *HFunc, UserDataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+				cbFn := *FuncVar
+				cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xCacheKeyForeach(x.GoPointer(), FuncVarRef, UserDataVar)
 // Calls the given function for each of the values in the #GCache.
 func (x *Cache) ValueForeach(FuncVar *HFunc, UserDataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+				cbFn := *FuncVar
+				cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xCacheValueForeach(x.GoPointer(), FuncVarRef, UserDataVar)

M v4/glib/gcompletion.go +11 -9

 // comparison function is strncmp().
 func (x *Completion) SetCompare(StrncmpFuncVar *CompletionStrncmpFunc) {
-	StrncmpFuncVarPtr := uintptr(unsafe.Pointer(StrncmpFuncVar))
 	var StrncmpFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(StrncmpFuncVarPtr); ok {
+	if StrncmpFuncVar != nil {
-		StrncmpFuncVarRef = cbRefPtr
+		StrncmpFuncVarPtr := uintptr(unsafe.Pointer(StrncmpFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(StrncmpFuncVarPtr); ok {
-		fcb := func(arg0 string, arg1 string, arg2 uint) int {
+			StrncmpFuncVarRef = cbRefPtr
-			cbFn := *StrncmpFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 string, arg1 string, arg2 uint) int {
+				cbFn := *StrncmpFuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			StrncmpFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(StrncmpFuncVarPtr, StrncmpFuncVarRef)
 		}
-		StrncmpFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(StrncmpFuncVarPtr, StrncmpFuncVarRef)
 	}
 	xCompletionSetCompare(x.GoPointer(), StrncmpFuncVarRef)

M v4/glib/gdataset.go +33 -27

 // than skipping over elements that are removed.
 func DatalistForeach(DatalistVar **Data, FuncVar *DataForeachFunc, UserDataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 Quark, arg1 uintptr, arg2 uintptr) {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 Quark, arg1 uintptr, arg2 uintptr) {
+				cbFn := *FuncVar
+				cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xDatalistForeach(DatalistVar, FuncVarRef, UserDataVar)
 // than skipping over elements that are removed.
 func DatasetForeach(DatasetLocationVar uintptr, FuncVar *DataForeachFunc, UserDataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 Quark, arg1 uintptr, arg2 uintptr) {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 Quark, arg1 uintptr, arg2 uintptr) {
+				cbFn := *FuncVar
+				cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xDatasetForeach(DatasetLocationVar, FuncVarRef, UserDataVar)
 // is called.
 func DatasetIdSetDataFull(DatasetLocationVar uintptr, KeyIdVar Quark, DataVar uintptr, DestroyFuncVar *DestroyNotify) {
-	DestroyFuncVarPtr := uintptr(unsafe.Pointer(DestroyFuncVar))
 	var DestroyFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(DestroyFuncVarPtr); ok {
+	if DestroyFuncVar != nil {
-		DestroyFuncVarRef = cbRefPtr
+		DestroyFuncVarPtr := uintptr(unsafe.Pointer(DestroyFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(DestroyFuncVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyFuncVarRef = cbRefPtr
-			cbFn := *DestroyFuncVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyFuncVar
+				cbFn(arg0)
+			}
+			DestroyFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(DestroyFuncVarPtr, DestroyFuncVarRef)
 		}
-		DestroyFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(DestroyFuncVarPtr, DestroyFuncVarRef)
 	}
 	xDatasetIdSetDataFull(DatasetLocationVar, KeyIdVar, DataVar, DestroyFuncVarRef)

M v4/glib/gerror.go +66 -54

 // g_error_domain_register_static().
 func ErrorDomainRegister(ErrorTypeNameVar string, ErrorTypePrivateSizeVar uint, ErrorTypeInitVar *ErrorInitFunc, ErrorTypeCopyVar *ErrorCopyFunc, ErrorTypeClearVar *ErrorClearFunc) Quark {
-	ErrorTypeInitVarPtr := uintptr(unsafe.Pointer(ErrorTypeInitVar))
 	var ErrorTypeInitVarRef uintptr
-	if cbRefPtr, ok := GetCallback(ErrorTypeInitVarPtr); ok {
+	if ErrorTypeInitVar != nil {
-		ErrorTypeInitVarRef = cbRefPtr
+		ErrorTypeInitVarPtr := uintptr(unsafe.Pointer(ErrorTypeInitVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(ErrorTypeInitVarPtr); ok {
-		fcb := func(arg0 *Error) {
+			ErrorTypeInitVarRef = cbRefPtr
-			cbFn := *ErrorTypeInitVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 *Error) {
+				cbFn := *ErrorTypeInitVar
+				cbFn(arg0)
+			}
+			ErrorTypeInitVarRef = purego.NewCallback(fcb)
+			SaveCallback(ErrorTypeInitVarPtr, ErrorTypeInitVarRef)
 		}
-		ErrorTypeInitVarRef = purego.NewCallback(fcb)
-		SaveCallback(ErrorTypeInitVarPtr, ErrorTypeInitVarRef)
 	}
-	ErrorTypeCopyVarPtr := uintptr(unsafe.Pointer(ErrorTypeCopyVar))
 	var ErrorTypeCopyVarRef uintptr
-	if cbRefPtr, ok := GetCallback(ErrorTypeCopyVarPtr); ok {
+	if ErrorTypeCopyVar != nil {
-		ErrorTypeCopyVarRef = cbRefPtr
+		ErrorTypeCopyVarPtr := uintptr(unsafe.Pointer(ErrorTypeCopyVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(ErrorTypeCopyVarPtr); ok {
-		fcb := func(arg0 *Error, arg1 *Error) {
+			ErrorTypeCopyVarRef = cbRefPtr
-			cbFn := *ErrorTypeCopyVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 *Error, arg1 *Error) {
+				cbFn := *ErrorTypeCopyVar
+				cbFn(arg0, arg1)
+			}
+			ErrorTypeCopyVarRef = purego.NewCallback(fcb)
+			SaveCallback(ErrorTypeCopyVarPtr, ErrorTypeCopyVarRef)
 		}
-		ErrorTypeCopyVarRef = purego.NewCallback(fcb)
-		SaveCallback(ErrorTypeCopyVarPtr, ErrorTypeCopyVarRef)
 	}
-	ErrorTypeClearVarPtr := uintptr(unsafe.Pointer(ErrorTypeClearVar))
 	var ErrorTypeClearVarRef uintptr
-	if cbRefPtr, ok := GetCallback(ErrorTypeClearVarPtr); ok {
+	if ErrorTypeClearVar != nil {
-		ErrorTypeClearVarRef = cbRefPtr
+		ErrorTypeClearVarPtr := uintptr(unsafe.Pointer(ErrorTypeClearVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(ErrorTypeClearVarPtr); ok {
-		fcb := func(arg0 *Error) {
+			ErrorTypeClearVarRef = cbRefPtr
-			cbFn := *ErrorTypeClearVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 *Error) {
+				cbFn := *ErrorTypeClearVar
+				cbFn(arg0)
+			}
+			ErrorTypeClearVarRef = purego.NewCallback(fcb)
+			SaveCallback(ErrorTypeClearVarPtr, ErrorTypeClearVarRef)
 		}
-		ErrorTypeClearVarRef = purego.NewCallback(fcb)
-		SaveCallback(ErrorTypeClearVarPtr, ErrorTypeClearVarRef)
 	}
 	cret := xErrorDomainRegister(ErrorTypeNameVar, ErrorTypePrivateSizeVar, ErrorTypeInitVarRef, ErrorTypeCopyVarRef, ErrorTypeClearVarRef)
 // already takes care of passing valid information to this function.
 func ErrorDomainRegisterStatic(ErrorTypeNameVar string, ErrorTypePrivateSizeVar uint, ErrorTypeInitVar *ErrorInitFunc, ErrorTypeCopyVar *ErrorCopyFunc, ErrorTypeClearVar *ErrorClearFunc) Quark {
-	ErrorTypeInitVarPtr := uintptr(unsafe.Pointer(ErrorTypeInitVar))
 	var ErrorTypeInitVarRef uintptr
-	if cbRefPtr, ok := GetCallback(ErrorTypeInitVarPtr); ok {
+	if ErrorTypeInitVar != nil {
-		ErrorTypeInitVarRef = cbRefPtr
+		ErrorTypeInitVarPtr := uintptr(unsafe.Pointer(ErrorTypeInitVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(ErrorTypeInitVarPtr); ok {
-		fcb := func(arg0 *Error) {
+			ErrorTypeInitVarRef = cbRefPtr
-			cbFn := *ErrorTypeInitVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 *Error) {
+				cbFn := *ErrorTypeInitVar
+				cbFn(arg0)
+			}
+			ErrorTypeInitVarRef = purego.NewCallback(fcb)
+			SaveCallback(ErrorTypeInitVarPtr, ErrorTypeInitVarRef)
 		}
-		ErrorTypeInitVarRef = purego.NewCallback(fcb)
-		SaveCallback(ErrorTypeInitVarPtr, ErrorTypeInitVarRef)
 	}
-	ErrorTypeCopyVarPtr := uintptr(unsafe.Pointer(ErrorTypeCopyVar))
 	var ErrorTypeCopyVarRef uintptr
-	if cbRefPtr, ok := GetCallback(ErrorTypeCopyVarPtr); ok {
+	if ErrorTypeCopyVar != nil {
-		ErrorTypeCopyVarRef = cbRefPtr
+		ErrorTypeCopyVarPtr := uintptr(unsafe.Pointer(ErrorTypeCopyVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(ErrorTypeCopyVarPtr); ok {
-		fcb := func(arg0 *Error, arg1 *Error) {
+			ErrorTypeCopyVarRef = cbRefPtr
-			cbFn := *ErrorTypeCopyVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 *Error, arg1 *Error) {
+				cbFn := *ErrorTypeCopyVar
+				cbFn(arg0, arg1)
+			}
+			ErrorTypeCopyVarRef = purego.NewCallback(fcb)
+			SaveCallback(ErrorTypeCopyVarPtr, ErrorTypeCopyVarRef)
 		}
-		ErrorTypeCopyVarRef = purego.NewCallback(fcb)
-		SaveCallback(ErrorTypeCopyVarPtr, ErrorTypeCopyVarRef)
 	}
-	ErrorTypeClearVarPtr := uintptr(unsafe.Pointer(ErrorTypeClearVar))
 	var ErrorTypeClearVarRef uintptr
-	if cbRefPtr, ok := GetCallback(ErrorTypeClearVarPtr); ok {
+	if ErrorTypeClearVar != nil {
-		ErrorTypeClearVarRef = cbRefPtr
+		ErrorTypeClearVarPtr := uintptr(unsafe.Pointer(ErrorTypeClearVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(ErrorTypeClearVarPtr); ok {
-		fcb := func(arg0 *Error) {
+			ErrorTypeClearVarRef = cbRefPtr
-			cbFn := *ErrorTypeClearVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 *Error) {
+				cbFn := *ErrorTypeClearVar
+				cbFn(arg0)
+			}
+			ErrorTypeClearVarRef = purego.NewCallback(fcb)
+			SaveCallback(ErrorTypeClearVarPtr, ErrorTypeClearVarRef)
 		}
-		ErrorTypeClearVarRef = purego.NewCallback(fcb)
-		SaveCallback(ErrorTypeClearVarPtr, ErrorTypeClearVarRef)
 	}
 	cret := xErrorDomainRegisterStatic(ErrorTypeNameVar, ErrorTypePrivateSizeVar, ErrorTypeInitVarRef, ErrorTypeCopyVarRef, ErrorTypeClearVarRef)

M v4/glib/ghash.go +44 -36

 // values in a hash table ends up needing O(n*n) operations).
 func HashTableFind(HashTableVar *HashTable, PredicateVar *HRFunc, UserDataVar uintptr) uintptr {
-	PredicateVarPtr := uintptr(unsafe.Pointer(PredicateVar))
 	var PredicateVarRef uintptr
-	if cbRefPtr, ok := GetCallback(PredicateVarPtr); ok {
+	if PredicateVar != nil {
-		PredicateVarRef = cbRefPtr
+		PredicateVarPtr := uintptr(unsafe.Pointer(PredicateVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(PredicateVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
+			PredicateVarRef = cbRefPtr
-			cbFn := *PredicateVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
+				cbFn := *PredicateVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			PredicateVarRef = purego.NewCallback(fcb)
+			SaveCallback(PredicateVarPtr, PredicateVarRef)
 		}
-		PredicateVarRef = purego.NewCallback(fcb)
-		SaveCallback(PredicateVarPtr, PredicateVarRef)
 	}
 	cret := xHashTableFind(HashTableVar, PredicateVarRef, UserDataVar)
 // order searches in contrast to g_hash_table_lookup().
 func HashTableForeach(HashTableVar *HashTable, FuncVar *HFunc, UserDataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+				cbFn := *FuncVar
+				cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xHashTableForeach(HashTableVar, FuncVarRef, UserDataVar)
 // key/value pairs in the hash table.
 func HashTableForeachRemove(HashTableVar *HashTable, FuncVar *HRFunc, UserDataVar uintptr) uint {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	cret := xHashTableForeachRemove(HashTableVar, FuncVarRef, UserDataVar)
 // key/value pairs in the hash table.
 func HashTableForeachSteal(HashTableVar *HashTable, FuncVar *HRFunc, UserDataVar uintptr) uint {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	cret := xHashTableForeachSteal(HashTableVar, FuncVarRef, UserDataVar)

M v4/glib/ghook.go +33 -27

 // Calls a function on each valid #GHook.
 func (x *HookList) Marshal(MayRecurseVar bool, MarshallerVar *HookMarshaller, MarshalDataVar uintptr) {
-	MarshallerVarPtr := uintptr(unsafe.Pointer(MarshallerVar))
 	var MarshallerVarRef uintptr
-	if cbRefPtr, ok := GetCallback(MarshallerVarPtr); ok {
+	if MarshallerVar != nil {
-		MarshallerVarRef = cbRefPtr
+		MarshallerVarPtr := uintptr(unsafe.Pointer(MarshallerVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(MarshallerVarPtr); ok {
-		fcb := func(arg0 *Hook, arg1 uintptr) {
+			MarshallerVarRef = cbRefPtr
-			cbFn := *MarshallerVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 *Hook, arg1 uintptr) {
+				cbFn := *MarshallerVar
+				cbFn(arg0, arg1)
+			}
+			MarshallerVarRef = purego.NewCallback(fcb)
+			SaveCallback(MarshallerVarPtr, MarshallerVarRef)
 		}
-		MarshallerVarRef = purego.NewCallback(fcb)
-		SaveCallback(MarshallerVarPtr, MarshallerVarRef)
 	}
 	xHookListMarshal(x.GoPointer(), MayRecurseVar, MarshallerVarRef, MarshalDataVar)
 // function returns %FALSE.
 func (x *HookList) MarshalCheck(MayRecurseVar bool, MarshallerVar *HookCheckMarshaller, MarshalDataVar uintptr) {
-	MarshallerVarPtr := uintptr(unsafe.Pointer(MarshallerVar))
 	var MarshallerVarRef uintptr
-	if cbRefPtr, ok := GetCallback(MarshallerVarPtr); ok {
+	if MarshallerVar != nil {
-		MarshallerVarRef = cbRefPtr
+		MarshallerVarPtr := uintptr(unsafe.Pointer(MarshallerVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(MarshallerVarPtr); ok {
-		fcb := func(arg0 *Hook, arg1 uintptr) bool {
+			MarshallerVarRef = cbRefPtr
-			cbFn := *MarshallerVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 *Hook, arg1 uintptr) bool {
+				cbFn := *MarshallerVar
+				return cbFn(arg0, arg1)
+			}
+			MarshallerVarRef = purego.NewCallback(fcb)
+			SaveCallback(MarshallerVarPtr, MarshallerVarRef)
 		}
-		MarshallerVarRef = purego.NewCallback(fcb)
-		SaveCallback(MarshallerVarPtr, MarshallerVarRef)
 	}
 	xHookListMarshalCheck(x.GoPointer(), MayRecurseVar, MarshallerVarRef, MarshalDataVar)
 // Inserts a #GHook into a #GHookList, sorted by the given function.
 func HookInsertSorted(HookListVar *HookList, HookVar *Hook, FuncVar *HookCompareFunc) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 *Hook, arg1 *Hook) int {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 *Hook, arg1 *Hook) int {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xHookInsertSorted(HookListVar, HookVar, FuncVarRef)

M v4/glib/giochannel.go +33 -27

 // with the default priority.
 func IoAddWatch(ChannelVar *IOChannel, ConditionVar IOCondition, FuncVar *IOFunc, UserDataVar uintptr) uint {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 *IOChannel, arg1 IOCondition, arg2 uintptr) bool {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 *IOChannel, arg1 IOCondition, arg2 uintptr) bool {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	cret := xIoAddWatch(ChannelVar, ConditionVar, FuncVarRef, UserDataVar)
 // You can do these steps manually if you need greater control.
 func IoAddWatchFull(ChannelVar *IOChannel, PriorityVar int, ConditionVar IOCondition, FuncVar *IOFunc, UserDataVar uintptr, NotifyVar *DestroyNotify) uint {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 *IOChannel, arg1 IOCondition, arg2 uintptr) bool {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 *IOChannel, arg1 IOCondition, arg2 uintptr) bool {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
 	var NotifyVarRef uintptr
-	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
+	if NotifyVar != nil {
-		NotifyVarRef = cbRefPtr
+		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			NotifyVarRef = cbRefPtr
-			cbFn := *NotifyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *NotifyVar
+				cbFn(arg0)
+			}
+			NotifyVarRef = purego.NewCallback(fcb)
+			SaveCallback(NotifyVarPtr, NotifyVarRef)
 		}
-		NotifyVarRef = purego.NewCallback(fcb)
-		SaveCallback(NotifyVarPtr, NotifyVarRef)
 	}
 	cret := xIoAddWatchFull(ChannelVar, PriorityVar, ConditionVar, FuncVarRef, UserDataVar, NotifyVarRef)

M v4/glib/glib-unix.go +66 -54

 // The source will never close the fd -- you must do it yourself.
 func UnixFdAdd(FdVar int, ConditionVar IOCondition, FunctionVar *UnixFDSourceFunc, UserDataVar uintptr) uint {
-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
 	var FunctionVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
+	if FunctionVar != nil {
-		FunctionVarRef = cbRefPtr
+		FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
-		fcb := func(arg0 int, arg1 IOCondition, arg2 uintptr) bool {
+			FunctionVarRef = cbRefPtr
-			cbFn := *FunctionVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 int, arg1 IOCondition, arg2 uintptr) bool {
+				cbFn := *FunctionVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			FunctionVarRef = purego.NewCallback(fcb)
+			SaveCallback(FunctionVarPtr, FunctionVarRef)
 		}
-		FunctionVarRef = purego.NewCallback(fcb)
-		SaveCallback(FunctionVarPtr, FunctionVarRef)
 	}
 	cret := xUnixFdAdd(FdVar, ConditionVar, FunctionVarRef, UserDataVar)
 // @user_data.
 func UnixFdAddFull(PriorityVar int, FdVar int, ConditionVar IOCondition, FunctionVar *UnixFDSourceFunc, UserDataVar uintptr, NotifyVar *DestroyNotify) uint {
-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
 	var FunctionVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
+	if FunctionVar != nil {
-		FunctionVarRef = cbRefPtr
+		FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
-		fcb := func(arg0 int, arg1 IOCondition, arg2 uintptr) bool {
+			FunctionVarRef = cbRefPtr
-			cbFn := *FunctionVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 int, arg1 IOCondition, arg2 uintptr) bool {
+				cbFn := *FunctionVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			FunctionVarRef = purego.NewCallback(fcb)
+			SaveCallback(FunctionVarPtr, FunctionVarRef)
 		}
-		FunctionVarRef = purego.NewCallback(fcb)
-		SaveCallback(FunctionVarPtr, FunctionVarRef)
 	}
-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
 	var NotifyVarRef uintptr
-	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
+	if NotifyVar != nil {
-		NotifyVarRef = cbRefPtr
+		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			NotifyVarRef = cbRefPtr
-			cbFn := *NotifyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *NotifyVar
+				cbFn(arg0)
+			}
+			NotifyVarRef = purego.NewCallback(fcb)
+			SaveCallback(NotifyVarPtr, NotifyVarRef)
 		}
-		NotifyVarRef = purego.NewCallback(fcb)
-		SaveCallback(NotifyVarPtr, NotifyVarRef)
 	}
 	cret := xUnixFdAddFull(PriorityVar, FdVar, ConditionVar, FunctionVarRef, UserDataVar, NotifyVarRef)
 // using g_source_remove().
 func UnixSignalAdd(SignumVar int, HandlerVar *SourceFunc, UserDataVar uintptr) uint {
-	HandlerVarPtr := uintptr(unsafe.Pointer(HandlerVar))
 	var HandlerVarRef uintptr
-	if cbRefPtr, ok := GetCallback(HandlerVarPtr); ok {
+	if HandlerVar != nil {
-		HandlerVarRef = cbRefPtr
+		HandlerVarPtr := uintptr(unsafe.Pointer(HandlerVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(HandlerVarPtr); ok {
-		fcb := func(arg0 uintptr) bool {
+			HandlerVarRef = cbRefPtr
-			cbFn := *HandlerVar
+		} else {
-			return cbFn(arg0)
+			fcb := func(arg0 uintptr) bool {
+				cbFn := *HandlerVar
+				return cbFn(arg0)
+			}
+			HandlerVarRef = purego.NewCallback(fcb)
+			SaveCallback(HandlerVarPtr, HandlerVarRef)
 		}
-		HandlerVarRef = purego.NewCallback(fcb)
-		SaveCallback(HandlerVarPtr, HandlerVarRef)
 	}
 	cret := xUnixSignalAdd(SignumVar, HandlerVarRef, UserDataVar)
 // using g_source_remove().
 func UnixSignalAddFull(PriorityVar int, SignumVar int, HandlerVar *SourceFunc, UserDataVar uintptr, NotifyVar *DestroyNotify) uint {
-	HandlerVarPtr := uintptr(unsafe.Pointer(HandlerVar))
 	var HandlerVarRef uintptr
-	if cbRefPtr, ok := GetCallback(HandlerVarPtr); ok {
+	if HandlerVar != nil {
-		HandlerVarRef = cbRefPtr
+		HandlerVarPtr := uintptr(unsafe.Pointer(HandlerVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(HandlerVarPtr); ok {
-		fcb := func(arg0 uintptr) bool {
+			HandlerVarRef = cbRefPtr
-			cbFn := *HandlerVar
+		} else {
-			return cbFn(arg0)
+			fcb := func(arg0 uintptr) bool {
+				cbFn := *HandlerVar
+				return cbFn(arg0)
+			}
+			HandlerVarRef = purego.NewCallback(fcb)
+			SaveCallback(HandlerVarPtr, HandlerVarRef)
 		}
-		HandlerVarRef = purego.NewCallback(fcb)
-		SaveCallback(HandlerVarPtr, HandlerVarRef)
 	}
-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
 	var NotifyVarRef uintptr
-	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
+	if NotifyVar != nil {
-		NotifyVarRef = cbRefPtr
+		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			NotifyVarRef = cbRefPtr
-			cbFn := *NotifyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *NotifyVar
+				cbFn(arg0)
+			}
+			NotifyVarRef = purego.NewCallback(fcb)
+			SaveCallback(NotifyVarPtr, NotifyVarRef)
 		}
-		NotifyVarRef = purego.NewCallback(fcb)
-		SaveCallback(NotifyVarPtr, NotifyVarRef)
 	}
 	cret := xUnixSignalAddFull(PriorityVar, SignumVar, HandlerVarRef, UserDataVar, NotifyVarRef)

M v4/glib/gmain.go +187 -153

 // will be continuously run in a loop (and may prevent this call from returning).
 func (x *MainContext) Invoke(FunctionVar *SourceFunc, DataVar uintptr) {
-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
 	var FunctionVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
+	if FunctionVar != nil {
-		FunctionVarRef = cbRefPtr
+		FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
-		fcb := func(arg0 uintptr) bool {
+			FunctionVarRef = cbRefPtr
-			cbFn := *FunctionVar
+		} else {
-			return cbFn(arg0)
+			fcb := func(arg0 uintptr) bool {
+				cbFn := *FunctionVar
+				return cbFn(arg0)
+			}
+			FunctionVarRef = purego.NewCallback(fcb)
+			SaveCallback(FunctionVarPtr, FunctionVarRef)
 		}
-		FunctionVarRef = purego.NewCallback(fcb)
-		SaveCallback(FunctionVarPtr, FunctionVarRef)
 	}
 	xMainContextInvoke(x.GoPointer(), FunctionVarRef, DataVar)
 // thread or with any particular context acquired.
 func (x *MainContext) InvokeFull(PriorityVar int, FunctionVar *SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) {
-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
 	var FunctionVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
+	if FunctionVar != nil {
-		FunctionVarRef = cbRefPtr
+		FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
-		fcb := func(arg0 uintptr) bool {
+			FunctionVarRef = cbRefPtr
-			cbFn := *FunctionVar
+		} else {
-			return cbFn(arg0)
+			fcb := func(arg0 uintptr) bool {
+				cbFn := *FunctionVar
+				return cbFn(arg0)
+			}
+			FunctionVarRef = purego.NewCallback(fcb)
+			SaveCallback(FunctionVarPtr, FunctionVarRef)
 		}
-		FunctionVarRef = purego.NewCallback(fcb)
-		SaveCallback(FunctionVarPtr, FunctionVarRef)
 	}
 	var NotifyVarRef uintptr
 // loop with an external event loop.
 func (x *MainContext) SetPollFunc(FuncVar *PollFunc) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 *PollFD, arg1 uint, arg2 int) int {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 *PollFD, arg1 uint, arg2 int) int {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xMainContextSetPollFunc(x.GoPointer(), FuncVarRef)
 // of also unsetting the callback.
 func (x *Source) SetCallback(FuncVar *SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr) bool {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0)
+			fcb := func(arg0 uintptr) bool {
+				cbFn := *FuncVar
+				return cbFn(arg0)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	var NotifyVarRef uintptr
 // This should only ever be called from [struct@GLib.Source] implementations.
 func (x *Source) SetDisposeFunction(DisposeVar *SourceDisposeFunc) {
-	DisposeVarPtr := uintptr(unsafe.Pointer(DisposeVar))
 	var DisposeVarRef uintptr
-	if cbRefPtr, ok := GetCallback(DisposeVarPtr); ok {
+	if DisposeVar != nil {
-		DisposeVarRef = cbRefPtr
+		DisposeVarPtr := uintptr(unsafe.Pointer(DisposeVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(DisposeVarPtr); ok {
-		fcb := func(arg0 *Source) {
+			DisposeVarRef = cbRefPtr
-			cbFn := *DisposeVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 *Source) {
+				cbFn := *DisposeVar
+				cbFn(arg0)
+			}
+			DisposeVarRef = purego.NewCallback(fcb)
+			SaveCallback(DisposeVarPtr, DisposeVarRef)
 		}
-		DisposeVarRef = purego.NewCallback(fcb)
-		SaveCallback(DisposeVarPtr, DisposeVarRef)
 	}
 	xSourceSetDisposeFunction(x.GoPointer(), DisposeVarRef)
 // need greater control.
 func ChildWatchAdd(PidVar Pid, FunctionVar *ChildWatchFunc, DataVar uintptr) uint {
-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
 	var FunctionVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
+	if FunctionVar != nil {
-		FunctionVarRef = cbRefPtr
+		FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
-		fcb := func(arg0 Pid, arg1 int, arg2 uintptr) {
+			FunctionVarRef = cbRefPtr
-			cbFn := *FunctionVar
+		} else {
-			cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 Pid, arg1 int, arg2 uintptr) {
+				cbFn := *FunctionVar
+				cbFn(arg0, arg1, arg2)
+			}
+			FunctionVarRef = purego.NewCallback(fcb)
+			SaveCallback(FunctionVarPtr, FunctionVarRef)
 		}
-		FunctionVarRef = purego.NewCallback(fcb)
-		SaveCallback(FunctionVarPtr, FunctionVarRef)
 	}
 	cret := xChildWatchAdd(PidVar, FunctionVarRef, DataVar)
 // need greater control.
 func ChildWatchAddFull(PriorityVar int, PidVar Pid, FunctionVar *ChildWatchFunc, DataVar uintptr, NotifyVar *DestroyNotify) uint {
-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
 	var FunctionVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
+	if FunctionVar != nil {
-		FunctionVarRef = cbRefPtr
+		FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
-		fcb := func(arg0 Pid, arg1 int, arg2 uintptr) {
+			FunctionVarRef = cbRefPtr
-			cbFn := *FunctionVar
+		} else {
-			cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 Pid, arg1 int, arg2 uintptr) {
+				cbFn := *FunctionVar
+				cbFn(arg0, arg1, arg2)
+			}
+			FunctionVarRef = purego.NewCallback(fcb)
+			SaveCallback(FunctionVarPtr, FunctionVarRef)
 		}
-		FunctionVarRef = purego.NewCallback(fcb)
-		SaveCallback(FunctionVarPtr, FunctionVarRef)
 	}
 	var NotifyVarRef uintptr
 // pointer casts.
 func ClearHandleId(TagPtrVar uint, ClearFuncVar *ClearHandleFunc) {
-	ClearFuncVarPtr := uintptr(unsafe.Pointer(ClearFuncVar))
 	var ClearFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(ClearFuncVarPtr); ok {
+	if ClearFuncVar != nil {
-		ClearFuncVarRef = cbRefPtr
+		ClearFuncVarPtr := uintptr(unsafe.Pointer(ClearFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(ClearFuncVarPtr); ok {
-		fcb := func(arg0 uint) {
+			ClearFuncVarRef = cbRefPtr
-			cbFn := *ClearFuncVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uint) {
+				cbFn := *ClearFuncVar
+				cbFn(arg0)
+			}
+			ClearFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(ClearFuncVarPtr, ClearFuncVarRef)
 		}
-		ClearFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(ClearFuncVarPtr, ClearFuncVarRef)
 	}
 	xClearHandleId(TagPtrVar, ClearFuncVarRef)
 // need greater control or to use a custom main context.
 func IdleAdd(FunctionVar *SourceFunc, DataVar uintptr) uint {
-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
 	var FunctionVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
+	if FunctionVar != nil {
-		FunctionVarRef = cbRefPtr
+		FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
-		fcb := func(arg0 uintptr) bool {
+			FunctionVarRef = cbRefPtr
-			cbFn := *FunctionVar
+		} else {
-			return cbFn(arg0)
+			fcb := func(arg0 uintptr) bool {
+				cbFn := *FunctionVar
+				return cbFn(arg0)
+			}
+			FunctionVarRef = purego.NewCallback(fcb)
+			SaveCallback(FunctionVarPtr, FunctionVarRef)
 		}
-		FunctionVarRef = purego.NewCallback(fcb)
-		SaveCallback(FunctionVarPtr, FunctionVarRef)
 	}
 	cret := xIdleAdd(FunctionVarRef, DataVar)
 // need greater control or to use a custom main context.
 func IdleAddFull(PriorityVar int, FunctionVar *SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) uint {
-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
 	var FunctionVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
+	if FunctionVar != nil {
-		FunctionVarRef = cbRefPtr
+		FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
-		fcb := func(arg0 uintptr) bool {
+			FunctionVarRef = cbRefPtr
-			cbFn := *FunctionVar
+		} else {
-			return cbFn(arg0)
+			fcb := func(arg0 uintptr) bool {
+				cbFn := *FunctionVar
+				return cbFn(arg0)
+			}
+			FunctionVarRef = purego.NewCallback(fcb)
+			SaveCallback(FunctionVarPtr, FunctionVarRef)
 		}
-		FunctionVarRef = purego.NewCallback(fcb)
-		SaveCallback(FunctionVarPtr, FunctionVarRef)
 	}
 	var NotifyVarRef uintptr
 // This function otherwise behaves like [func@GLib.idle_add].
 func IdleAddOnce(FunctionVar *SourceOnceFunc, DataVar uintptr) uint {
-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
 	var FunctionVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
+	if FunctionVar != nil {
-		FunctionVarRef = cbRefPtr
+		FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			FunctionVarRef = cbRefPtr
-			cbFn := *FunctionVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *FunctionVar
+				cbFn(arg0)
+			}
+			FunctionVarRef = purego.NewCallback(fcb)
+			SaveCallback(FunctionVarPtr, FunctionVarRef)
 		}
-		FunctionVarRef = purego.NewCallback(fcb)
-		SaveCallback(FunctionVarPtr, FunctionVarRef)
 	}
 	cret := xIdleAddOnce(FunctionVarRef, DataVar)
 // time. See [func@GLib.get_monotonic_time].
 func TimeoutAdd(IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr) uint {
-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
 	var FunctionVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
+	if FunctionVar != nil {
-		FunctionVarRef = cbRefPtr
+		FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
-		fcb := func(arg0 uintptr) bool {
+			FunctionVarRef = cbRefPtr
-			cbFn := *FunctionVar
+		} else {
-			return cbFn(arg0)
+			fcb := func(arg0 uintptr) bool {
+				cbFn := *FunctionVar
+				return cbFn(arg0)
+			}
+			FunctionVarRef = purego.NewCallback(fcb)
+			SaveCallback(FunctionVarPtr, FunctionVarRef)
 		}
-		FunctionVarRef = purego.NewCallback(fcb)
-		SaveCallback(FunctionVarPtr, FunctionVarRef)
 	}
 	cret := xTimeoutAdd(IntervalVar, FunctionVarRef, DataVar)
 // See [func@GLib.get_monotonic_time].
 func TimeoutAddFull(PriorityVar int, IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) uint {
-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
 	var FunctionVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
+	if FunctionVar != nil {
-		FunctionVarRef = cbRefPtr
+		FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
-		fcb := func(arg0 uintptr) bool {
+			FunctionVarRef = cbRefPtr
-			cbFn := *FunctionVar
+		} else {
-			return cbFn(arg0)
+			fcb := func(arg0 uintptr) bool {
+				cbFn := *FunctionVar
+				return cbFn(arg0)
+			}
+			FunctionVarRef = purego.NewCallback(fcb)
+			SaveCallback(FunctionVarPtr, FunctionVarRef)
 		}
-		FunctionVarRef = purego.NewCallback(fcb)
-		SaveCallback(FunctionVarPtr, FunctionVarRef)
 	}
 	var NotifyVarRef uintptr
 // This function otherwise behaves like [func@GLib.timeout_add].
 func TimeoutAddOnce(IntervalVar uint, FunctionVar *SourceOnceFunc, DataVar uintptr) uint {
-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
 	var FunctionVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
+	if FunctionVar != nil {
-		FunctionVarRef = cbRefPtr
+		FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			FunctionVarRef = cbRefPtr
-			cbFn := *FunctionVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *FunctionVar
+				cbFn(arg0)
+			}
+			FunctionVarRef = purego.NewCallback(fcb)
+			SaveCallback(FunctionVarPtr, FunctionVarRef)
 		}
-		FunctionVarRef = purego.NewCallback(fcb)
-		SaveCallback(FunctionVarPtr, FunctionVarRef)
 	}
 	cret := xTimeoutAddOnce(IntervalVar, FunctionVarRef, DataVar)
 // time. See [func@GLib.get_monotonic_time].
 func TimeoutAddSeconds(IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr) uint {
-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
 	var FunctionVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
+	if FunctionVar != nil {
-		FunctionVarRef = cbRefPtr
+		FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
-		fcb := func(arg0 uintptr) bool {
+			FunctionVarRef = cbRefPtr
-			cbFn := *FunctionVar
+		} else {
-			return cbFn(arg0)
+			fcb := func(arg0 uintptr) bool {
+				cbFn := *FunctionVar
+				return cbFn(arg0)
+			}
+			FunctionVarRef = purego.NewCallback(fcb)
+			SaveCallback(FunctionVarPtr, FunctionVarRef)
 		}
-		FunctionVarRef = purego.NewCallback(fcb)
-		SaveCallback(FunctionVarPtr, FunctionVarRef)
 	}
 	cret := xTimeoutAddSeconds(IntervalVar, FunctionVarRef, DataVar)
 // time. See [func@GLib.get_monotonic_time].
 func TimeoutAddSecondsFull(PriorityVar int, IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) uint {
-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
 	var FunctionVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
+	if FunctionVar != nil {
-		FunctionVarRef = cbRefPtr
+		FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
-		fcb := func(arg0 uintptr) bool {
+			FunctionVarRef = cbRefPtr
-			cbFn := *FunctionVar
+		} else {
-			return cbFn(arg0)
+			fcb := func(arg0 uintptr) bool {
+				cbFn := *FunctionVar
+				return cbFn(arg0)
+			}
+			FunctionVarRef = purego.NewCallback(fcb)
+			SaveCallback(FunctionVarPtr, FunctionVarRef)
 		}
-		FunctionVarRef = purego.NewCallback(fcb)
-		SaveCallback(FunctionVarPtr, FunctionVarRef)
 	}
 	var NotifyVarRef uintptr
 // seconds.
 func TimeoutAddSecondsOnce(IntervalVar uint, FunctionVar *SourceOnceFunc, DataVar uintptr) uint {
-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
 	var FunctionVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
+	if FunctionVar != nil {
-		FunctionVarRef = cbRefPtr
+		FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			FunctionVarRef = cbRefPtr
-			cbFn := *FunctionVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *FunctionVar
+				cbFn(arg0)
+			}
+			FunctionVarRef = purego.NewCallback(fcb)
+			SaveCallback(FunctionVarPtr, FunctionVarRef)
 		}
-		FunctionVarRef = purego.NewCallback(fcb)
-		SaveCallback(FunctionVarPtr, FunctionVarRef)
 	}
 	cret := xTimeoutAddSecondsOnce(IntervalVar, FunctionVarRef, DataVar)

M v4/glib/gmarkup.go +11 -9

 // free it and create a new parse context).
 func NewMarkupParseContext(ParserVar *MarkupParser, FlagsVar MarkupParseFlags, UserDataVar uintptr, UserDataDnotifyVar *DestroyNotify) *MarkupParseContext {
-	UserDataDnotifyVarPtr := uintptr(unsafe.Pointer(UserDataDnotifyVar))
 	var UserDataDnotifyVarRef uintptr
-	if cbRefPtr, ok := GetCallback(UserDataDnotifyVarPtr); ok {
+	if UserDataDnotifyVar != nil {
-		UserDataDnotifyVarRef = cbRefPtr
+		UserDataDnotifyVarPtr := uintptr(unsafe.Pointer(UserDataDnotifyVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(UserDataDnotifyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			UserDataDnotifyVarRef = cbRefPtr
-			cbFn := *UserDataDnotifyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *UserDataDnotifyVar
+				cbFn(arg0)
+			}
+			UserDataDnotifyVarRef = purego.NewCallback(fcb)
+			SaveCallback(UserDataDnotifyVarPtr, UserDataDnotifyVarRef)
 		}
-		UserDataDnotifyVarRef = purego.NewCallback(fcb)
-		SaveCallback(UserDataDnotifyVarPtr, UserDataDnotifyVarRef)
 	}
 	cret := xNewMarkupParseContext(ParserVar, FlagsVar, UserDataVar, UserDataDnotifyVarRef)

M v4/glib/gmem.go +11 -9

 // ```
 func ClearPointer(PpVar uintptr, DestroyVar *DestroyNotify) {
-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
 	var DestroyVarRef uintptr
-	if cbRefPtr, ok := GetCallback(DestroyVarPtr); ok {
+	if DestroyVar != nil {
-		DestroyVarRef = cbRefPtr
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(DestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyVarRef = cbRefPtr
-			cbFn := *DestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			SaveCallback(DestroyVarPtr, DestroyVarRef)
 		}
-		DestroyVarRef = purego.NewCallback(fcb)
-		SaveCallback(DestroyVarPtr, DestroyVarRef)
 	}
 	xClearPointer(PpVar, DestroyVarRef)

M v4/glib/gmessages.go +66 -54

 // [Using Structured Logging](logging.html#using-structured-logging).
 func LogSetDefaultHandler(LogFuncVar *LogFunc, UserDataVar uintptr) uintptr {
-	LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
 	var LogFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(LogFuncVarPtr); ok {
+	if LogFuncVar != nil {
-		LogFuncVarRef = cbRefPtr
+		LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(LogFuncVarPtr); ok {
-		fcb := func(arg0 string, arg1 LogLevelFlags, arg2 string, arg3 uintptr) {
+			LogFuncVarRef = cbRefPtr
-			cbFn := *LogFuncVar
+		} else {
-			cbFn(arg0, arg1, arg2, arg3)
+			fcb := func(arg0 string, arg1 LogLevelFlags, arg2 string, arg3 uintptr) {
+				cbFn := *LogFuncVar
+				cbFn(arg0, arg1, arg2, arg3)
+			}
+			LogFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(LogFuncVarPtr, LogFuncVarRef)
 		}
-		LogFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(LogFuncVarPtr, LogFuncVarRef)
 	}
 	cret := xLogSetDefaultHandler(LogFuncVarRef, UserDataVar)
 // ```
 func LogSetHandler(LogDomainVar string, LogLevelsVar LogLevelFlags, LogFuncVar *LogFunc, UserDataVar uintptr) uint {
-	LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
 	var LogFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(LogFuncVarPtr); ok {
+	if LogFuncVar != nil {
-		LogFuncVarRef = cbRefPtr
+		LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(LogFuncVarPtr); ok {
-		fcb := func(arg0 string, arg1 LogLevelFlags, arg2 string, arg3 uintptr) {
+			LogFuncVarRef = cbRefPtr
-			cbFn := *LogFuncVar
+		} else {
-			cbFn(arg0, arg1, arg2, arg3)
+			fcb := func(arg0 string, arg1 LogLevelFlags, arg2 string, arg3 uintptr) {
+				cbFn := *LogFuncVar
+				cbFn(arg0, arg1, arg2, arg3)
+			}
+			LogFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(LogFuncVarPtr, LogFuncVarRef)
 		}
-		LogFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(LogFuncVarPtr, LogFuncVarRef)
 	}
 	cret := xLogSetHandler(LogDomainVar, LogLevelsVar, LogFuncVarRef, UserDataVar)
 // application domain.
 func LogSetHandlerFull(LogDomainVar string, LogLevelsVar LogLevelFlags, LogFuncVar *LogFunc, UserDataVar uintptr, DestroyVar *DestroyNotify) uint {
-	LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
 	var LogFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(LogFuncVarPtr); ok {
+	if LogFuncVar != nil {
-		LogFuncVarRef = cbRefPtr
+		LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(LogFuncVarPtr); ok {
-		fcb := func(arg0 string, arg1 LogLevelFlags, arg2 string, arg3 uintptr) {
+			LogFuncVarRef = cbRefPtr
-			cbFn := *LogFuncVar
+		} else {
-			cbFn(arg0, arg1, arg2, arg3)
+			fcb := func(arg0 string, arg1 LogLevelFlags, arg2 string, arg3 uintptr) {
+				cbFn := *LogFuncVar
+				cbFn(arg0, arg1, arg2, arg3)
+			}
+			LogFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(LogFuncVarPtr, LogFuncVarRef)
 		}
-		LogFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(LogFuncVarPtr, LogFuncVarRef)
 	}
-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
 	var DestroyVarRef uintptr
-	if cbRefPtr, ok := GetCallback(DestroyVarPtr); ok {
+	if DestroyVar != nil {
-		DestroyVarRef = cbRefPtr
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(DestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyVarRef = cbRefPtr
-			cbFn := *DestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			SaveCallback(DestroyVarPtr, DestroyVarRef)
 		}
-		DestroyVarRef = purego.NewCallback(fcb)
-		SaveCallback(DestroyVarPtr, DestroyVarRef)
 	}
 	cret := xLogSetHandlerFull(LogDomainVar, LogLevelsVar, LogFuncVarRef, UserDataVar, DestroyVarRef)
 // There can only be one writer function. It is an error to set more than one.
 func LogSetWriterFunc(FuncVar *LogWriterFunc, UserDataVar uintptr, UserDataFreeVar *DestroyNotify) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 LogLevelFlags, arg1 []LogField, arg2 uint, arg3 uintptr) LogWriterOutput {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2, arg3)
+			fcb := func(arg0 LogLevelFlags, arg1 []LogField, arg2 uint, arg3 uintptr) LogWriterOutput {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1, arg2, arg3)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
-	UserDataFreeVarPtr := uintptr(unsafe.Pointer(UserDataFreeVar))
 	var UserDataFreeVarRef uintptr
-	if cbRefPtr, ok := GetCallback(UserDataFreeVarPtr); ok {
+	if UserDataFreeVar != nil {
-		UserDataFreeVarRef = cbRefPtr
+		UserDataFreeVarPtr := uintptr(unsafe.Pointer(UserDataFreeVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(UserDataFreeVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			UserDataFreeVarRef = cbRefPtr
-			cbFn := *UserDataFreeVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *UserDataFreeVar
+				cbFn(arg0)
+			}
+			UserDataFreeVarRef = purego.NewCallback(fcb)
+			SaveCallback(UserDataFreeVarPtr, UserDataFreeVarRef)
 		}
-		UserDataFreeVarRef = purego.NewCallback(fcb)
-		SaveCallback(UserDataFreeVarPtr, UserDataFreeVarRef)
 	}
 	xLogSetWriterFunc(FuncVarRef, UserDataVar, UserDataFreeVarRef)

M v4/glib/gnode.go +33 -27

 // that would modify the structure of the tree.
 func (x *Node) ChildrenForeach(FlagsVar TraverseFlags, FuncVar *NodeForeachFunc, DataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 *Node, arg1 uintptr) {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 *Node, arg1 uintptr) {
+				cbFn := *FuncVar
+				cbFn(arg0, arg1)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xNodeChildrenForeach(x.GoPointer(), FlagsVar, FuncVarRef, DataVar)
 // Recursively copies a #GNode and its data.
 func (x *Node) CopyDeep(CopyFuncVar *CopyFunc, DataVar uintptr) *Node {
-	CopyFuncVarPtr := uintptr(unsafe.Pointer(CopyFuncVar))
 	var CopyFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(CopyFuncVarPtr); ok {
+	if CopyFuncVar != nil {
-		CopyFuncVarRef = cbRefPtr
+		CopyFuncVarPtr := uintptr(unsafe.Pointer(CopyFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(CopyFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
+			CopyFuncVarRef = cbRefPtr
-			cbFn := *CopyFuncVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
+				cbFn := *CopyFuncVar
+				return cbFn(arg0, arg1)
+			}
+			CopyFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(CopyFuncVarPtr, CopyFuncVarRef)
 		}
-		CopyFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(CopyFuncVarPtr, CopyFuncVarRef)
 	}
 	cret := xNodeCopyDeep(x.GoPointer(), CopyFuncVarRef, DataVar)
 // @func must not do anything that would modify the structure of the tree.
 func (x *Node) Traverse(OrderVar TraverseType, FlagsVar TraverseFlags, MaxDepthVar int, FuncVar *NodeTraverseFunc, DataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 *Node, arg1 uintptr) bool {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 *Node, arg1 uintptr) bool {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xNodeTraverse(x.GoPointer(), OrderVar, FlagsVar, MaxDepthVar, FuncVarRef, DataVar)

M v4/glib/goption.go +11 -9

 // specified when constructing the group with g_option_group_new().
 func (x *OptionGroup) SetErrorHook(ErrorFuncVar *OptionErrorFunc) {
-	ErrorFuncVarPtr := uintptr(unsafe.Pointer(ErrorFuncVar))
 	var ErrorFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(ErrorFuncVarPtr); ok {
+	if ErrorFuncVar != nil {
-		ErrorFuncVarRef = cbRefPtr
+		ErrorFuncVarPtr := uintptr(unsafe.Pointer(ErrorFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(ErrorFuncVarPtr); ok {
-		fcb := func(arg0 *OptionContext, arg1 *OptionGroup, arg2 uintptr, arg3 **Error) {
+			ErrorFuncVarRef = cbRefPtr
-			cbFn := *ErrorFuncVar
+		} else {
-			cbFn(arg0, arg1, arg2, arg3)
+			fcb := func(arg0 *OptionContext, arg1 *OptionGroup, arg2 uintptr, arg3 **Error) {
+				cbFn := *ErrorFuncVar
+				cbFn(arg0, arg1, arg2, arg3)
+			}
+			ErrorFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(ErrorFuncVarPtr, ErrorFuncVarRef)
 		}
-		ErrorFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(ErrorFuncVarPtr, ErrorFuncVarRef)
 	}
 	xOptionGroupSetErrorHook(x.GoPointer(), ErrorFuncVarRef)

M v4/glib/gqsort.go +22 -18

 // Unlike `qsort()`, this is guaranteed to be a stable sort (since GLib 2.32).
 func QsortWithData(PbaseVar uintptr, TotalElemsVar int, SizeVar uint, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {
-	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
 	var CompareFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
+	if CompareFuncVar != nil {
-		CompareFuncVarRef = cbRefPtr
+		CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+			CompareFuncVarRef = cbRefPtr
-			cbFn := *CompareFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+				cbFn := *CompareFuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			CompareFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
 		}
-		CompareFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
 	}
 	xQsortWithData(PbaseVar, TotalElemsVar, SizeVar, CompareFuncVarRef, UserDataVar)
 // Unlike `qsort()`, this is guaranteed to be a stable sort.
 func SortArray(ArrayVar []uintptr, NElementsVar uint, ElementSizeVar uint, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {
-	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
 	var CompareFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
+	if CompareFuncVar != nil {
-		CompareFuncVarRef = cbRefPtr
+		CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+			CompareFuncVarRef = cbRefPtr
-			cbFn := *CompareFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+				cbFn := *CompareFuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			CompareFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
 		}
-		CompareFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
 	}
 	xSortArray(ArrayVar, NElementsVar, ElementSizeVar, CompareFuncVarRef, UserDataVar)

M v4/glib/gqueue.go +55 -45

 // first argument and the given user data as the second argument.
 func (x *Queue) FindCustom(DataVar uintptr, FuncVar *CompareFunc) *List {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) int {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) int {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	cret := xQueueFindCustom(x.GoPointer(), DataVar, FuncVarRef)
 // not modify any part of the queue after that element.
 func (x *Queue) Foreach(FuncVar *Func, UserDataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) {
+				cbFn := *FuncVar
+				cbFn(arg0, arg1)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xQueueForeach(x.GoPointer(), FuncVarRef, UserDataVar)
 // element from it).
 func (x *Queue) FreeFull(FreeFuncVar *DestroyNotify) {
-	FreeFuncVarPtr := uintptr(unsafe.Pointer(FreeFuncVar))
 	var FreeFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FreeFuncVarPtr); ok {
+	if FreeFuncVar != nil {
-		FreeFuncVarRef = cbRefPtr
+		FreeFuncVarPtr := uintptr(unsafe.Pointer(FreeFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FreeFuncVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			FreeFuncVarRef = cbRefPtr
-			cbFn := *FreeFuncVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *FreeFuncVar
+				cbFn(arg0)
+			}
+			FreeFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FreeFuncVarPtr, FreeFuncVarRef)
 		}
-		FreeFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FreeFuncVarPtr, FreeFuncVarRef)
 	}
 	xQueueFreeFull(x.GoPointer(), FreeFuncVarRef)
 // Inserts @data into @queue using @func to determine the new position.
 func (x *Queue) InsertSorted(DataVar uintptr, FuncVar *CompareDataFunc, UserDataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xQueueInsertSorted(x.GoPointer(), DataVar, FuncVarRef, UserDataVar)
 // Sorts @queue using @compare_func.
 func (x *Queue) Sort(CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {
-	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
 	var CompareFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
+	if CompareFuncVar != nil {
-		CompareFuncVarRef = cbRefPtr
+		CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+			CompareFuncVarRef = cbRefPtr
-			cbFn := *CompareFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+				cbFn := *CompareFuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			CompareFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
 		}
-		CompareFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
 	}
 	xQueueSort(x.GoPointer(), CompareFuncVarRef, UserDataVar)

M v4/glib/grcbox.go +22 -18

 // when the callback is called and will be freed.
 func AtomicRcBoxReleaseFull(MemBlockVar uintptr, ClearFuncVar *DestroyNotify) {
-	ClearFuncVarPtr := uintptr(unsafe.Pointer(ClearFuncVar))
 	var ClearFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(ClearFuncVarPtr); ok {
+	if ClearFuncVar != nil {
-		ClearFuncVarRef = cbRefPtr
+		ClearFuncVarPtr := uintptr(unsafe.Pointer(ClearFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(ClearFuncVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			ClearFuncVarRef = cbRefPtr
-			cbFn := *ClearFuncVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *ClearFuncVar
+				cbFn(arg0)
+			}
+			ClearFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(ClearFuncVarPtr, ClearFuncVarRef)
 		}
-		ClearFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(ClearFuncVarPtr, ClearFuncVarRef)
 	}
 	xAtomicRcBoxReleaseFull(MemBlockVar, ClearFuncVarRef)
 // resources allocated for @mem_block.
 func RcBoxReleaseFull(MemBlockVar uintptr, ClearFuncVar *DestroyNotify) {
-	ClearFuncVarPtr := uintptr(unsafe.Pointer(ClearFuncVar))
 	var ClearFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(ClearFuncVarPtr); ok {
+	if ClearFuncVar != nil {
-		ClearFuncVarRef = cbRefPtr
+		ClearFuncVarPtr := uintptr(unsafe.Pointer(ClearFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(ClearFuncVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			ClearFuncVarRef = cbRefPtr
-			cbFn := *ClearFuncVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *ClearFuncVar
+				cbFn(arg0)
+			}
+			ClearFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(ClearFuncVarPtr, ClearFuncVarRef)
 		}
-		ClearFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(ClearFuncVarPtr, ClearFuncVarRef)
 	}
 	xRcBoxReleaseFull(MemBlockVar, ClearFuncVarRef)

M v4/glib/gregex.go +11 -9

 func (x *Regex) ReplaceEval(StringVar []string, StringLenVar int, StartPositionVar int, MatchOptionsVar RegexMatchFlags, EvalVar *RegexEvalCallback, UserDataVar uintptr) (string, error) {
 	var cerr *Error
-	EvalVarPtr := uintptr(unsafe.Pointer(EvalVar))
 	var EvalVarRef uintptr
-	if cbRefPtr, ok := GetCallback(EvalVarPtr); ok {
+	if EvalVar != nil {
-		EvalVarRef = cbRefPtr
+		EvalVarPtr := uintptr(unsafe.Pointer(EvalVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(EvalVarPtr); ok {
-		fcb := func(arg0 *MatchInfo, arg1 *String, arg2 uintptr) bool {
+			EvalVarRef = cbRefPtr
-			cbFn := *EvalVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 *MatchInfo, arg1 *String, arg2 uintptr) bool {
+				cbFn := *EvalVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			EvalVarRef = purego.NewCallback(fcb)
+			SaveCallback(EvalVarPtr, EvalVarRef)
 		}
-		EvalVarRef = purego.NewCallback(fcb)
-		SaveCallback(EvalVarPtr, EvalVarRef)
 	}
 	cret := xRegexReplaceEval(x.GoPointer(), StringVar, StringLenVar, StartPositionVar, MatchOptionsVar, EvalVarRef, UserDataVar, &cerr)

M v4/glib/grel.go +22 -18

 // before any records are added to the #GRelation.
 func (x *Relation) Index(FieldVar int, HashFuncVar *HashFunc, KeyEqualFuncVar *EqualFunc) {
-	HashFuncVarPtr := uintptr(unsafe.Pointer(HashFuncVar))
 	var HashFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(HashFuncVarPtr); ok {
+	if HashFuncVar != nil {
-		HashFuncVarRef = cbRefPtr
+		HashFuncVarPtr := uintptr(unsafe.Pointer(HashFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(HashFuncVarPtr); ok {
-		fcb := func(arg0 uintptr) uint {
+			HashFuncVarRef = cbRefPtr
-			cbFn := *HashFuncVar
+		} else {
-			return cbFn(arg0)
+			fcb := func(arg0 uintptr) uint {
+				cbFn := *HashFuncVar
+				return cbFn(arg0)
+			}
+			HashFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(HashFuncVarPtr, HashFuncVarRef)
 		}
-		HashFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(HashFuncVarPtr, HashFuncVarRef)
 	}
-	KeyEqualFuncVarPtr := uintptr(unsafe.Pointer(KeyEqualFuncVar))
 	var KeyEqualFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(KeyEqualFuncVarPtr); ok {
+	if KeyEqualFuncVar != nil {
-		KeyEqualFuncVarRef = cbRefPtr
+		KeyEqualFuncVarPtr := uintptr(unsafe.Pointer(KeyEqualFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(KeyEqualFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) bool {
+			KeyEqualFuncVarRef = cbRefPtr
-			cbFn := *KeyEqualFuncVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) bool {
+				cbFn := *KeyEqualFuncVar
+				return cbFn(arg0, arg1)
+			}
+			KeyEqualFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(KeyEqualFuncVarPtr, KeyEqualFuncVarRef)
 		}
-		KeyEqualFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(KeyEqualFuncVarPtr, KeyEqualFuncVarRef)
 	}
 	xRelationIndex(x.GoPointer(), FieldVar, HashFuncVarRef, KeyEqualFuncVarRef)

M v4/glib/gscanner.go +11 -9

 // parameter.
 func (x *Scanner) ScopeForeachSymbol(ScopeIdVar uint, FuncVar *HFunc, UserDataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+				cbFn := *FuncVar
+				cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xScannerScopeForeachSymbol(x.GoPointer(), ScopeIdVar, FuncVarRef, UserDataVar)

M v4/glib/gsequence.go +132 -108

 // to the function. @func must not modify the sequence itself.
 func (x *Sequence) Foreach(FuncVar *Func, UserDataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) {
+				cbFn := *FuncVar
+				cbFn(arg0, arg1)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xSequenceForeach(x.GoPointer(), FuncVarRef, UserDataVar)
 // g_sequence_sort() or g_sequence_sort_iter().
 func (x *Sequence) InsertSorted(DataVar uintptr, CmpFuncVar *CompareDataFunc, CmpDataVar uintptr) *SequenceIter {
-	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
 	var CmpFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
+	if CmpFuncVar != nil {
-		CmpFuncVarRef = cbRefPtr
+		CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+			CmpFuncVarRef = cbRefPtr
-			cbFn := *CmpFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+				cbFn := *CmpFuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			CmpFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
 		}
-		CmpFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
 	}
 	cret := xSequenceInsertSorted(x.GoPointer(), DataVar, CmpFuncVarRef, CmpDataVar)
 // g_sequence_sort() or g_sequence_sort_iter().
 func (x *Sequence) InsertSortedIter(DataVar uintptr, IterCmpVar *SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {
-	IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
 	var IterCmpVarRef uintptr
-	if cbRefPtr, ok := GetCallback(IterCmpVarPtr); ok {
+	if IterCmpVar != nil {
-		IterCmpVarRef = cbRefPtr
+		IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(IterCmpVarPtr); ok {
-		fcb := func(arg0 *SequenceIter, arg1 *SequenceIter, arg2 uintptr) int {
+			IterCmpVarRef = cbRefPtr
-			cbFn := *IterCmpVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 *SequenceIter, arg1 *SequenceIter, arg2 uintptr) int {
+				cbFn := *IterCmpVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			IterCmpVarRef = purego.NewCallback(fcb)
+			SaveCallback(IterCmpVarPtr, IterCmpVarRef)
 		}
-		IterCmpVarRef = purego.NewCallback(fcb)
-		SaveCallback(IterCmpVarPtr, IterCmpVarRef)
 	}
 	cret := xSequenceInsertSortedIter(x.GoPointer(), DataVar, IterCmpVarRef, CmpDataVar)
 // unsorted.
 func (x *Sequence) Lookup(DataVar uintptr, CmpFuncVar *CompareDataFunc, CmpDataVar uintptr) *SequenceIter {
-	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
 	var CmpFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
+	if CmpFuncVar != nil {
-		CmpFuncVarRef = cbRefPtr
+		CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+			CmpFuncVarRef = cbRefPtr
-			cbFn := *CmpFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+				cbFn := *CmpFuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			CmpFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
 		}
-		CmpFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
 	}
 	cret := xSequenceLookup(x.GoPointer(), DataVar, CmpFuncVarRef, CmpDataVar)
 // unsorted.
 func (x *Sequence) LookupIter(DataVar uintptr, IterCmpVar *SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {
-	IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
 	var IterCmpVarRef uintptr
-	if cbRefPtr, ok := GetCallback(IterCmpVarPtr); ok {
+	if IterCmpVar != nil {
-		IterCmpVarRef = cbRefPtr
+		IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(IterCmpVarPtr); ok {
-		fcb := func(arg0 *SequenceIter, arg1 *SequenceIter, arg2 uintptr) int {
+			IterCmpVarRef = cbRefPtr
-			cbFn := *IterCmpVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 *SequenceIter, arg1 *SequenceIter, arg2 uintptr) int {
+				cbFn := *IterCmpVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			IterCmpVarRef = purego.NewCallback(fcb)
+			SaveCallback(IterCmpVarPtr, IterCmpVarRef)
 		}
-		IterCmpVarRef = purego.NewCallback(fcb)
-		SaveCallback(IterCmpVarPtr, IterCmpVarRef)
 	}
 	cret := xSequenceLookupIter(x.GoPointer(), DataVar, IterCmpVarRef, CmpDataVar)
 // unsorted.
 func (x *Sequence) Search(DataVar uintptr, CmpFuncVar *CompareDataFunc, CmpDataVar uintptr) *SequenceIter {
-	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
 	var CmpFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
+	if CmpFuncVar != nil {
-		CmpFuncVarRef = cbRefPtr
+		CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+			CmpFuncVarRef = cbRefPtr
-			cbFn := *CmpFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+				cbFn := *CmpFuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			CmpFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
 		}
-		CmpFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
 	}
 	cret := xSequenceSearch(x.GoPointer(), DataVar, CmpFuncVarRef, CmpDataVar)
 // unsorted.
 func (x *Sequence) SearchIter(DataVar uintptr, IterCmpVar *SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {
-	IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
 	var IterCmpVarRef uintptr
-	if cbRefPtr, ok := GetCallback(IterCmpVarPtr); ok {
+	if IterCmpVar != nil {
-		IterCmpVarRef = cbRefPtr
+		IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(IterCmpVarPtr); ok {
-		fcb := func(arg0 *SequenceIter, arg1 *SequenceIter, arg2 uintptr) int {
+			IterCmpVarRef = cbRefPtr
-			cbFn := *IterCmpVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 *SequenceIter, arg1 *SequenceIter, arg2 uintptr) int {
+				cbFn := *IterCmpVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			IterCmpVarRef = purego.NewCallback(fcb)
+			SaveCallback(IterCmpVarPtr, IterCmpVarRef)
 		}
-		IterCmpVarRef = purego.NewCallback(fcb)
-		SaveCallback(IterCmpVarPtr, IterCmpVarRef)
 	}
 	cret := xSequenceSearchIter(x.GoPointer(), DataVar, IterCmpVarRef, CmpDataVar)
 // if the second comes before the first.
 func (x *Sequence) Sort(CmpFuncVar *CompareDataFunc, CmpDataVar uintptr) {
-	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
 	var CmpFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
+	if CmpFuncVar != nil {
-		CmpFuncVarRef = cbRefPtr
+		CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+			CmpFuncVarRef = cbRefPtr
-			cbFn := *CmpFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+				cbFn := *CmpFuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			CmpFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
 		}
-		CmpFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
 	}
 	xSequenceSort(x.GoPointer(), CmpFuncVarRef, CmpDataVar)
 // iterator comes before the first.
 func (x *Sequence) SortIter(CmpFuncVar *SequenceIterCompareFunc, CmpDataVar uintptr) {
-	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
 	var CmpFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
+	if CmpFuncVar != nil {
-		CmpFuncVarRef = cbRefPtr
+		CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
-		fcb := func(arg0 *SequenceIter, arg1 *SequenceIter, arg2 uintptr) int {
+			CmpFuncVarRef = cbRefPtr
-			cbFn := *CmpFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 *SequenceIter, arg1 *SequenceIter, arg2 uintptr) int {
+				cbFn := *CmpFuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			CmpFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
 		}
-		CmpFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
 	}
 	xSequenceSortIter(x.GoPointer(), CmpFuncVarRef, CmpDataVar)
 // itself.
 func SequenceForeachRange(BeginVar *SequenceIter, EndVar *SequenceIter, FuncVar *Func, UserDataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) {
+				cbFn := *FuncVar
+				cbFn(arg0, arg1)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xSequenceForeachRange(BeginVar, EndVar, FuncVarRef, UserDataVar)
 // the second item comes before the first.
 func SequenceSortChanged(IterVar *SequenceIter, CmpFuncVar *CompareDataFunc, CmpDataVar uintptr) {
-	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
 	var CmpFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
+	if CmpFuncVar != nil {
-		CmpFuncVarRef = cbRefPtr
+		CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+			CmpFuncVarRef = cbRefPtr
-			cbFn := *CmpFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+				cbFn := *CmpFuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			CmpFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
 		}
-		CmpFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
 	}
 	xSequenceSortChanged(IterVar, CmpFuncVarRef, CmpDataVar)
 // iterator comes before the first.
 func SequenceSortChangedIter(IterVar *SequenceIter, IterCmpVar *SequenceIterCompareFunc, CmpDataVar uintptr) {
-	IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
 	var IterCmpVarRef uintptr
-	if cbRefPtr, ok := GetCallback(IterCmpVarPtr); ok {
+	if IterCmpVar != nil {
-		IterCmpVarRef = cbRefPtr
+		IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(IterCmpVarPtr); ok {
-		fcb := func(arg0 *SequenceIter, arg1 *SequenceIter, arg2 uintptr) int {
+			IterCmpVarRef = cbRefPtr
-			cbFn := *IterCmpVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 *SequenceIter, arg1 *SequenceIter, arg2 uintptr) int {
+				cbFn := *IterCmpVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			IterCmpVarRef = purego.NewCallback(fcb)
+			SaveCallback(IterCmpVarPtr, IterCmpVarRef)
 		}
-		IterCmpVarRef = purego.NewCallback(fcb)
-		SaveCallback(IterCmpVarPtr, IterCmpVarRef)
 	}
 	xSequenceSortChangedIter(IterVar, IterCmpVarRef, CmpDataVar)

M v4/glib/gtestutils.go +132 -108

 // and it is recommended to do so even if it isn’t.
 func TestAddDataFunc(TestpathVar string, TestDataVar uintptr, TestFuncVar *TestDataFunc) {
-	TestFuncVarPtr := uintptr(unsafe.Pointer(TestFuncVar))
 	var TestFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(TestFuncVarPtr); ok {
+	if TestFuncVar != nil {
-		TestFuncVarRef = cbRefPtr
+		TestFuncVarPtr := uintptr(unsafe.Pointer(TestFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(TestFuncVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			TestFuncVarRef = cbRefPtr
-			cbFn := *TestFuncVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *TestFuncVar
+				cbFn(arg0)
+			}
+			TestFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(TestFuncVarPtr, TestFuncVarRef)
 		}
-		TestFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(TestFuncVarPtr, TestFuncVarRef)
 	}
 	xTestAddDataFunc(TestpathVar, TestDataVar, TestFuncVarRef)
 // is freeing @test_data after the test run is complete.
 func TestAddDataFuncFull(TestpathVar string, TestDataVar uintptr, TestFuncVar *TestDataFunc, DataFreeFuncVar *DestroyNotify) {
-	TestFuncVarPtr := uintptr(unsafe.Pointer(TestFuncVar))
 	var TestFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(TestFuncVarPtr); ok {
+	if TestFuncVar != nil {
-		TestFuncVarRef = cbRefPtr
+		TestFuncVarPtr := uintptr(unsafe.Pointer(TestFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(TestFuncVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			TestFuncVarRef = cbRefPtr
-			cbFn := *TestFuncVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *TestFuncVar
+				cbFn(arg0)
+			}
+			TestFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(TestFuncVarPtr, TestFuncVarRef)
 		}
-		TestFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(TestFuncVarPtr, TestFuncVarRef)
 	}
-	DataFreeFuncVarPtr := uintptr(unsafe.Pointer(DataFreeFuncVar))
 	var DataFreeFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(DataFreeFuncVarPtr); ok {
+	if DataFreeFuncVar != nil {
-		DataFreeFuncVarRef = cbRefPtr
+		DataFreeFuncVarPtr := uintptr(unsafe.Pointer(DataFreeFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(DataFreeFuncVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DataFreeFuncVarRef = cbRefPtr
-			cbFn := *DataFreeFuncVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DataFreeFuncVar
+				cbFn(arg0)
+			}
+			DataFreeFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(DataFreeFuncVarPtr, DataFreeFuncVarRef)
 		}
-		DataFreeFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(DataFreeFuncVarPtr, DataFreeFuncVarRef)
 	}
 	xTestAddDataFuncFull(TestpathVar, TestDataVar, TestFuncVarRef, DataFreeFuncVarRef)
 // it is recommended to do so even if it isn’t.
 func TestAddFunc(TestpathVar string, TestFuncVar *TestFunc) {
-	TestFuncVarPtr := uintptr(unsafe.Pointer(TestFuncVar))
 	var TestFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(TestFuncVarPtr); ok {
+	if TestFuncVar != nil {
-		TestFuncVarRef = cbRefPtr
+		TestFuncVarPtr := uintptr(unsafe.Pointer(TestFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(TestFuncVarPtr); ok {
-		fcb := func() {
+			TestFuncVarRef = cbRefPtr
-			cbFn := *TestFuncVar
+		} else {
-			cbFn()
+			fcb := func() {
+				cbFn := *TestFuncVar
+				cbFn()
+			}
+			TestFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(TestFuncVarPtr, TestFuncVarRef)
 		}
-		TestFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(TestFuncVarPtr, TestFuncVarRef)
 	}
 	xTestAddFunc(TestpathVar, TestFuncVarRef)
 func TestAddVtable(TestpathVar string, DataSizeVar uint, TestDataVar uintptr, DataSetupVar *TestFixtureFunc, DataTestVar *TestFixtureFunc, DataTeardownVar *TestFixtureFunc) {
-	DataSetupVarPtr := uintptr(unsafe.Pointer(DataSetupVar))
 	var DataSetupVarRef uintptr
-	if cbRefPtr, ok := GetCallback(DataSetupVarPtr); ok {
+	if DataSetupVar != nil {
-		DataSetupVarRef = cbRefPtr
+		DataSetupVarPtr := uintptr(unsafe.Pointer(DataSetupVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(DataSetupVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) {
+			DataSetupVarRef = cbRefPtr
-			cbFn := *DataSetupVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) {
+				cbFn := *DataSetupVar
+				cbFn(arg0, arg1)
+			}
+			DataSetupVarRef = purego.NewCallback(fcb)
+			SaveCallback(DataSetupVarPtr, DataSetupVarRef)
 		}
-		DataSetupVarRef = purego.NewCallback(fcb)
-		SaveCallback(DataSetupVarPtr, DataSetupVarRef)
 	}
-	DataTestVarPtr := uintptr(unsafe.Pointer(DataTestVar))
 	var DataTestVarRef uintptr
-	if cbRefPtr, ok := GetCallback(DataTestVarPtr); ok {
+	if DataTestVar != nil {
-		DataTestVarRef = cbRefPtr
+		DataTestVarPtr := uintptr(unsafe.Pointer(DataTestVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(DataTestVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) {
+			DataTestVarRef = cbRefPtr
-			cbFn := *DataTestVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) {
+				cbFn := *DataTestVar
+				cbFn(arg0, arg1)
+			}
+			DataTestVarRef = purego.NewCallback(fcb)
+			SaveCallback(DataTestVarPtr, DataTestVarRef)
 		}
-		DataTestVarRef = purego.NewCallback(fcb)
-		SaveCallback(DataTestVarPtr, DataTestVarRef)
 	}
-	DataTeardownVarPtr := uintptr(unsafe.Pointer(DataTeardownVar))
 	var DataTeardownVarRef uintptr
-	if cbRefPtr, ok := GetCallback(DataTeardownVarPtr); ok {
+	if DataTeardownVar != nil {
-		DataTeardownVarRef = cbRefPtr
+		DataTeardownVarPtr := uintptr(unsafe.Pointer(DataTeardownVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(DataTeardownVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) {
+			DataTeardownVarRef = cbRefPtr
-			cbFn := *DataTeardownVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) {
+				cbFn := *DataTeardownVar
+				cbFn(arg0, arg1)
+			}
+			DataTeardownVarRef = purego.NewCallback(fcb)
+			SaveCallback(DataTeardownVarPtr, DataTeardownVarRef)
 		}
-		DataTeardownVarRef = purego.NewCallback(fcb)
-		SaveCallback(DataTeardownVarPtr, DataTeardownVarRef)
 	}
 	xTestAddVtable(TestpathVar, DataSizeVar, TestDataVar, DataSetupVarRef, DataTestVarRef, DataTeardownVarRef)
 // varying @test_name and @data_test arguments.
 func TestCreateCase(TestNameVar string, DataSizeVar uint, TestDataVar uintptr, DataSetupVar *TestFixtureFunc, DataTestVar *TestFixtureFunc, DataTeardownVar *TestFixtureFunc) *TestCase {
-	DataSetupVarPtr := uintptr(unsafe.Pointer(DataSetupVar))
 	var DataSetupVarRef uintptr
-	if cbRefPtr, ok := GetCallback(DataSetupVarPtr); ok {
+	if DataSetupVar != nil {
-		DataSetupVarRef = cbRefPtr
+		DataSetupVarPtr := uintptr(unsafe.Pointer(DataSetupVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(DataSetupVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) {
+			DataSetupVarRef = cbRefPtr
-			cbFn := *DataSetupVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) {
+				cbFn := *DataSetupVar
+				cbFn(arg0, arg1)
+			}
+			DataSetupVarRef = purego.NewCallback(fcb)
+			SaveCallback(DataSetupVarPtr, DataSetupVarRef)
 		}
-		DataSetupVarRef = purego.NewCallback(fcb)
-		SaveCallback(DataSetupVarPtr, DataSetupVarRef)
 	}
-	DataTestVarPtr := uintptr(unsafe.Pointer(DataTestVar))
 	var DataTestVarRef uintptr
-	if cbRefPtr, ok := GetCallback(DataTestVarPtr); ok {
+	if DataTestVar != nil {
-		DataTestVarRef = cbRefPtr
+		DataTestVarPtr := uintptr(unsafe.Pointer(DataTestVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(DataTestVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) {
+			DataTestVarRef = cbRefPtr
-			cbFn := *DataTestVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) {
+				cbFn := *DataTestVar
+				cbFn(arg0, arg1)
+			}
+			DataTestVarRef = purego.NewCallback(fcb)
+			SaveCallback(DataTestVarPtr, DataTestVarRef)
 		}
-		DataTestVarRef = purego.NewCallback(fcb)
-		SaveCallback(DataTestVarPtr, DataTestVarRef)
 	}
-	DataTeardownVarPtr := uintptr(unsafe.Pointer(DataTeardownVar))
 	var DataTeardownVarRef uintptr
-	if cbRefPtr, ok := GetCallback(DataTeardownVarPtr); ok {
+	if DataTeardownVar != nil {
-		DataTeardownVarRef = cbRefPtr
+		DataTeardownVarPtr := uintptr(unsafe.Pointer(DataTeardownVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(DataTeardownVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) {
+			DataTeardownVarRef = cbRefPtr
-			cbFn := *DataTeardownVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) {
+				cbFn := *DataTeardownVar
+				cbFn(arg0, arg1)
+			}
+			DataTeardownVarRef = purego.NewCallback(fcb)
+			SaveCallback(DataTeardownVarPtr, DataTeardownVarRef)
 		}
-		DataTeardownVarRef = purego.NewCallback(fcb)
-		SaveCallback(DataTeardownVarPtr, DataTeardownVarRef)
 	}
 	cret := xTestCreateCase(TestNameVar, DataSizeVar, TestDataVar, DataSetupVarRef, DataTestVarRef, DataTeardownVarRef)
 // [Using Structured Logging](logging.html#using-structured-logging).
 func TestLogSetFatalHandler(LogFuncVar *TestLogFatalFunc, UserDataVar uintptr) {
-	LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
 	var LogFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(LogFuncVarPtr); ok {
+	if LogFuncVar != nil {
-		LogFuncVarRef = cbRefPtr
+		LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(LogFuncVarPtr); ok {
-		fcb := func(arg0 string, arg1 LogLevelFlags, arg2 string, arg3 uintptr) bool {
+			LogFuncVarRef = cbRefPtr
-			cbFn := *LogFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2, arg3)
+			fcb := func(arg0 string, arg1 LogLevelFlags, arg2 string, arg3 uintptr) bool {
+				cbFn := *LogFuncVar
+				return cbFn(arg0, arg1, arg2, arg3)
+			}
+			LogFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(LogFuncVarPtr, LogFuncVarRef)
 		}
-		LogFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(LogFuncVarPtr, LogFuncVarRef)
 	}
 	xTestLogSetFatalHandler(LogFuncVarRef, UserDataVar)
 // before `A()` during teardown.
 func TestQueueDestroy(DestroyFuncVar *DestroyNotify, DestroyDataVar uintptr) {
-	DestroyFuncVarPtr := uintptr(unsafe.Pointer(DestroyFuncVar))
 	var DestroyFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(DestroyFuncVarPtr); ok {
+	if DestroyFuncVar != nil {
-		DestroyFuncVarRef = cbRefPtr
+		DestroyFuncVarPtr := uintptr(unsafe.Pointer(DestroyFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(DestroyFuncVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyFuncVarRef = cbRefPtr
-			cbFn := *DestroyFuncVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyFuncVar
+				cbFn(arg0)
+			}
+			DestroyFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(DestroyFuncVarPtr, DestroyFuncVarRef)
 		}
-		DestroyFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(DestroyFuncVarPtr, DestroyFuncVarRef)
 	}
 	xTestQueueDestroy(DestroyFuncVarRef, DestroyDataVar)

M v4/glib/gthread.go +88 -72

 func (x *Once) Impl(FuncVar *ThreadFunc, ArgVar uintptr) uintptr {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr) uintptr {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0)
+			fcb := func(arg0 uintptr) uintptr {
+				cbFn := *FuncVar
+				return cbFn(arg0)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	cret := xOnceImpl(x.GoPointer(), FuncVarRef, ArgVar)
 // @notify is used quite differently from @destructor in g_private_new().
 func (x *StaticPrivate) Set(DataVar uintptr, NotifyVar *DestroyNotify) {
-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
 	var NotifyVarRef uintptr
-	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
+	if NotifyVar != nil {
-		NotifyVarRef = cbRefPtr
+		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			NotifyVarRef = cbRefPtr
-			cbFn := *NotifyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *NotifyVar
+				cbFn(arg0)
+			}
+			NotifyVarRef = purego.NewCallback(fcb)
+			SaveCallback(NotifyVarPtr, NotifyVarRef)
 		}
-		NotifyVarRef = purego.NewCallback(fcb)
-		SaveCallback(NotifyVarPtr, NotifyVarRef)
 	}
 	xStaticPrivateSet(x.GoPointer(), DataVar, NotifyVarRef)
 // POSIX and all threads inherit their parent thread's priority.
 func NewThread(NameVar string, FuncVar *ThreadFunc, DataVar uintptr) *Thread {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr) uintptr {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0)
+			fcb := func(arg0 uintptr) uintptr {
+				cbFn := *FuncVar
+				return cbFn(arg0)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	cret := xNewThread(NameVar, FuncVarRef, DataVar)
 func ThreadTryNew(NameVar string, FuncVar *ThreadFunc, DataVar uintptr) (*Thread, error) {
 	var cerr *Error
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr) uintptr {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0)
+			fcb := func(arg0 uintptr) uintptr {
+				cbFn := *FuncVar
+				return cbFn(arg0)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	cret := xThreadTryNew(NameVar, FuncVarRef, DataVar, &cerr)
 // Creates a new #GPrivate.
 func PrivateNew(NotifyVar *DestroyNotify) *Private {
-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
 	var NotifyVarRef uintptr
-	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
+	if NotifyVar != nil {
-		NotifyVarRef = cbRefPtr
+		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			NotifyVarRef = cbRefPtr
-			cbFn := *NotifyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *NotifyVar
+				cbFn(arg0)
+			}
+			NotifyVarRef = purego.NewCallback(fcb)
+			SaveCallback(NotifyVarPtr, NotifyVarRef)
 		}
-		NotifyVarRef = purego.NewCallback(fcb)
-		SaveCallback(NotifyVarPtr, NotifyVarRef)
 	}
 	cret := xPrivateNew(NotifyVarRef)
 func ThreadCreate(FuncVar *ThreadFunc, DataVar uintptr, JoinableVar bool) (*Thread, error) {
 	var cerr *Error
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr) uintptr {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0)
+			fcb := func(arg0 uintptr) uintptr {
+				cbFn := *FuncVar
+				return cbFn(arg0)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	cret := xThreadCreate(FuncVarRef, DataVar, JoinableVar, &cerr)
 func ThreadCreateFull(FuncVar *ThreadFunc, DataVar uintptr, StackSizeVar uint32, JoinableVar bool, BoundVar bool, PriorityVar ThreadPriority) (*Thread, error) {
 	var cerr *Error
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr) uintptr {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0)
+			fcb := func(arg0 uintptr) uintptr {
+				cbFn := *FuncVar
+				return cbFn(arg0)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	cret := xThreadCreateFull(FuncVarRef, DataVar, StackSizeVar, JoinableVar, BoundVar, PriorityVar, &cerr)
 // which is quadratic in the number of existing threads.
 func ThreadForeach(ThreadFuncVar *Func, UserDataVar uintptr) {
-	ThreadFuncVarPtr := uintptr(unsafe.Pointer(ThreadFuncVar))
 	var ThreadFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(ThreadFuncVarPtr); ok {
+	if ThreadFuncVar != nil {
-		ThreadFuncVarRef = cbRefPtr
+		ThreadFuncVarPtr := uintptr(unsafe.Pointer(ThreadFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(ThreadFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) {
+			ThreadFuncVarRef = cbRefPtr
-			cbFn := *ThreadFuncVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) {
+				cbFn := *ThreadFuncVar
+				cbFn(arg0, arg1)
+			}
+			ThreadFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(ThreadFuncVarPtr, ThreadFuncVarRef)
 		}
-		ThreadFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(ThreadFuncVarPtr, ThreadFuncVarRef)
 	}
 	xThreadForeach(ThreadFuncVarRef, UserDataVar)

M v4/glib/gthreadpool.go +11 -9

 // created.
 func (x *ThreadPool) SetSortFunction(FuncVar *CompareDataFunc, UserDataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xThreadPoolSetSortFunction(x.GoPointer(), FuncVarRef, UserDataVar)

M v4/glib/gtree.go +110 -90

 // Creates a new #GTree.
 func NewTree(KeyCompareFuncVar *CompareFunc) *Tree {
-	KeyCompareFuncVarPtr := uintptr(unsafe.Pointer(KeyCompareFuncVar))
 	var KeyCompareFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(KeyCompareFuncVarPtr); ok {
+	if KeyCompareFuncVar != nil {
-		KeyCompareFuncVarRef = cbRefPtr
+		KeyCompareFuncVarPtr := uintptr(unsafe.Pointer(KeyCompareFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(KeyCompareFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) int {
+			KeyCompareFuncVarRef = cbRefPtr
-			cbFn := *KeyCompareFuncVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) int {
+				cbFn := *KeyCompareFuncVar
+				return cbFn(arg0, arg1)
+			}
+			KeyCompareFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(KeyCompareFuncVarPtr, KeyCompareFuncVarRef)
 		}
-		KeyCompareFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(KeyCompareFuncVarPtr, KeyCompareFuncVarRef)
 	}
 	cret := xNewTree(KeyCompareFuncVarRef)
 // removing the entry from the #GTree.
 func NewTreeFull(KeyCompareFuncVar *CompareDataFunc, KeyCompareDataVar uintptr, KeyDestroyFuncVar *DestroyNotify, ValueDestroyFuncVar *DestroyNotify) *Tree {
-	KeyCompareFuncVarPtr := uintptr(unsafe.Pointer(KeyCompareFuncVar))
 	var KeyCompareFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(KeyCompareFuncVarPtr); ok {
+	if KeyCompareFuncVar != nil {
-		KeyCompareFuncVarRef = cbRefPtr
+		KeyCompareFuncVarPtr := uintptr(unsafe.Pointer(KeyCompareFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(KeyCompareFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+			KeyCompareFuncVarRef = cbRefPtr
-			cbFn := *KeyCompareFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+				cbFn := *KeyCompareFuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			KeyCompareFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(KeyCompareFuncVarPtr, KeyCompareFuncVarRef)
 		}
-		KeyCompareFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(KeyCompareFuncVarPtr, KeyCompareFuncVarRef)
 	}
-	KeyDestroyFuncVarPtr := uintptr(unsafe.Pointer(KeyDestroyFuncVar))
 	var KeyDestroyFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(KeyDestroyFuncVarPtr); ok {
+	if KeyDestroyFuncVar != nil {
-		KeyDestroyFuncVarRef = cbRefPtr
+		KeyDestroyFuncVarPtr := uintptr(unsafe.Pointer(KeyDestroyFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(KeyDestroyFuncVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			KeyDestroyFuncVarRef = cbRefPtr
-			cbFn := *KeyDestroyFuncVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *KeyDestroyFuncVar
+				cbFn(arg0)
+			}
+			KeyDestroyFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(KeyDestroyFuncVarPtr, KeyDestroyFuncVarRef)
 		}
-		KeyDestroyFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(KeyDestroyFuncVarPtr, KeyDestroyFuncVarRef)
 	}
-	ValueDestroyFuncVarPtr := uintptr(unsafe.Pointer(ValueDestroyFuncVar))
 	var ValueDestroyFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(ValueDestroyFuncVarPtr); ok {
+	if ValueDestroyFuncVar != nil {
-		ValueDestroyFuncVarRef = cbRefPtr
+		ValueDestroyFuncVarPtr := uintptr(unsafe.Pointer(ValueDestroyFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(ValueDestroyFuncVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			ValueDestroyFuncVarRef = cbRefPtr
-			cbFn := *ValueDestroyFuncVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *ValueDestroyFuncVar
+				cbFn(arg0)
+			}
+			ValueDestroyFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(ValueDestroyFuncVarPtr, ValueDestroyFuncVarRef)
 		}
-		ValueDestroyFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(ValueDestroyFuncVarPtr, ValueDestroyFuncVarRef)
 	}
 	cret := xNewTreeFull(KeyCompareFuncVarRef, KeyCompareDataVar, KeyDestroyFuncVarRef, ValueDestroyFuncVarRef)
 // See g_tree_new() for more details.
 func NewTreeWithData(KeyCompareFuncVar *CompareDataFunc, KeyCompareDataVar uintptr) *Tree {
-	KeyCompareFuncVarPtr := uintptr(unsafe.Pointer(KeyCompareFuncVar))
 	var KeyCompareFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(KeyCompareFuncVarPtr); ok {
+	if KeyCompareFuncVar != nil {
-		KeyCompareFuncVarRef = cbRefPtr
+		KeyCompareFuncVarPtr := uintptr(unsafe.Pointer(KeyCompareFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(KeyCompareFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+			KeyCompareFuncVarRef = cbRefPtr
-			cbFn := *KeyCompareFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+				cbFn := *KeyCompareFuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			KeyCompareFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(KeyCompareFuncVarPtr, KeyCompareFuncVarRef)
 		}
-		KeyCompareFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(KeyCompareFuncVarPtr, KeyCompareFuncVarRef)
 	}
 	cret := xNewTreeWithData(KeyCompareFuncVarRef, KeyCompareDataVar)
 // the tree, then walk the list and remove each item.
 func (x *Tree) Foreach(FuncVar *TraverseFunc, UserDataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xTreeForeach(x.GoPointer(), FuncVarRef, UserDataVar)
 // the tree, then walk the list and remove each item.
 func (x *Tree) ForeachNode(FuncVar *TraverseNodeFunc, UserDataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 *TreeNode, arg1 uintptr) bool {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 *TreeNode, arg1 uintptr) bool {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xTreeForeachNode(x.GoPointer(), FuncVarRef, UserDataVar)
 // pairs that have a larger key.
 func (x *Tree) Search(SearchFuncVar *CompareFunc, UserDataVar uintptr) uintptr {
-	SearchFuncVarPtr := uintptr(unsafe.Pointer(SearchFuncVar))
 	var SearchFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(SearchFuncVarPtr); ok {
+	if SearchFuncVar != nil {
-		SearchFuncVarRef = cbRefPtr
+		SearchFuncVarPtr := uintptr(unsafe.Pointer(SearchFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(SearchFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) int {
+			SearchFuncVarRef = cbRefPtr
-			cbFn := *SearchFuncVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) int {
+				cbFn := *SearchFuncVar
+				return cbFn(arg0, arg1)
+			}
+			SearchFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(SearchFuncVarPtr, SearchFuncVarRef)
 		}
-		SearchFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(SearchFuncVarPtr, SearchFuncVarRef)
 	}
 	cret := xTreeSearch(x.GoPointer(), SearchFuncVarRef, UserDataVar)
 // pairs that have a larger key.
 func (x *Tree) SearchNode(SearchFuncVar *CompareFunc, UserDataVar uintptr) *TreeNode {
-	SearchFuncVarPtr := uintptr(unsafe.Pointer(SearchFuncVar))
 	var SearchFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(SearchFuncVarPtr); ok {
+	if SearchFuncVar != nil {
-		SearchFuncVarRef = cbRefPtr
+		SearchFuncVarPtr := uintptr(unsafe.Pointer(SearchFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(SearchFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) int {
+			SearchFuncVarRef = cbRefPtr
-			cbFn := *SearchFuncVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) int {
+				cbFn := *SearchFuncVar
+				return cbFn(arg0, arg1)
+			}
+			SearchFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(SearchFuncVarPtr, SearchFuncVarRef)
 		}
-		SearchFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(SearchFuncVarPtr, SearchFuncVarRef)
 	}
 	cret := xTreeSearchNode(x.GoPointer(), SearchFuncVarRef, UserDataVar)
 // Calls the given function for each node in the #GTree.
 func (x *Tree) Traverse(TraverseFuncVar *TraverseFunc, TraverseTypeVar TraverseType, UserDataVar uintptr) {
-	TraverseFuncVarPtr := uintptr(unsafe.Pointer(TraverseFuncVar))
 	var TraverseFuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(TraverseFuncVarPtr); ok {
+	if TraverseFuncVar != nil {
-		TraverseFuncVarRef = cbRefPtr
+		TraverseFuncVarPtr := uintptr(unsafe.Pointer(TraverseFuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(TraverseFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
+			TraverseFuncVarRef = cbRefPtr
-			cbFn := *TraverseFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
+				cbFn := *TraverseFuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			TraverseFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(TraverseFuncVarPtr, TraverseFuncVarRef)
 		}
-		TraverseFuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(TraverseFuncVarPtr, TraverseFuncVarRef)
 	}
 	xTreeTraverse(x.GoPointer(), TraverseFuncVarRef, TraverseTypeVar, UserDataVar)

M v4/glib/gutils.go +11 -9

 // program.
 func Atexit(FuncVar *VoidFunc) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
-		fcb := func() {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			cbFn()
+			fcb := func() {
+				cbFn := *FuncVar
+				cbFn()
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xAtexit(FuncVarRef)

M v4/glib/gvariant.go +11 -9

 // process.
 func NewVariantFromData(TypeVar *VariantType, DataVar []byte, SizeVar uint, TrustedVar bool, NotifyVar *DestroyNotify, UserDataVar uintptr) *Variant {
-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
 	var NotifyVarRef uintptr
-	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
+	if NotifyVar != nil {
-		NotifyVarRef = cbRefPtr
+		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
-	} else {
+		if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			NotifyVarRef = cbRefPtr
-			cbFn := *NotifyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *NotifyVar
+				cbFn(arg0)
+			}
+			NotifyVarRef = purego.NewCallback(fcb)
+			SaveCallback(NotifyVarPtr, NotifyVarRef)
 		}
-		NotifyVarRef = purego.NewCallback(fcb)
-		SaveCallback(NotifyVarPtr, NotifyVarRef)
 	}
 	cret := xNewVariantFromData(TypeVar, DataVar, SizeVar, TrustedVar, NotifyVarRef, UserDataVar)

M v4/gobject/gbindinggroup.go +11 -9

 		}
 	}
-	UserDataDestroyVarPtr := uintptr(unsafe.Pointer(UserDataDestroyVar))
 	var UserDataDestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(UserDataDestroyVarPtr); ok {
+	if UserDataDestroyVar != nil {
-		UserDataDestroyVarRef = cbRefPtr
+		UserDataDestroyVarPtr := uintptr(unsafe.Pointer(UserDataDestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(UserDataDestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			UserDataDestroyVarRef = cbRefPtr
-			cbFn := *UserDataDestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *UserDataDestroyVar
+				cbFn(arg0)
+			}
+			UserDataDestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(UserDataDestroyVarPtr, UserDataDestroyVarRef)
 		}
-		UserDataDestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(UserDataDestroyVarPtr, UserDataDestroyVarRef)
 	}
 	xBindingGroupBindFull(x.GoPointer(), SourcePropertyVar, TargetVar.GoPointer(), TargetPropertyVar, FlagsVar, TransformToVarRef, TransformFromVarRef, UserDataVar, UserDataDestroyVarRef)

M v4/gobject/gboxed.go +22 -18

 // will create the appropriate `*_get_type()` function for the boxed type.
 func BoxedTypeRegisterStatic(NameVar string, BoxedCopyVar *BoxedCopyFunc, BoxedFreeVar *BoxedFreeFunc) types.GType {
-	BoxedCopyVarPtr := uintptr(unsafe.Pointer(BoxedCopyVar))
 	var BoxedCopyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(BoxedCopyVarPtr); ok {
+	if BoxedCopyVar != nil {
-		BoxedCopyVarRef = cbRefPtr
+		BoxedCopyVarPtr := uintptr(unsafe.Pointer(BoxedCopyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(BoxedCopyVarPtr); ok {
-		fcb := func(arg0 uintptr) uintptr {
+			BoxedCopyVarRef = cbRefPtr
-			cbFn := *BoxedCopyVar
+		} else {
-			return cbFn(arg0)
+			fcb := func(arg0 uintptr) uintptr {
+				cbFn := *BoxedCopyVar
+				return cbFn(arg0)
+			}
+			BoxedCopyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(BoxedCopyVarPtr, BoxedCopyVarRef)
 		}
-		BoxedCopyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(BoxedCopyVarPtr, BoxedCopyVarRef)
 	}
-	BoxedFreeVarPtr := uintptr(unsafe.Pointer(BoxedFreeVar))
 	var BoxedFreeVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(BoxedFreeVarPtr); ok {
+	if BoxedFreeVar != nil {
-		BoxedFreeVarRef = cbRefPtr
+		BoxedFreeVarPtr := uintptr(unsafe.Pointer(BoxedFreeVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(BoxedFreeVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			BoxedFreeVarRef = cbRefPtr
-			cbFn := *BoxedFreeVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *BoxedFreeVar
+				cbFn(arg0)
+			}
+			BoxedFreeVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(BoxedFreeVarPtr, BoxedFreeVarRef)
 		}
-		BoxedFreeVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(BoxedFreeVarPtr, BoxedFreeVarRef)
 	}
 	cret := xBoxedTypeRegisterStatic(NameVar, BoxedCopyVarRef, BoxedFreeVarRef)

M v4/gobject/gclosure.go +132 -108

 // notifiers will be run before the finalize notifiers.
 func (x *Closure) AddFinalizeNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify) {
-	NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
 	var NotifyFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(NotifyFuncVarPtr); ok {
+	if NotifyFuncVar != nil {
-		NotifyFuncVarRef = cbRefPtr
+		NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(NotifyFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 *Closure) {
+			NotifyFuncVarRef = cbRefPtr
-			cbFn := *NotifyFuncVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 *Closure) {
+				cbFn := *NotifyFuncVar
+				cbFn(arg0, arg1)
+			}
+			NotifyFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
 		}
-		NotifyFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
 	}
 	xClosureAddFinalizeNotifier(x.GoPointer(), NotifyDataVar, NotifyFuncVarRef)
 // in an unspecified order.
 func (x *Closure) AddInvalidateNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify) {
-	NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
 	var NotifyFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(NotifyFuncVarPtr); ok {
+	if NotifyFuncVar != nil {
-		NotifyFuncVarRef = cbRefPtr
+		NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(NotifyFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 *Closure) {
+			NotifyFuncVarRef = cbRefPtr
-			cbFn := *NotifyFuncVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 *Closure) {
+				cbFn := *NotifyFuncVar
+				cbFn(arg0, arg1)
+			}
+			NotifyFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
 		}
-		NotifyFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
 	}
 	xClosureAddInvalidateNotifier(x.GoPointer(), NotifyDataVar, NotifyFuncVarRef)
 // example of marshal guards.
 func (x *Closure) AddMarshalGuards(PreMarshalDataVar uintptr, PreMarshalNotifyVar *ClosureNotify, PostMarshalDataVar uintptr, PostMarshalNotifyVar *ClosureNotify) {
-	PreMarshalNotifyVarPtr := uintptr(unsafe.Pointer(PreMarshalNotifyVar))
 	var PreMarshalNotifyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(PreMarshalNotifyVarPtr); ok {
+	if PreMarshalNotifyVar != nil {
-		PreMarshalNotifyVarRef = cbRefPtr
+		PreMarshalNotifyVarPtr := uintptr(unsafe.Pointer(PreMarshalNotifyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(PreMarshalNotifyVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 *Closure) {
+			PreMarshalNotifyVarRef = cbRefPtr
-			cbFn := *PreMarshalNotifyVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 *Closure) {
+				cbFn := *PreMarshalNotifyVar
+				cbFn(arg0, arg1)
+			}
+			PreMarshalNotifyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(PreMarshalNotifyVarPtr, PreMarshalNotifyVarRef)
 		}
-		PreMarshalNotifyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(PreMarshalNotifyVarPtr, PreMarshalNotifyVarRef)
 	}
-	PostMarshalNotifyVarPtr := uintptr(unsafe.Pointer(PostMarshalNotifyVar))
 	var PostMarshalNotifyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(PostMarshalNotifyVarPtr); ok {
+	if PostMarshalNotifyVar != nil {
-		PostMarshalNotifyVarRef = cbRefPtr
+		PostMarshalNotifyVarPtr := uintptr(unsafe.Pointer(PostMarshalNotifyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(PostMarshalNotifyVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 *Closure) {
+			PostMarshalNotifyVarRef = cbRefPtr
-			cbFn := *PostMarshalNotifyVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 *Closure) {
+				cbFn := *PostMarshalNotifyVar
+				cbFn(arg0, arg1)
+			}
+			PostMarshalNotifyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(PostMarshalNotifyVarPtr, PostMarshalNotifyVarRef)
 		}
-		PostMarshalNotifyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(PostMarshalNotifyVarPtr, PostMarshalNotifyVarRef)
 	}
 	xClosureAddMarshalGuards(x.GoPointer(), PreMarshalDataVar, PreMarshalNotifyVarRef, PostMarshalDataVar, PostMarshalNotifyVarRef)
 // Notice that notifiers are automatically removed after they are run.
 func (x *Closure) RemoveFinalizeNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify) {
-	NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
 	var NotifyFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(NotifyFuncVarPtr); ok {
+	if NotifyFuncVar != nil {
-		NotifyFuncVarRef = cbRefPtr
+		NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(NotifyFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 *Closure) {
+			NotifyFuncVarRef = cbRefPtr
-			cbFn := *NotifyFuncVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 *Closure) {
+				cbFn := *NotifyFuncVar
+				cbFn(arg0, arg1)
+			}
+			NotifyFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
 		}
-		NotifyFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
 	}
 	xClosureRemoveFinalizeNotifier(x.GoPointer(), NotifyDataVar, NotifyFuncVarRef)
 // Notice that notifiers are automatically removed after they are run.
 func (x *Closure) RemoveInvalidateNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify) {
-	NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
 	var NotifyFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(NotifyFuncVarPtr); ok {
+	if NotifyFuncVar != nil {
-		NotifyFuncVarRef = cbRefPtr
+		NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(NotifyFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 *Closure) {
+			NotifyFuncVarRef = cbRefPtr
-			cbFn := *NotifyFuncVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 *Closure) {
+				cbFn := *NotifyFuncVar
+				cbFn(arg0, arg1)
+			}
+			NotifyFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
 		}
-		NotifyFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
 	}
 	xClosureRemoveInvalidateNotifier(x.GoPointer(), NotifyDataVar, NotifyFuncVarRef)
 // See also: g_closure_set_meta_marshal()
 func (x *Closure) SetMarshal(MarshalVar *ClosureMarshal) {
-	MarshalVarPtr := uintptr(unsafe.Pointer(MarshalVar))
 	var MarshalVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(MarshalVarPtr); ok {
+	if MarshalVar != nil {
-		MarshalVarRef = cbRefPtr
+		MarshalVarPtr := uintptr(unsafe.Pointer(MarshalVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(MarshalVarPtr); ok {
-		fcb := func(arg0 *Closure, arg1 *Value, arg2 uint, arg3 []Value, arg4 uintptr, arg5 uintptr) {
+			MarshalVarRef = cbRefPtr
-			cbFn := *MarshalVar
+		} else {
-			cbFn(arg0, arg1, arg2, arg3, arg4, arg5)
+			fcb := func(arg0 *Closure, arg1 *Value, arg2 uint, arg3 []Value, arg4 uintptr, arg5 uintptr) {
+				cbFn := *MarshalVar
+				cbFn(arg0, arg1, arg2, arg3, arg4, arg5)
+			}
+			MarshalVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(MarshalVarPtr, MarshalVarRef)
 		}
-		MarshalVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(MarshalVarPtr, MarshalVarRef)
 	}
 	xClosureSetMarshal(x.GoPointer(), MarshalVarRef)
 // @marshal_data argument.
 func (x *Closure) SetMetaMarshal(MarshalDataVar uintptr, MetaMarshalVar *ClosureMarshal) {
-	MetaMarshalVarPtr := uintptr(unsafe.Pointer(MetaMarshalVar))
 	var MetaMarshalVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(MetaMarshalVarPtr); ok {
+	if MetaMarshalVar != nil {
-		MetaMarshalVarRef = cbRefPtr
+		MetaMarshalVarPtr := uintptr(unsafe.Pointer(MetaMarshalVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(MetaMarshalVarPtr); ok {
-		fcb := func(arg0 *Closure, arg1 *Value, arg2 uint, arg3 []Value, arg4 uintptr, arg5 uintptr) {
+			MetaMarshalVarRef = cbRefPtr
-			cbFn := *MetaMarshalVar
+		} else {
-			cbFn(arg0, arg1, arg2, arg3, arg4, arg5)
+			fcb := func(arg0 *Closure, arg1 *Value, arg2 uint, arg3 []Value, arg4 uintptr, arg5 uintptr) {
+				cbFn := *MetaMarshalVar
+				cbFn(arg0, arg1, arg2, arg3, arg4, arg5)
+			}
+			MetaMarshalVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(MetaMarshalVarPtr, MetaMarshalVarRef)
 		}
-		MetaMarshalVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(MetaMarshalVarPtr, MetaMarshalVarRef)
 	}
 	xClosureSetMetaMarshal(x.GoPointer(), MarshalDataVar, MetaMarshalVarRef)
 // @destroy_data will be called as a finalize notifier on the #GClosure.
 func CclosureNew(CallbackFuncVar *Callback, UserDataVar uintptr, DestroyDataVar *ClosureNotify) *Closure {
-	CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
 	var CallbackFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
+	if CallbackFuncVar != nil {
-		CallbackFuncVarRef = cbRefPtr
+		CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
-		fcb := func() {
+			CallbackFuncVarRef = cbRefPtr
-			cbFn := *CallbackFuncVar
+		} else {
-			cbFn()
+			fcb := func() {
+				cbFn := *CallbackFuncVar
+				cbFn()
+			}
+			CallbackFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
 		}
-		CallbackFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
 	}
-	DestroyDataVarPtr := uintptr(unsafe.Pointer(DestroyDataVar))
 	var DestroyDataVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DestroyDataVarPtr); ok {
+	if DestroyDataVar != nil {
-		DestroyDataVarRef = cbRefPtr
+		DestroyDataVarPtr := uintptr(unsafe.Pointer(DestroyDataVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DestroyDataVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 *Closure) {
+			DestroyDataVarRef = cbRefPtr
-			cbFn := *DestroyDataVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 *Closure) {
+				cbFn := *DestroyDataVar
+				cbFn(arg0, arg1)
+			}
+			DestroyDataVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyDataVarPtr, DestroyDataVarRef)
 		}
-		DestroyDataVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DestroyDataVarPtr, DestroyDataVarRef)
 	}
 	cret := xCclosureNew(CallbackFuncVarRef, UserDataVar, DestroyDataVarRef)
 // @destroy_data will be called as a finalize notifier on the #GClosure.
 func CclosureNewSwap(CallbackFuncVar *Callback, UserDataVar uintptr, DestroyDataVar *ClosureNotify) *Closure {
-	CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
 	var CallbackFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
+	if CallbackFuncVar != nil {
-		CallbackFuncVarRef = cbRefPtr
+		CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
-		fcb := func() {
+			CallbackFuncVarRef = cbRefPtr
-			cbFn := *CallbackFuncVar
+		} else {
-			cbFn()
+			fcb := func() {
+				cbFn := *CallbackFuncVar
+				cbFn()
+			}
+			CallbackFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
 		}
-		CallbackFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
 	}
-	DestroyDataVarPtr := uintptr(unsafe.Pointer(DestroyDataVar))
 	var DestroyDataVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DestroyDataVarPtr); ok {
+	if DestroyDataVar != nil {
-		DestroyDataVarRef = cbRefPtr
+		DestroyDataVarPtr := uintptr(unsafe.Pointer(DestroyDataVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DestroyDataVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 *Closure) {
+			DestroyDataVarRef = cbRefPtr
-			cbFn := *DestroyDataVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 *Closure) {
+				cbFn := *DestroyDataVar
+				cbFn(arg0, arg1)
+			}
+			DestroyDataVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyDataVarPtr, DestroyDataVarRef)
 		}
-		DestroyDataVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DestroyDataVarPtr, DestroyDataVarRef)
 	}
 	cret := xCclosureNewSwap(CallbackFuncVarRef, UserDataVar, DestroyDataVarRef)

M v4/gobject/gobject.go +77 -63

 // after the object is is freed.
 func CclosureNewObject(CallbackFuncVar *Callback, ObjectVar *Object) *Closure {
-	CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
 	var CallbackFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
+	if CallbackFuncVar != nil {
-		CallbackFuncVarRef = cbRefPtr
+		CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
-		fcb := func() {
+			CallbackFuncVarRef = cbRefPtr
-			cbFn := *CallbackFuncVar
+		} else {
-			cbFn()
+			fcb := func() {
+				cbFn := *CallbackFuncVar
+				cbFn()
+			}
+			CallbackFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
 		}
-		CallbackFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
 	}
 	cret := xCclosureNewObject(CallbackFuncVarRef, ObjectVar.GoPointer())
 // after the object is is freed.
 func CclosureNewObjectSwap(CallbackFuncVar *Callback, ObjectVar *Object) *Closure {
-	CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
 	var CallbackFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
+	if CallbackFuncVar != nil {
-		CallbackFuncVarRef = cbRefPtr
+		CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
-		fcb := func() {
+			CallbackFuncVarRef = cbRefPtr
-			cbFn := *CallbackFuncVar
+		} else {
-			cbFn()
+			fcb := func() {
+				cbFn := *CallbackFuncVar
+				cbFn()
+			}
+			CallbackFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
 		}
-		CallbackFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
 	}
 	cret := xCclosureNewObjectSwap(CallbackFuncVarRef, ObjectVar.GoPointer())
 // details.
 func SignalConnectObject(InstanceVar *TypeInstance, DetailedSignalVar string, CHandlerVar *Callback, GobjectVar *Object, ConnectFlagsVar ConnectFlags) uint32 {
-	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
 	var CHandlerVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
+	if CHandlerVar != nil {
-		CHandlerVarRef = cbRefPtr
+		CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
-		fcb := func() {
+			CHandlerVarRef = cbRefPtr
-			cbFn := *CHandlerVar
+		} else {
-			cbFn()
+			fcb := func() {
+				cbFn := *CHandlerVar
+				cbFn()
+			}
+			CHandlerVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
 		}
-		CHandlerVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
 	}
 	cret := xSignalConnectObject(InstanceVar, DetailedSignalVar, CHandlerVarRef, GobjectVar.GoPointer(), ConnectFlagsVar)
 // A g_object_add_toggle_ref() must be released with g_object_remove_toggle_ref().
 func (x *Object) AddToggleRef(NotifyVar *ToggleNotify, DataVar uintptr) {
-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
 	var NotifyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
+	if NotifyVar != nil {
-		NotifyVarRef = cbRefPtr
+		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 bool) {
+			NotifyVarRef = cbRefPtr
-			cbFn := *NotifyVar
+		} else {
-			cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 bool) {
+				cbFn := *NotifyVar
+				cbFn(arg0, arg1, arg2)
+			}
+			NotifyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 		}
-		NotifyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 	}
 	xObjectAddToggleRef(x.GoPointer(), NotifyVarRef, DataVar)
 // you must take care of that yourself.
 func (x *Object) RemoveToggleRef(NotifyVar *ToggleNotify, DataVar uintptr) {
-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
 	var NotifyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
+	if NotifyVar != nil {
-		NotifyVarRef = cbRefPtr
+		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 bool) {
+			NotifyVarRef = cbRefPtr
-			cbFn := *NotifyVar
+		} else {
-			cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 bool) {
+				cbFn := *NotifyVar
+				cbFn(arg0, arg1, arg2)
+			}
+			NotifyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 		}
-		NotifyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 	}
 	xObjectRemoveToggleRef(x.GoPointer(), NotifyVarRef, DataVar)
 // Use #GWeakRef if thread-safety is required.
 func (x *Object) WeakRef(NotifyVar *WeakNotify, DataVar uintptr) {
-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
 	var NotifyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
+	if NotifyVar != nil {
-		NotifyVarRef = cbRefPtr
+		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) {
+			NotifyVarRef = cbRefPtr
-			cbFn := *NotifyVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) {
+				cbFn := *NotifyVar
+				cbFn(arg0, arg1)
+			}
+			NotifyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 		}
-		NotifyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 	}
 	xObjectWeakRef(x.GoPointer(), NotifyVarRef, DataVar)
 // Removes a weak reference callback to an object.
 func (x *Object) WeakUnref(NotifyVar *WeakNotify, DataVar uintptr) {
-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
 	var NotifyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
+	if NotifyVar != nil {
-		NotifyVarRef = cbRefPtr
+		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) {
+			NotifyVarRef = cbRefPtr
-			cbFn := *NotifyVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) {
+				cbFn := *NotifyVar
+				cbFn(arg0, arg1)
+			}
+			NotifyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 		}
-		NotifyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 	}
 	xObjectWeakUnref(x.GoPointer(), NotifyVarRef, DataVar)

M v4/gobject/gsignal.go +33 -27

 // for signals which don't have %G_SIGNAL_NO_HOOKS flag set.
 func SignalAddEmissionHook(SignalIdVar uint, DetailVar glib.Quark, HookFuncVar *SignalEmissionHook, HookDataVar uintptr, DataDestroyVar *glib.DestroyNotify) uint32 {
-	HookFuncVarPtr := uintptr(unsafe.Pointer(HookFuncVar))
 	var HookFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(HookFuncVarPtr); ok {
+	if HookFuncVar != nil {
-		HookFuncVarRef = cbRefPtr
+		HookFuncVarPtr := uintptr(unsafe.Pointer(HookFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(HookFuncVarPtr); ok {
-		fcb := func(arg0 *SignalInvocationHint, arg1 uint, arg2 []Value, arg3 uintptr) bool {
+			HookFuncVarRef = cbRefPtr
-			cbFn := *HookFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2, arg3)
+			fcb := func(arg0 *SignalInvocationHint, arg1 uint, arg2 []Value, arg3 uintptr) bool {
+				cbFn := *HookFuncVar
+				return cbFn(arg0, arg1, arg2, arg3)
+			}
+			HookFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(HookFuncVarPtr, HookFuncVarRef)
 		}
-		HookFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(HookFuncVarPtr, HookFuncVarRef)
 	}
 	var DataDestroyVarRef uintptr
 // details.
 func SignalConnectData(InstanceVar *Object, DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr, DestroyDataVar *ClosureNotify, ConnectFlagsVar ConnectFlags) uint32 {
-	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
 	var CHandlerVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
+	if CHandlerVar != nil {
-		CHandlerVarRef = cbRefPtr
+		CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
-		fcb := func() {
+			CHandlerVarRef = cbRefPtr
-			cbFn := *CHandlerVar
+		} else {
-			cbFn()
+			fcb := func() {
+				cbFn := *CHandlerVar
+				cbFn()
+			}
+			CHandlerVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
 		}
-		CHandlerVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
 	}
 	var DestroyDataVarRef uintptr
 // parent class closure from inside the overridden one.
 func SignalOverrideClassHandler(SignalNameVar string, InstanceTypeVar types.GType, ClassHandlerVar *Callback) {
-	ClassHandlerVarPtr := uintptr(unsafe.Pointer(ClassHandlerVar))
 	var ClassHandlerVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(ClassHandlerVarPtr); ok {
+	if ClassHandlerVar != nil {
-		ClassHandlerVarRef = cbRefPtr
+		ClassHandlerVarPtr := uintptr(unsafe.Pointer(ClassHandlerVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(ClassHandlerVarPtr); ok {
-		fcb := func() {
+			ClassHandlerVarRef = cbRefPtr
-			cbFn := *ClassHandlerVar
+		} else {
-			cbFn()
+			fcb := func() {
+				cbFn := *ClassHandlerVar
+				cbFn()
+			}
+			ClassHandlerVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(ClassHandlerVarPtr, ClassHandlerVarRef)
 		}
-		ClassHandlerVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(ClassHandlerVarPtr, ClassHandlerVarRef)
 	}
 	xSignalOverrideClassHandler(SignalNameVar, InstanceTypeVar, ClassHandlerVarRef)

M v4/gobject/gsignalgroup.go +66 -54

 // You cannot connect a signal handler after #GSignalGroup:target has been set.
 func (x *SignalGroup) Connect(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr) {
-	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
 	var CHandlerVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
+	if CHandlerVar != nil {
-		CHandlerVarRef = cbRefPtr
+		CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
-		fcb := func() {
+			CHandlerVarRef = cbRefPtr
-			cbFn := *CHandlerVar
+		} else {
-			cbFn()
+			fcb := func() {
+				cbFn := *CHandlerVar
+				cbFn()
+			}
+			CHandlerVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
 		}
-		CHandlerVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
 	}
 	xSignalGroupConnect(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar)
 // You cannot connect a signal handler after #GSignalGroup:target has been set.
 func (x *SignalGroup) ConnectAfter(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr) {
-	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
 	var CHandlerVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
+	if CHandlerVar != nil {
-		CHandlerVarRef = cbRefPtr
+		CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
-		fcb := func() {
+			CHandlerVarRef = cbRefPtr
-			cbFn := *CHandlerVar
+		} else {
-			cbFn()
+			fcb := func() {
+				cbFn := *CHandlerVar
+				cbFn()
+			}
+			CHandlerVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
 		}
-		CHandlerVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
 	}
 	xSignalGroupConnectAfter(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar)
 // You cannot connect a signal handler after #GSignalGroup:target has been set.
 func (x *SignalGroup) ConnectData(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr, NotifyVar *ClosureNotify, FlagsVar ConnectFlags) {
-	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
 	var CHandlerVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
+	if CHandlerVar != nil {
-		CHandlerVarRef = cbRefPtr
+		CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
-		fcb := func() {
+			CHandlerVarRef = cbRefPtr
-			cbFn := *CHandlerVar
+		} else {
-			cbFn()
+			fcb := func() {
+				cbFn := *CHandlerVar
+				cbFn()
+			}
+			CHandlerVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
 		}
-		CHandlerVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
 	}
-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
 	var NotifyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
+	if NotifyVar != nil {
-		NotifyVarRef = cbRefPtr
+		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 *Closure) {
+			NotifyVarRef = cbRefPtr
-			cbFn := *NotifyVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 *Closure) {
+				cbFn := *NotifyVar
+				cbFn(arg0, arg1)
+			}
+			NotifyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 		}
-		NotifyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 	}
 	xSignalGroupConnectData(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar, NotifyVarRef, FlagsVar)
 // You cannot connect a signal handler after #GSignalGroup:target has been set.
 func (x *SignalGroup) ConnectObject(DetailedSignalVar string, CHandlerVar *Callback, ObjectVar uintptr, FlagsVar ConnectFlags) {
-	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
 	var CHandlerVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
+	if CHandlerVar != nil {
-		CHandlerVarRef = cbRefPtr
+		CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
-		fcb := func() {
+			CHandlerVarRef = cbRefPtr
-			cbFn := *CHandlerVar
+		} else {
-			cbFn()
+			fcb := func() {
+				cbFn := *CHandlerVar
+				cbFn()
+			}
+			CHandlerVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
 		}
-		CHandlerVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
 	}
 	xSignalGroupConnectObject(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, ObjectVar, FlagsVar)
 // You cannot connect a signal handler after #GSignalGroup:target has been set.
 func (x *SignalGroup) ConnectSwapped(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr) {
-	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
 	var CHandlerVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
+	if CHandlerVar != nil {
-		CHandlerVarRef = cbRefPtr
+		CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
-		fcb := func() {
+			CHandlerVarRef = cbRefPtr
-			cbFn := *CHandlerVar
+		} else {
-			cbFn()
+			fcb := func() {
+				cbFn := *CHandlerVar
+				cbFn()
+			}
+			CHandlerVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
 		}
-		CHandlerVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
 	}
 	xSignalGroupConnectSwapped(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar)

M v4/gobject/gtype.go +66 -54

 // chain.
 func TypeAddClassCacheFunc(CacheDataVar uintptr, CacheFuncVar *TypeClassCacheFunc) {
-	CacheFuncVarPtr := uintptr(unsafe.Pointer(CacheFuncVar))
 	var CacheFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CacheFuncVarPtr); ok {
+	if CacheFuncVar != nil {
-		CacheFuncVarRef = cbRefPtr
+		CacheFuncVarPtr := uintptr(unsafe.Pointer(CacheFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CacheFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 *TypeClass) bool {
+			CacheFuncVarRef = cbRefPtr
-			cbFn := *CacheFuncVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 *TypeClass) bool {
+				cbFn := *CacheFuncVar
+				return cbFn(arg0, arg1)
+			}
+			CacheFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CacheFuncVarPtr, CacheFuncVarRef)
 		}
-		CacheFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CacheFuncVarPtr, CacheFuncVarRef)
 	}
 	xTypeAddClassCacheFunc(CacheDataVar, CacheFuncVarRef)
 // interfaces.
 func TypeAddInterfaceCheck(CheckDataVar uintptr, CheckFuncVar *TypeInterfaceCheckFunc) {
-	CheckFuncVarPtr := uintptr(unsafe.Pointer(CheckFuncVar))
 	var CheckFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CheckFuncVarPtr); ok {
+	if CheckFuncVar != nil {
-		CheckFuncVarRef = cbRefPtr
+		CheckFuncVarPtr := uintptr(unsafe.Pointer(CheckFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CheckFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 *TypeInterface) {
+			CheckFuncVarRef = cbRefPtr
-			cbFn := *CheckFuncVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 *TypeInterface) {
+				cbFn := *CheckFuncVar
+				cbFn(arg0, arg1)
+			}
+			CheckFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CheckFuncVarPtr, CheckFuncVarRef)
 		}
-		CheckFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CheckFuncVarPtr, CheckFuncVarRef)
 	}
 	xTypeAddInterfaceCheck(CheckDataVar, CheckFuncVarRef)
 // struct and calling g_type_register_static().
 func TypeRegisterStaticSimple(ParentTypeVar types.GType, TypeNameVar string, ClassSizeVar uint, ClassInitVar *ClassInitFunc, InstanceSizeVar uint, InstanceInitVar *InstanceInitFunc, FlagsVar TypeFlags) types.GType {
-	ClassInitVarPtr := uintptr(unsafe.Pointer(ClassInitVar))
 	var ClassInitVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(ClassInitVarPtr); ok {
+	if ClassInitVar != nil {
-		ClassInitVarRef = cbRefPtr
+		ClassInitVarPtr := uintptr(unsafe.Pointer(ClassInitVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(ClassInitVarPtr); ok {
-		fcb := func(arg0 *TypeClass, arg1 uintptr) {
+			ClassInitVarRef = cbRefPtr
-			cbFn := *ClassInitVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 *TypeClass, arg1 uintptr) {
+				cbFn := *ClassInitVar
+				cbFn(arg0, arg1)
+			}
+			ClassInitVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(ClassInitVarPtr, ClassInitVarRef)
 		}
-		ClassInitVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(ClassInitVarPtr, ClassInitVarRef)
 	}
-	InstanceInitVarPtr := uintptr(unsafe.Pointer(InstanceInitVar))
 	var InstanceInitVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(InstanceInitVarPtr); ok {
+	if InstanceInitVar != nil {
-		InstanceInitVarRef = cbRefPtr
+		InstanceInitVarPtr := uintptr(unsafe.Pointer(InstanceInitVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(InstanceInitVarPtr); ok {
-		fcb := func(arg0 *TypeInstance, arg1 *TypeClass) {
+			InstanceInitVarRef = cbRefPtr
-			cbFn := *InstanceInitVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 *TypeInstance, arg1 *TypeClass) {
+				cbFn := *InstanceInitVar
+				cbFn(arg0, arg1)
+			}
+			InstanceInitVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(InstanceInitVarPtr, InstanceInitVarRef)
 		}
-		InstanceInitVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(InstanceInitVarPtr, InstanceInitVarRef)
 	}
 	cret := xTypeRegisterStaticSimple(ParentTypeVar, TypeNameVar, ClassSizeVar, ClassInitVarRef, InstanceSizeVar, InstanceInitVarRef, FlagsVar)
 // g_type_remove_class_cache_func() to avoid leaks.
 func TypeRemoveClassCacheFunc(CacheDataVar uintptr, CacheFuncVar *TypeClassCacheFunc) {
-	CacheFuncVarPtr := uintptr(unsafe.Pointer(CacheFuncVar))
 	var CacheFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CacheFuncVarPtr); ok {
+	if CacheFuncVar != nil {
-		CacheFuncVarRef = cbRefPtr
+		CacheFuncVarPtr := uintptr(unsafe.Pointer(CacheFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CacheFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 *TypeClass) bool {
+			CacheFuncVarRef = cbRefPtr
-			cbFn := *CacheFuncVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 *TypeClass) bool {
+				cbFn := *CacheFuncVar
+				return cbFn(arg0, arg1)
+			}
+			CacheFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CacheFuncVarPtr, CacheFuncVarRef)
 		}
-		CacheFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CacheFuncVarPtr, CacheFuncVarRef)
 	}
 	xTypeRemoveClassCacheFunc(CacheDataVar, CacheFuncVarRef)
 // g_type_add_interface_check().
 func TypeRemoveInterfaceCheck(CheckDataVar uintptr, CheckFuncVar *TypeInterfaceCheckFunc) {
-	CheckFuncVarPtr := uintptr(unsafe.Pointer(CheckFuncVar))
 	var CheckFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CheckFuncVarPtr); ok {
+	if CheckFuncVar != nil {
-		CheckFuncVarRef = cbRefPtr
+		CheckFuncVarPtr := uintptr(unsafe.Pointer(CheckFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CheckFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 *TypeInterface) {
+			CheckFuncVarRef = cbRefPtr
-			cbFn := *CheckFuncVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 *TypeInterface) {
+				cbFn := *CheckFuncVar
+				cbFn(arg0, arg1)
+			}
+			CheckFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CheckFuncVarPtr, CheckFuncVarRef)
 		}
-		CheckFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CheckFuncVarPtr, CheckFuncVarRef)
 	}
 	xTypeRemoveInterfaceCheck(CheckDataVar, CheckFuncVarRef)

M v4/gobject/gvalue.go +11 -9

 // @dest_type will be replaced.
 func ValueRegisterTransformFunc(SrcTypeVar types.GType, DestTypeVar types.GType, TransformFuncVar *ValueTransform) {
-	TransformFuncVarPtr := uintptr(unsafe.Pointer(TransformFuncVar))
 	var TransformFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(TransformFuncVarPtr); ok {
+	if TransformFuncVar != nil {
-		TransformFuncVarRef = cbRefPtr
+		TransformFuncVarPtr := uintptr(unsafe.Pointer(TransformFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(TransformFuncVarPtr); ok {
-		fcb := func(arg0 *Value, arg1 *Value) {
+			TransformFuncVarRef = cbRefPtr
-			cbFn := *TransformFuncVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 *Value, arg1 *Value) {
+				cbFn := *TransformFuncVar
+				cbFn(arg0, arg1)
+			}
+			TransformFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(TransformFuncVarPtr, TransformFuncVarRef)
 		}
-		TransformFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(TransformFuncVarPtr, TransformFuncVarRef)
 	}
 	xValueRegisterTransformFunc(SrcTypeVar, DestTypeVar, TransformFuncVarRef)

M v4/gobject/gvaluearray.go +22 -18

 // C qsort() function.
 func (x *ValueArray) Sort(CompareFuncVar *glib.CompareFunc) *ValueArray {
-	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
 	var CompareFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CompareFuncVarPtr); ok {
+	if CompareFuncVar != nil {
-		CompareFuncVarRef = cbRefPtr
+		CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CompareFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) int {
+			CompareFuncVarRef = cbRefPtr
-			cbFn := *CompareFuncVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) int {
+				cbFn := *CompareFuncVar
+				return cbFn(arg0, arg1)
+			}
+			CompareFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
 		}
-		CompareFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
 	}
 	cret := xValueArraySort(x.GoPointer(), CompareFuncVarRef)
 // C qsort() function.
 func (x *ValueArray) SortWithData(CompareFuncVar *glib.CompareDataFunc, UserDataVar uintptr) *ValueArray {
-	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
 	var CompareFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CompareFuncVarPtr); ok {
+	if CompareFuncVar != nil {
-		CompareFuncVarRef = cbRefPtr
+		CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CompareFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+			CompareFuncVarRef = cbRefPtr
-			cbFn := *CompareFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
+				cbFn := *CompareFuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			CompareFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
 		}
-		CompareFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
 	}
 	cret := xValueArraySortWithData(x.GoPointer(), CompareFuncVarRef, UserDataVar)

M v4/gsk/gsktypes.go +22 -18

 //     an approximation of the path using just the allowed operations.
 func (x *Path) Foreach(FlagsVar PathForeachFlags, FuncVar *PathForeachFunc, UserDataVar uintptr) bool {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 PathOperation, arg1 []graphene.Point, arg2 uint, arg3 float32, arg4 uintptr) bool {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2, arg3, arg4)
+			fcb := func(arg0 PathOperation, arg1 []graphene.Point, arg2 uint, arg3 float32, arg4 uintptr) bool {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1, arg2, arg3, arg4)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	cret := xPathForeach(x.GoPointer(), FlagsVar, FuncVarRef, UserDataVar)
 // If @func returns `FALSE`, the iteration is stopped.
 func (x *Path) ForeachIntersection(Path2Var *Path, FuncVar *PathIntersectionFunc, UserDataVar uintptr) bool {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 *Path, arg1 *PathPoint, arg2 *Path, arg3 *PathPoint, arg4 PathIntersection, arg5 uintptr) bool {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2, arg3, arg4, arg5)
+			fcb := func(arg0 *Path, arg1 *PathPoint, arg2 *Path, arg3 *PathPoint, arg4 PathIntersection, arg5 uintptr) bool {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1, arg2, arg3, arg4, arg5)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	cret := xPathForeachIntersection(x.GoPointer(), Path2Var, FuncVarRef, UserDataVar)

M v4/gtk/gtkassistant.go +11 -9

 		}
 	}
-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
 	var DestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
+	if DestroyVar != nil {
-		DestroyVarRef = cbRefPtr
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyVarRef = cbRefPtr
-			cbFn := *DestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 		}
-		DestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 	}
 	xAssistantSetForwardPageFunc(x.GoPointer(), PageFuncVarRef, DataVar, DestroyVarRef)

M v4/gtk/gtkbuilderscope.go +22 -18

 // namespace.
 func (x *BuilderCScope) AddCallbackSymbol(CallbackNameVar string, CallbackSymbolVar *gobject.Callback) {
-	CallbackSymbolVarPtr := uintptr(unsafe.Pointer(CallbackSymbolVar))
 	var CallbackSymbolVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CallbackSymbolVarPtr); ok {
+	if CallbackSymbolVar != nil {
-		CallbackSymbolVarRef = cbRefPtr
+		CallbackSymbolVarPtr := uintptr(unsafe.Pointer(CallbackSymbolVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CallbackSymbolVarPtr); ok {
-		fcb := func() {
+			CallbackSymbolVarRef = cbRefPtr
-			cbFn := *CallbackSymbolVar
+		} else {
-			cbFn()
+			fcb := func() {
+				cbFn := *CallbackSymbolVar
+				cbFn()
+			}
+			CallbackSymbolVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackSymbolVarPtr, CallbackSymbolVarRef)
 		}
-		CallbackSymbolVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CallbackSymbolVarPtr, CallbackSymbolVarRef)
 	}
 	xBuilderCScopeAddCallbackSymbol(x.GoPointer(), CallbackNameVar, CallbackSymbolVarRef)
 // for each symbol.
 func (x *BuilderCScope) AddCallbackSymbols(FirstCallbackNameVar string, FirstCallbackSymbolVar *gobject.Callback, varArgs ...interface{}) {
-	FirstCallbackSymbolVarPtr := uintptr(unsafe.Pointer(FirstCallbackSymbolVar))
 	var FirstCallbackSymbolVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FirstCallbackSymbolVarPtr); ok {
+	if FirstCallbackSymbolVar != nil {
-		FirstCallbackSymbolVarRef = cbRefPtr
+		FirstCallbackSymbolVarPtr := uintptr(unsafe.Pointer(FirstCallbackSymbolVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FirstCallbackSymbolVarPtr); ok {
-		fcb := func() {
+			FirstCallbackSymbolVarRef = cbRefPtr
-			cbFn := *FirstCallbackSymbolVar
+		} else {
-			cbFn()
+			fcb := func() {
+				cbFn := *FirstCallbackSymbolVar
+				cbFn()
+			}
+			FirstCallbackSymbolVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FirstCallbackSymbolVarPtr, FirstCallbackSymbolVarRef)
 		}
-		FirstCallbackSymbolVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FirstCallbackSymbolVarPtr, FirstCallbackSymbolVarRef)
 	}
 	xBuilderCScopeAddCallbackSymbols(x.GoPointer(), FirstCallbackNameVar, FirstCallbackSymbolVarRef, varArgs...)

M v4/gtk/gtkcellarea.go +22 -18

 // Calls @callback for every `GtkCellRenderer` in @area.
 func (x *CellArea) Foreach(CallbackVar *CellCallback, CallbackDataVar uintptr) {
-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
 	var CallbackVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
+	if CallbackVar != nil {
-		CallbackVarRef = cbRefPtr
+		CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) bool {
+			CallbackVarRef = cbRefPtr
-			cbFn := *CallbackVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) bool {
+				cbFn := *CallbackVar
+				return cbFn(arg0, arg1)
+			}
+			CallbackVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 		}
-		CallbackVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 	}
 	xCellAreaForeach(x.GoPointer(), CallbackVarRef, CallbackDataVar)
 // allocated rectangle inside @cell_area.
 func (x *CellArea) ForeachAlloc(ContextVar *CellAreaContext, WidgetVar *Widget, CellAreaVar *gdk.Rectangle, BackgroundAreaVar *gdk.Rectangle, CallbackVar *CellAllocCallback, CallbackDataVar uintptr) {
-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
 	var CallbackVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
+	if CallbackVar != nil {
-		CallbackVarRef = cbRefPtr
+		CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 *gdk.Rectangle, arg2 *gdk.Rectangle, arg3 uintptr) bool {
+			CallbackVarRef = cbRefPtr
-			cbFn := *CallbackVar
+		} else {
-			return cbFn(arg0, arg1, arg2, arg3)
+			fcb := func(arg0 uintptr, arg1 *gdk.Rectangle, arg2 *gdk.Rectangle, arg3 uintptr) bool {
+				cbFn := *CallbackVar
+				return cbFn(arg0, arg1, arg2, arg3)
+			}
+			CallbackVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 		}
-		CallbackVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 	}
 	xCellAreaForeachAlloc(x.GoPointer(), ContextVar.GoPointer(), WidgetVar.GoPointer(), CellAreaVar, BackgroundAreaVar, CallbackVarRef, CallbackDataVar)

M v4/gtk/gtkcustomfilter.go +22 -18

 		}
 	}
-	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
 	var UserDestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
+	if UserDestroyVar != nil {
-		UserDestroyVarRef = cbRefPtr
+		UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			UserDestroyVarRef = cbRefPtr
-			cbFn := *UserDestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *UserDestroyVar
+				cbFn(arg0)
+			}
+			UserDestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
 		}
-		UserDestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
 	}
 	cret := xNewCustomFilter(MatchFuncVarRef, UserDataVar, UserDestroyVarRef)
 		}
 	}
-	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
 	var UserDestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
+	if UserDestroyVar != nil {
-		UserDestroyVarRef = cbRefPtr
+		UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			UserDestroyVarRef = cbRefPtr
-			cbFn := *UserDestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *UserDestroyVar
+				cbFn(arg0)
+			}
+			UserDestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
 		}
-		UserDestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
 	}
 	xCustomFilterSetFilterFunc(x.GoPointer(), MatchFuncVarRef, UserDataVar, UserDestroyVarRef)

M v4/gtk/gtkcustomlayout.go +22 -18

 		}
 	}
-	MeasureVarPtr := uintptr(unsafe.Pointer(MeasureVar))
 	var MeasureVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(MeasureVarPtr); ok {
+	if MeasureVar != nil {
-		MeasureVarRef = cbRefPtr
+		MeasureVarPtr := uintptr(unsafe.Pointer(MeasureVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(MeasureVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 Orientation, arg2 int, arg3 *int, arg4 *int, arg5 *int, arg6 *int) {
+			MeasureVarRef = cbRefPtr
-			cbFn := *MeasureVar
+		} else {
-			cbFn(arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+			fcb := func(arg0 uintptr, arg1 Orientation, arg2 int, arg3 *int, arg4 *int, arg5 *int, arg6 *int) {
+				cbFn := *MeasureVar
+				cbFn(arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+			}
+			MeasureVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(MeasureVarPtr, MeasureVarRef)
 		}
-		MeasureVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(MeasureVarPtr, MeasureVarRef)
 	}
-	AllocateVarPtr := uintptr(unsafe.Pointer(AllocateVar))
 	var AllocateVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(AllocateVarPtr); ok {
+	if AllocateVar != nil {
-		AllocateVarRef = cbRefPtr
+		AllocateVarPtr := uintptr(unsafe.Pointer(AllocateVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(AllocateVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 int, arg2 int, arg3 int) {
+			AllocateVarRef = cbRefPtr
-			cbFn := *AllocateVar
+		} else {
-			cbFn(arg0, arg1, arg2, arg3)
+			fcb := func(arg0 uintptr, arg1 int, arg2 int, arg3 int) {
+				cbFn := *AllocateVar
+				cbFn(arg0, arg1, arg2, arg3)
+			}
+			AllocateVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(AllocateVarPtr, AllocateVarRef)
 		}
-		AllocateVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(AllocateVarPtr, AllocateVarRef)
 	}
 	cret := xNewCustomLayout(RequestModeVarRef, MeasureVarRef, AllocateVarRef)

M v4/gtk/gtkcustomsorter.go +11 -9

 		}
 	}
-	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
 	var UserDestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
+	if UserDestroyVar != nil {
-		UserDestroyVarRef = cbRefPtr
+		UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			UserDestroyVarRef = cbRefPtr
-			cbFn := *UserDestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *UserDestroyVar
+				cbFn(arg0)
+			}
+			UserDestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
 		}
-		UserDestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
 	}
 	xCustomSorterSetSortFunc(x.GoPointer(), SortFuncVarRef, UserDataVar, UserDestroyVarRef)

M v4/gtk/gtkdrawingarea.go +11 -9

 		}
 	}
-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
 	var DestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
+	if DestroyVar != nil {
-		DestroyVarRef = cbRefPtr
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyVarRef = cbRefPtr
-			cbFn := *DestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 		}
-		DestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 	}
 	xDrawingAreaSetDrawFunc(x.GoPointer(), DrawFuncVarRef, UserDataVar, DestroyVarRef)

M v4/gtk/gtkentrycompletion.go +22 -18

 // should not be in the completion list.
 func (x *EntryCompletion) SetMatchFunc(FuncVar *EntryCompletionMatchFunc, FuncDataVar uintptr, FuncNotifyVar *glib.DestroyNotify) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 string, arg2 *TreeIter, arg3 uintptr) bool {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2, arg3)
+			fcb := func(arg0 uintptr, arg1 string, arg2 *TreeIter, arg3 uintptr) bool {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1, arg2, arg3)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FuncVarPtr, FuncVarRef)
 	}
-	FuncNotifyVarPtr := uintptr(unsafe.Pointer(FuncNotifyVar))
 	var FuncNotifyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FuncNotifyVarPtr); ok {
+	if FuncNotifyVar != nil {
-		FuncNotifyVarRef = cbRefPtr
+		FuncNotifyVarPtr := uintptr(unsafe.Pointer(FuncNotifyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FuncNotifyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			FuncNotifyVarRef = cbRefPtr
-			cbFn := *FuncNotifyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *FuncNotifyVar
+				cbFn(arg0)
+			}
+			FuncNotifyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncNotifyVarPtr, FuncNotifyVarRef)
 		}
-		FuncNotifyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FuncNotifyVarPtr, FuncNotifyVarRef)
 	}
 	xEntryCompletionSetMatchFunc(x.GoPointer(), FuncVarRef, FuncDataVar, FuncNotifyVarRef)

M v4/gtk/gtkexpression.go +33 -27

 		}
 	}
-	CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
 	var CallbackFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
+	if CallbackFuncVar != nil {
-		CallbackFuncVarRef = cbRefPtr
+		CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
-		fcb := func() {
+			CallbackFuncVarRef = cbRefPtr
-			cbFn := *CallbackFuncVar
+		} else {
-			cbFn()
+			fcb := func() {
+				cbFn := *CallbackFuncVar
+				cbFn()
+			}
+			CallbackFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
 		}
-		CallbackFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
 	}
 	var UserDestroyVarRef uintptr
 // the @notify will be invoked.
 func (x *Expression) Watch(ThisVar *gobject.Object, NotifyVar *ExpressionNotify, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) *ExpressionWatch {
-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
 	var NotifyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
+	if NotifyVar != nil {
-		NotifyVarRef = cbRefPtr
+		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			NotifyVarRef = cbRefPtr
-			cbFn := *NotifyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *NotifyVar
+				cbFn(arg0)
+			}
+			NotifyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 		}
-		NotifyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 	}
-	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
 	var UserDestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
+	if UserDestroyVar != nil {
-		UserDestroyVarRef = cbRefPtr
+		UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			UserDestroyVarRef = cbRefPtr
-			cbFn := *UserDestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *UserDestroyVar
+				cbFn(arg0)
+			}
+			UserDestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
 		}
-		UserDestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
 	}
 	cret := xExpressionWatch(x.GoPointer(), ThisVar.GoPointer(), NotifyVarRef, UserDataVar, UserDestroyVarRef)

M v4/gtk/gtkflowbox.go +55 -45

 // should be implemented by the model.
 func (x *FlowBox) BindModel(ModelVar gio.ListModel, CreateWidgetFuncVar *FlowBoxCreateWidgetFunc, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) {
-	CreateWidgetFuncVarPtr := uintptr(unsafe.Pointer(CreateWidgetFuncVar))
 	var CreateWidgetFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CreateWidgetFuncVarPtr); ok {
+	if CreateWidgetFuncVar != nil {
-		CreateWidgetFuncVarRef = cbRefPtr
+		CreateWidgetFuncVarPtr := uintptr(unsafe.Pointer(CreateWidgetFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CreateWidgetFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
+			CreateWidgetFuncVarRef = cbRefPtr
-			cbFn := *CreateWidgetFuncVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
+				cbFn := *CreateWidgetFuncVar
+				return cbFn(arg0, arg1)
+			}
+			CreateWidgetFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CreateWidgetFuncVarPtr, CreateWidgetFuncVarRef)
 		}
-		CreateWidgetFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CreateWidgetFuncVarPtr, CreateWidgetFuncVarRef)
 	}
-	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
 	var UserDataFreeFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
+	if UserDataFreeFuncVar != nil {
-		UserDataFreeFuncVarRef = cbRefPtr
+		UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			UserDataFreeFuncVarRef = cbRefPtr
-			cbFn := *UserDataFreeFuncVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *UserDataFreeFuncVar
+				cbFn(arg0)
+			}
+			UserDataFreeFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
 		}
-		UserDataFreeFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
 	}
 	xFlowBoxBindModel(x.GoPointer(), ModelVar.GoPointer(), CreateWidgetFuncVarRef, UserDataVar, UserDataFreeFuncVarRef)
 // this function.
 func (x *FlowBox) SelectedForeach(FuncVar *FlowBoxForeachFunc, DataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+				cbFn := *FuncVar
+				cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xFlowBoxSelectedForeach(x.GoPointer(), FuncVarRef, DataVar)
 		}
 	}
-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
 	var DestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
+	if DestroyVar != nil {
-		DestroyVarRef = cbRefPtr
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyVarRef = cbRefPtr
-			cbFn := *DestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 		}
-		DestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 	}
 	xFlowBoxSetFilterFunc(x.GoPointer(), FilterFuncVarRef, UserDataVar, DestroyVarRef)
 		}
 	}
-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
 	var DestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
+	if DestroyVar != nil {
-		DestroyVarRef = cbRefPtr
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyVarRef = cbRefPtr
-			cbFn := *DestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 		}
-		DestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 	}
 	xFlowBoxSetSortFunc(x.GoPointer(), SortFuncVarRef, UserDataVar, DestroyVarRef)

M v4/gtk/gtkiconview.go +11 -9

 // selection cannot be modified from within this function.
 func (x *IconView) SelectedForeach(FuncVar *IconViewForeachFunc, DataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 *TreePath, arg2 uintptr) {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 *TreePath, arg2 uintptr) {
+				cbFn := *FuncVar
+				cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xIconViewSelectedForeach(x.GoPointer(), FuncVarRef, DataVar)

M v4/gtk/gtklistbox.go +55 -45

 		}
 	}
-	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
 	var UserDataFreeFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
+	if UserDataFreeFuncVar != nil {
-		UserDataFreeFuncVarRef = cbRefPtr
+		UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			UserDataFreeFuncVarRef = cbRefPtr
-			cbFn := *UserDataFreeFuncVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *UserDataFreeFuncVar
+				cbFn(arg0)
+			}
+			UserDataFreeFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
 		}
-		UserDataFreeFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
 	}
 	xListBoxBindModel(x.GoPointer(), ModelVar.GoPointer(), CreateWidgetFuncVarRef, UserDataVar, UserDataFreeFuncVarRef)
 // Note that the selection cannot be modified from within this function.
 func (x *ListBox) SelectedForeach(FuncVar *ListBoxForeachFunc, DataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+				cbFn := *FuncVar
+				cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xListBoxSelectedForeach(x.GoPointer(), FuncVarRef, DataVar)
 		}
 	}
-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
 	var DestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
+	if DestroyVar != nil {
-		DestroyVarRef = cbRefPtr
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyVarRef = cbRefPtr
-			cbFn := *DestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 		}
-		DestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 	}
 	xListBoxSetFilterFunc(x.GoPointer(), FilterFuncVarRef, UserDataVar, DestroyVarRef)
 		}
 	}
-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
 	var DestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
+	if DestroyVar != nil {
-		DestroyVarRef = cbRefPtr
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyVarRef = cbRefPtr
-			cbFn := *DestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 		}
-		DestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 	}
 	xListBoxSetHeaderFunc(x.GoPointer(), UpdateHeaderVarRef, UserDataVar, DestroyVarRef)
 		}
 	}
-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
 	var DestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
+	if DestroyVar != nil {
-		DestroyVarRef = cbRefPtr
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyVarRef = cbRefPtr
-			cbFn := *DestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 		}
-		DestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 	}
 	xListBoxSetSortFunc(x.GoPointer(), SortFuncVarRef, UserDataVar, DestroyVarRef)

M v4/gtk/gtkmaplistmodel.go +22 -18

 		}
 	}
-	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
 	var UserDestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
+	if UserDestroyVar != nil {
-		UserDestroyVarRef = cbRefPtr
+		UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			UserDestroyVarRef = cbRefPtr
-			cbFn := *UserDestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *UserDestroyVar
+				cbFn(arg0)
+			}
+			UserDestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
 		}
-		UserDestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
 	}
 	cret := xNewMapListModel(ModelVar.GoPointer(), MapFuncVarRef, UserDataVar, UserDestroyVarRef)
 		}
 	}
-	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
 	var UserDestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
+	if UserDestroyVar != nil {
-		UserDestroyVarRef = cbRefPtr
+		UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			UserDestroyVarRef = cbRefPtr
-			cbFn := *UserDestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *UserDestroyVar
+				cbFn(arg0)
+			}
+			UserDestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
 		}
-		UserDestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
 	}
 	xMapListModelSetMapFunc(x.GoPointer(), MapFuncVarRef, UserDataVar, UserDestroyVarRef)

M v4/gtk/gtkprinter.go +22 -18

 // If @func returns true, the enumeration is stopped.
 func EnumeratePrinters(FuncVar *PrinterFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify, WaitVar bool) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) bool {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) bool {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FuncVarPtr, FuncVarRef)
 	}
-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
 	var DestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
+	if DestroyVar != nil {
-		DestroyVarRef = cbRefPtr
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyVarRef = cbRefPtr
-			cbFn := *DestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 		}
-		DestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 	}
 	xEnumeratePrinters(FuncVarRef, DataVar, DestroyVarRef, WaitVar)

M v4/gtk/gtkprintjob.go +22 -18

 // Sends the print job off to the printer.
 func (x *PrintJob) Send(CallbackVar *PrintJobCompleteFunc, UserDataVar uintptr, DnotifyVar *glib.DestroyNotify) {
-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
 	var CallbackVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
+	if CallbackVar != nil {
-		CallbackVarRef = cbRefPtr
+		CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 *glib.Error) {
+			CallbackVarRef = cbRefPtr
-			cbFn := *CallbackVar
+		} else {
-			cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 *glib.Error) {
+				cbFn := *CallbackVar
+				cbFn(arg0, arg1, arg2)
+			}
+			CallbackVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 		}
-		CallbackVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 	}
-	DnotifyVarPtr := uintptr(unsafe.Pointer(DnotifyVar))
 	var DnotifyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DnotifyVarPtr); ok {
+	if DnotifyVar != nil {
-		DnotifyVarRef = cbRefPtr
+		DnotifyVarPtr := uintptr(unsafe.Pointer(DnotifyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DnotifyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DnotifyVarRef = cbRefPtr
-			cbFn := *DnotifyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DnotifyVar
+				cbFn(arg0)
+			}
+			DnotifyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DnotifyVarPtr, DnotifyVarRef)
 		}
-		DnotifyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DnotifyVarPtr, DnotifyVarRef)
 	}
 	xPrintJobSend(x.GoPointer(), CallbackVarRef, UserDataVar, DnotifyVarRef)

M v4/gtk/gtkprintoperation.go +11 -9

 // @done_cb from a signal handler for the ::response signal of the dialog.
 func PrintRunPageSetupDialogAsync(ParentVar *Window, PageSetupVar *PageSetup, SettingsVar *PrintSettings, DoneCbVar *PageSetupDoneFunc, DataVar uintptr) {
-	DoneCbVarPtr := uintptr(unsafe.Pointer(DoneCbVar))
 	var DoneCbVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DoneCbVarPtr); ok {
+	if DoneCbVar != nil {
-		DoneCbVarRef = cbRefPtr
+		DoneCbVarPtr := uintptr(unsafe.Pointer(DoneCbVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DoneCbVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) {
+			DoneCbVarRef = cbRefPtr
-			cbFn := *DoneCbVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) {
+				cbFn := *DoneCbVar
+				cbFn(arg0, arg1)
+			}
+			DoneCbVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DoneCbVarPtr, DoneCbVarRef)
 		}
-		DoneCbVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DoneCbVarPtr, DoneCbVarRef)
 	}
 	xPrintRunPageSetupDialogAsync(ParentVar.GoPointer(), PageSetupVar.GoPointer(), SettingsVar.GoPointer(), DoneCbVarRef, DataVar)

M v4/gtk/gtkprintsettings.go +11 -9

 // Calls @func for each key-value pair of @settings.
 func (x *PrintSettings) Foreach(FuncVar *PrintSettingsFunc, UserDataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 string, arg1 string, arg2 uintptr) {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 string, arg1 string, arg2 uintptr) {
+				cbFn := *FuncVar
+				cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xPrintSettingsForeach(x.GoPointer(), FuncVarRef, UserDataVar)

M v4/gtk/gtkshortcutaction.go +22 -18

 func NewCallbackAction(CallbackVar *ShortcutFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) *CallbackAction {
 	var cls *CallbackAction
-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
 	var CallbackVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
+	if CallbackVar != nil {
-		CallbackVarRef = cbRefPtr
+		CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 *glib.Variant, arg2 uintptr) bool {
+			CallbackVarRef = cbRefPtr
-			cbFn := *CallbackVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 *glib.Variant, arg2 uintptr) bool {
+				cbFn := *CallbackVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			CallbackVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 		}
-		CallbackVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 	}
-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
 	var DestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
+	if DestroyVar != nil {
-		DestroyVarRef = cbRefPtr
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyVarRef = cbRefPtr
-			cbFn := *DestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 		}
-		DestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 	}
 	cret := xNewCallbackAction(CallbackVarRef, DataVar, DestroyVarRef)

M v4/gtk/gtktextbuffer.go +22 -18

 // other signal handlers which may further modify the [type@Gtk.TextBuffer].
 func (x *TextBuffer) AddCommitNotify(FlagsVar TextBufferNotifyFlags, CommitNotifyVar *TextBufferCommitNotify, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) uint {
-	CommitNotifyVarPtr := uintptr(unsafe.Pointer(CommitNotifyVar))
 	var CommitNotifyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CommitNotifyVarPtr); ok {
+	if CommitNotifyVar != nil {
-		CommitNotifyVarRef = cbRefPtr
+		CommitNotifyVarPtr := uintptr(unsafe.Pointer(CommitNotifyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CommitNotifyVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 TextBufferNotifyFlags, arg2 uint, arg3 uint, arg4 uintptr) {
+			CommitNotifyVarRef = cbRefPtr
-			cbFn := *CommitNotifyVar
+		} else {
-			cbFn(arg0, arg1, arg2, arg3, arg4)
+			fcb := func(arg0 uintptr, arg1 TextBufferNotifyFlags, arg2 uint, arg3 uint, arg4 uintptr) {
+				cbFn := *CommitNotifyVar
+				cbFn(arg0, arg1, arg2, arg3, arg4)
+			}
+			CommitNotifyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CommitNotifyVarPtr, CommitNotifyVarRef)
 		}
-		CommitNotifyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CommitNotifyVarPtr, CommitNotifyVarRef)
 	}
-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
 	var DestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
+	if DestroyVar != nil {
-		DestroyVarRef = cbRefPtr
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyVarRef = cbRefPtr
-			cbFn := *DestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 		}
-		DestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 	}
 	cret := xTextBufferAddCommitNotify(x.GoPointer(), FlagsVar, CommitNotifyVarRef, UserDataVar, DestroyVarRef)

M v4/gtk/gtktextiter.go +22 -18

 // but goes backward from @iter.
 func (x *TextIter) BackwardFindChar(PredVar *TextCharPredicate, UserDataVar uintptr, LimitVar *TextIter) bool {
-	PredVarPtr := uintptr(unsafe.Pointer(PredVar))
 	var PredVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(PredVarPtr); ok {
+	if PredVar != nil {
-		PredVarRef = cbRefPtr
+		PredVarPtr := uintptr(unsafe.Pointer(PredVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(PredVarPtr); ok {
-		fcb := func(arg0 uint32, arg1 uintptr) bool {
+			PredVarRef = cbRefPtr
-			cbFn := *PredVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 uint32, arg1 uintptr) bool {
+				cbFn := *PredVar
+				return cbFn(arg0, arg1)
+			}
+			PredVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(PredVarPtr, PredVarRef)
 		}
-		PredVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(PredVarPtr, PredVarRef)
 	}
 	cret := xTextIterBackwardFindChar(x.GoPointer(), PredVarRef, UserDataVar, LimitVar)
 // @limit is non-%NULL, otherwise to the end iterator.
 func (x *TextIter) ForwardFindChar(PredVar *TextCharPredicate, UserDataVar uintptr, LimitVar *TextIter) bool {
-	PredVarPtr := uintptr(unsafe.Pointer(PredVar))
 	var PredVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(PredVarPtr); ok {
+	if PredVar != nil {
-		PredVarRef = cbRefPtr
+		PredVarPtr := uintptr(unsafe.Pointer(PredVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(PredVarPtr); ok {
-		fcb := func(arg0 uint32, arg1 uintptr) bool {
+			PredVarRef = cbRefPtr
-			cbFn := *PredVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 uint32, arg1 uintptr) bool {
+				cbFn := *PredVar
+				return cbFn(arg0, arg1)
+			}
+			PredVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(PredVarPtr, PredVarRef)
 		}
-		PredVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(PredVarPtr, PredVarRef)
 	}
 	cret := xTextIterForwardFindChar(x.GoPointer(), PredVarRef, UserDataVar, LimitVar)

M v4/gtk/gtktexttagtable.go +11 -9

 // over it (you can’t add/remove tags).
 func (x *TextTagTable) Foreach(FuncVar *TextTagTableForeach, DataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) {
+				cbFn := *FuncVar
+				cbFn(arg0, arg1)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xTextTagTableForeach(x.GoPointer(), FuncVarRef, DataVar)

M v4/gtk/gtktreelistmodel.go +22 -18

 func NewTreeListModel(RootVar gio.ListModel, PassthroughVar bool, AutoexpandVar bool, CreateFuncVar *TreeListModelCreateModelFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) *TreeListModel {
 	var cls *TreeListModel
-	CreateFuncVarPtr := uintptr(unsafe.Pointer(CreateFuncVar))
 	var CreateFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CreateFuncVarPtr); ok {
+	if CreateFuncVar != nil {
-		CreateFuncVarRef = cbRefPtr
+		CreateFuncVarPtr := uintptr(unsafe.Pointer(CreateFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CreateFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
+			CreateFuncVarRef = cbRefPtr
-			cbFn := *CreateFuncVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
+				cbFn := *CreateFuncVar
+				return cbFn(arg0, arg1)
+			}
+			CreateFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CreateFuncVarPtr, CreateFuncVarRef)
 		}
-		CreateFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CreateFuncVarPtr, CreateFuncVarRef)
 	}
-	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
 	var UserDestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
+	if UserDestroyVar != nil {
-		UserDestroyVarRef = cbRefPtr
+		UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			UserDestroyVarRef = cbRefPtr
-			cbFn := *UserDestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *UserDestroyVar
+				cbFn(arg0)
+			}
+			UserDestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
 		}
-		UserDestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
 	}
 	cret := xNewTreeListModel(RootVar.GoPointer(), PassthroughVar, AutoexpandVar, CreateFuncVarRef, UserDataVar, UserDestroyVarRef)

M v4/gtk/gtktreemodelfilter.go +22 -18

 // can only be called once for a given filter model.
 func (x *TreeModelFilter) SetModifyFunc(NColumnsVar int, TypesVar []types.GType, FuncVar *TreeModelFilterModifyFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 *TreeIter, arg2 *gobject.Value, arg3 int, arg4 uintptr) {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			cbFn(arg0, arg1, arg2, arg3, arg4)
+			fcb := func(arg0 uintptr, arg1 *TreeIter, arg2 *gobject.Value, arg3 int, arg4 uintptr) {
+				cbFn := *FuncVar
+				cbFn(arg0, arg1, arg2, arg3, arg4)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	var DestroyVarRef uintptr
 // once for a given filter model.
 func (x *TreeModelFilter) SetVisibleFunc(FuncVar *TreeModelFilterVisibleFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 *TreeIter, arg2 uintptr) bool {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 *TreeIter, arg2 uintptr) bool {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	var DestroyVarRef uintptr

M v4/gtk/gtktreeselection.go +22 -18

 // gtk_tree_selection_get_selected_rows() might be more useful.
 func (x *TreeSelection) SelectedForeach(FuncVar *TreeSelectionForeachFunc, DataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 *TreePath, arg2 *TreeIter, arg3 uintptr) {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			cbFn(arg0, arg1, arg2, arg3)
+			fcb := func(arg0 uintptr, arg1 *TreePath, arg2 *TreeIter, arg3 uintptr) {
+				cbFn := *FuncVar
+				cbFn(arg0, arg1, arg2, arg3)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xTreeSelectionSelectedForeach(x.GoPointer(), FuncVarRef, DataVar)
 		}
 	}
-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
 	var DestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
+	if DestroyVar != nil {
-		DestroyVarRef = cbRefPtr
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyVarRef = cbRefPtr
-			cbFn := *DestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 		}
-		DestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 	}
 	xTreeSelectionSetSelectFunction(x.GoPointer(), FuncVarRef, DataVar, DestroyVarRef)

M v4/gtk/gtktreeview.go +44 -36

 // “sizing” property set to be GTK_TREE_VIEW_COLUMN_FIXED.
 func (x *TreeView) InsertColumnWithDataFunc(PositionVar int, TitleVar string, CellVar *CellRenderer, FuncVar *TreeCellDataFunc, DataVar uintptr, DnotifyVar *glib.DestroyNotify) int {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr, arg3 *TreeIter, arg4 uintptr) {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			cbFn(arg0, arg1, arg2, arg3, arg4)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr, arg3 *TreeIter, arg4 uintptr) {
+				cbFn := *FuncVar
+				cbFn(arg0, arg1, arg2, arg3, arg4)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FuncVarPtr, FuncVarRef)
 	}
-	DnotifyVarPtr := uintptr(unsafe.Pointer(DnotifyVar))
 	var DnotifyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DnotifyVarPtr); ok {
+	if DnotifyVar != nil {
-		DnotifyVarRef = cbRefPtr
+		DnotifyVarPtr := uintptr(unsafe.Pointer(DnotifyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DnotifyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DnotifyVarRef = cbRefPtr
-			cbFn := *DnotifyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DnotifyVar
+				cbFn(arg0)
+			}
+			DnotifyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DnotifyVarPtr, DnotifyVarRef)
 		}
-		DnotifyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DnotifyVarPtr, DnotifyVarRef)
 	}
 	cret := xTreeViewInsertColumnWithDataFunc(x.GoPointer(), PositionVar, TitleVar, CellVar.GoPointer(), FuncVarRef, DataVar, DnotifyVarRef)
 // Calls @func on all expanded rows.
 func (x *TreeView) MapExpandedRows(FuncVar *TreeViewMappingFunc, DataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 *TreePath, arg2 uintptr) {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 *TreePath, arg2 uintptr) {
+				cbFn := *FuncVar
+				cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xTreeViewMapExpandedRows(x.GoPointer(), FuncVarRef, DataVar)
 // `GtkTreeView`SearchEqualFunc returns %FALSE on matches.
 func (x *TreeView) SetSearchEqualFunc(SearchEqualFuncVar *TreeViewSearchEqualFunc, SearchUserDataVar uintptr, SearchDestroyVar *glib.DestroyNotify) {
-	SearchEqualFuncVarPtr := uintptr(unsafe.Pointer(SearchEqualFuncVar))
 	var SearchEqualFuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(SearchEqualFuncVarPtr); ok {
+	if SearchEqualFuncVar != nil {
-		SearchEqualFuncVarRef = cbRefPtr
+		SearchEqualFuncVarPtr := uintptr(unsafe.Pointer(SearchEqualFuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(SearchEqualFuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 int, arg2 string, arg3 *TreeIter, arg4 uintptr) bool {
+			SearchEqualFuncVarRef = cbRefPtr
-			cbFn := *SearchEqualFuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2, arg3, arg4)
+			fcb := func(arg0 uintptr, arg1 int, arg2 string, arg3 *TreeIter, arg4 uintptr) bool {
+				cbFn := *SearchEqualFuncVar
+				return cbFn(arg0, arg1, arg2, arg3, arg4)
+			}
+			SearchEqualFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(SearchEqualFuncVarPtr, SearchEqualFuncVarRef)
 		}
-		SearchEqualFuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(SearchEqualFuncVarPtr, SearchEqualFuncVarRef)
 	}
 	var SearchDestroyVarRef uintptr

M v4/gtk/gtktreeviewcolumn.go +11 -9

 		}
 	}
-	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
 	var DestroyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
+	if DestroyVar != nil {
-		DestroyVarRef = cbRefPtr
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			DestroyVarRef = cbRefPtr
-			cbFn := *DestroyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 		}
-		DestroyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
 	}
 	xTreeViewColumnSetCellDataFunc(x.GoPointer(), CellRendererVar.GoPointer(), FuncVarRef, FuncDataVar, DestroyVarRef)

M v4/gtk/gtkwidget.go +55 -45

 // shortcut.
 func (x *WidgetClass) AddBinding(KeyvalVar uint, ModsVar gdk.ModifierType, CallbackVar *ShortcutFunc, FormatStringVar string, varArgs ...interface{}) {
-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
 	var CallbackVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
+	if CallbackVar != nil {
-		CallbackVarRef = cbRefPtr
+		CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 *glib.Variant, arg2 uintptr) bool {
+			CallbackVarRef = cbRefPtr
-			cbFn := *CallbackVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 *glib.Variant, arg2 uintptr) bool {
+				cbFn := *CallbackVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			CallbackVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 		}
-		CallbackVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 	}
 	xWidgetClassAddBinding(x.GoPointer(), KeyvalVar, ModsVar, CallbackVarRef, FormatStringVar, varArgs...)
 // class initializer after calling [method@Gtk.WidgetClass.set_template].
 func (x *WidgetClass) BindTemplateCallbackFull(CallbackNameVar string, CallbackSymbolVar *gobject.Callback) {
-	CallbackSymbolVarPtr := uintptr(unsafe.Pointer(CallbackSymbolVar))
 	var CallbackSymbolVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CallbackSymbolVarPtr); ok {
+	if CallbackSymbolVar != nil {
-		CallbackSymbolVarRef = cbRefPtr
+		CallbackSymbolVarPtr := uintptr(unsafe.Pointer(CallbackSymbolVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CallbackSymbolVarPtr); ok {
-		fcb := func() {
+			CallbackSymbolVarRef = cbRefPtr
-			cbFn := *CallbackSymbolVar
+		} else {
-			cbFn()
+			fcb := func() {
+				cbFn := *CallbackSymbolVar
+				cbFn()
+			}
+			CallbackSymbolVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackSymbolVarPtr, CallbackSymbolVarRef)
 		}
-		CallbackSymbolVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CallbackSymbolVarPtr, CallbackSymbolVarRef)
 	}
 	xWidgetClassBindTemplateCallbackFull(x.GoPointer(), CallbackNameVar, CallbackSymbolVarRef)
 // with [method@Gtk.Widget.action_set_enabled]).
 func (x *WidgetClass) InstallAction(ActionNameVar string, ParameterTypeVar string, ActivateVar *WidgetActionActivateFunc) {
-	ActivateVarPtr := uintptr(unsafe.Pointer(ActivateVar))
 	var ActivateVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(ActivateVarPtr); ok {
+	if ActivateVar != nil {
-		ActivateVarRef = cbRefPtr
+		ActivateVarPtr := uintptr(unsafe.Pointer(ActivateVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(ActivateVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 string, arg2 *glib.Variant) {
+			ActivateVarRef = cbRefPtr
-			cbFn := *ActivateVar
+		} else {
-			cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 string, arg2 *glib.Variant) {
+				cbFn := *ActivateVar
+				cbFn(arg0, arg1, arg2)
+			}
+			ActivateVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(ActivateVarPtr, ActivateVarRef)
 		}
-		ActivateVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(ActivateVarPtr, ActivateVarRef)
 	}
 	xWidgetClassInstallAction(x.GoPointer(), ActionNameVar, ParameterTypeVar, ActivateVarRef)
 // to [method@Gtk.Widget.remove_tick_callback].
 func (x *Widget) AddTickCallback(CallbackVar *TickCallback, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) uint {
-	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
 	var CallbackVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
+	if CallbackVar != nil {
-		CallbackVarRef = cbRefPtr
+		CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
+			CallbackVarRef = cbRefPtr
-			cbFn := *CallbackVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
+				cbFn := *CallbackVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			CallbackVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 		}
-		CallbackVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
 	}
-	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
 	var NotifyVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
+	if NotifyVar != nil {
-		NotifyVarRef = cbRefPtr
+		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
-		fcb := func(arg0 uintptr) {
+			NotifyVarRef = cbRefPtr
-			cbFn := *NotifyVar
+		} else {
-			cbFn(arg0)
+			fcb := func(arg0 uintptr) {
+				cbFn := *NotifyVar
+				cbFn(arg0)
+			}
+			NotifyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 		}
-		NotifyVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
 	}
 	cret := xWidgetAddTickCallback(x.GoPointer(), CallbackVarRef, UserDataVar, NotifyVarRef)

M v4/pango/pango-attributes.go +11 -9

 // inserts them into a new list.
 func (x *AttrList) Filter(FuncVar *AttrFilterFunc, DataVar uintptr) *AttrList {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 *Attribute, arg1 uintptr) bool {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1)
+			fcb := func(arg0 *Attribute, arg1 uintptr) bool {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	cret := xAttrListFilter(x.GoPointer(), FuncVarRef, DataVar)

M v4/pango/pango-fontset.go +11 -9

 // If @func returns %TRUE, that stops the iteration.
 func (x *Fontset) Foreach(FuncVar *FontsetForeachFunc, DataVar uintptr) {
-	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
 	var FuncVarRef uintptr
-	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
+	if FuncVar != nil {
-		FuncVarRef = cbRefPtr
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
-	} else {
+		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
-		fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
+			FuncVarRef = cbRefPtr
-			cbFn := *FuncVar
+		} else {
-			return cbFn(arg0, arg1, arg2)
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncVarPtr, FuncVarRef)
 		}
-		FuncVarRef = purego.NewCallback(fcb)
-		glib.SaveCallback(FuncVarPtr, FuncVarRef)
 	}
 	xFontsetForeach(x.GoPointer(), FuncVarRef, DataVar)