generate: iterate on function support

Author: tmc

generate/codegen/gen_function.go

@@ -16,7 +16,7 @@ type Function struct {
 	Type        *typing.FunctionType
 	Name        string // the first part of objc function name
 	GoName      string
-	Params      []*Param
+	Parameters  []*Param
 	ReturnType  typing.Type
 	Deprecated  bool // if has been deprecated
 	Suffix      bool // GoName conflicts so add suffix to this function
@@ -28,28 +28,28 @@ type Function struct {
 }
 
 // GoArgs return go function args
-func (f *Function) GoArgs() string {
+func (f *Function) GoArgs(currentModule *modules.Module) string {
 	var args []string
-	for _, p := range f.Params {
-		args = append(args, p.GoName())
+	for _, p := range f.Parameters {
+		args = append(args, fmt.Sprintf("%s %s", p.Name, p.Type.GoName(currentModule, true)))
 	}
 	return strings.Join(args, ", ")
 }
 
 // GoReturn return go function return
-func (f *Function) GoReturn() string {
+func (f *Function) GoReturn(currentModule *modules.Module) string {
 	if f.ReturnType == nil {
 		return ""
 	}
-	return f.ReturnType.GoName(nil, true)
+	return f.ReturnType.GoName(currentModule, true)
 }
 
 // Selector return full Objc function name
 func (f *Function) Selector() string {
 	if f.identifier == "" {
 		var sb strings.Builder
 		sb.WriteString(f.Name)
-		for idx, p := range f.Params {
+		for idx, p := range f.Parameters {
 			if idx > 0 {
 				sb.WriteString(p.FieldName)
 			}
@@ -69,7 +69,7 @@ func (f *Function) NormalizeInstanceTypeFunction(returnType *typing.ClassType) *
 	nm := &Function{
 		Name:       f.Name,
 		GoName:     f.GoName,
-		Params:     f.Params,
+		Parameters: f.Parameters,
 		ReturnType: returnType,
 		goFuncName: f.goFuncName,
 		Suffix:     f.Suffix,
@@ -107,7 +107,7 @@ func (f *Function) WriteGoCallCode(currentModule *modules.Module, typeName strin
 	}
 	callCode := fmt.Sprintf("objc.Call[%s](%s, objc.Sel(\"%s\")", returnTypeStr, receiver, f.Selector())
 	var sb strings.Builder
-	for idx, p := range f.Params {
+	for idx, p := range f.Parameters {
 		sb.WriteString(", ")
 		switch tt := p.Type.(type) {
 		case *typing.ClassType:
@@ -154,7 +154,7 @@ func (f *Function) WriteGoInterfaceCode(currentModule *modules.Module, classType
 // GoFuncDeclare generate go function declaration
 func (f *Function) GoFuncDeclare(currentModule *modules.Module, goTypeName string) string {
 	var paramStrs []string
-	for _, p := range f.Params {
+	for _, p := range f.Parameters {
 		paramStrs = append(paramStrs, p.GoDeclare(currentModule, false))
 	}
 
@@ -167,11 +167,11 @@ func (f *Function) GoFuncName() string {
 	if f.goFuncName == "" {
 		var sb strings.Builder
 		name := f.GoName
-		if len(f.Params) == 0 {
+		if len(f.Parameters) == 0 {
 			sb.WriteString(stringx.Capitalize(name))
 		}
 
-		for _, p := range f.Params {
+		for _, p := range f.Parameters {
 			sb.WriteString(stringx.Capitalize(p.FieldName))
 			if p.Object {
 				sb.WriteString("Object")
@@ -189,7 +189,7 @@ func (f *Function) GoFuncName() string {
 // ProtocolGoFuncFieldType generate go function declaration for protocol struct impl field
 func (f *Function) ProtocolGoFuncFieldType(currentModule *modules.Module) string {
 	var paramStrs []string
-	for _, p := range f.Params {
+	for _, p := range f.Parameters {
 		paramStrs = append(paramStrs, p.GoDeclare(currentModule, true))
 	}
 
@@ -201,7 +201,7 @@ func (f *Function) ProtocolGoFuncName() string {
 	if f.goFuncName == "" {
 		var sb strings.Builder
 		sb.WriteString(stringx.Capitalize(f.Name))
-		for idx, p := range f.Params {
+		for idx, p := range f.Parameters {
 			if idx == 0 {
 				continue
 			}
@@ -222,7 +222,7 @@ func (f *Function) ProtocolGoFuncName() string {
 // GoImports return all imports for go file
 func (f *Function) GoImports() set.Set[string] {
 	var imports = set.New("github.com/progrium/macdriver/objc")
-	for _, param := range f.Params {
+	for _, param := range f.Parameters {
 		imports.AddSet(param.Type.GoImports())
 	}
 	if f.ReturnType != nil {
@@ -232,7 +232,7 @@ func (f *Function) GoImports() set.Set[string] {
 }
 
 func (f *Function) HasProtocolParam() bool {
-	for _, p := range f.Params {
+	for _, p := range f.Parameters {
 		switch p.Type.(type) {
 		case *typing.ProtocolType:
 			return true
@@ -242,8 +242,8 @@ func (f *Function) HasProtocolParam() bool {
 }
 
 func (f *Function) ToProtocolParamAsObjectFunction() *Function {
-	var newParams = make([]*Param, len(f.Params))
-	for i, p := range f.Params {
+	var newParams = make([]*Param, len(f.Parameters))
+	for i, p := range f.Parameters {
 		switch p.Type.(type) {
 		case *typing.ProtocolType:
 			newParams[i] = &Param{
@@ -259,7 +259,7 @@ func (f *Function) ToProtocolParamAsObjectFunction() *Function {
 	return &Function{
 		Name:        f.Name,
 		GoName:      f.GoName,
-		Params:      newParams,
+		Parameters:  newParams,
 		Suffix:      f.Suffix,
 		ReturnType:  f.ReturnType,
 		Deprecated:  f.Deprecated,

generate/codegen/modulewriter.go

@@ -119,7 +119,7 @@ func (m *ModuleWriter) WriteFunctions() {
 			cw.WriteLine(fmt.Sprintf("// %s [Full Topic]", fa.Description))
 			cw.WriteLine(fmt.Sprintf("//\n// [Full Topic]: %s", fa.DocURL))
 		}
-		cw.WriteLineF("// func %s(%s) %s", fa.Name, fa.GoArgs(), fa.GoReturn())
+		cw.WriteLineF("// func %s(%s) %s {}", fa.GoName, fa.GoArgs(&m.Module), fa.GoReturn(&m.Module))
 	}
 }
 

generate/function.go

@@ -4,28 +4,90 @@ import (
 	"fmt"
 
 	"github.com/progrium/macdriver/generate/codegen"
-	"github.com/progrium/macdriver/generate/modules"
 	"github.com/progrium/macdriver/generate/typing"
 )
 
 func (db *Generator) ToFunction(fw string, sym Symbol) *codegen.Function {
+	// these functions have known declparse failures
+	knownIssues := map[string]bool{
+		"AUListenerAddParameter":                   true,
+		"MIDIClientCreate":                         true,
+		"AudioDeviceGetProperty":                   true,
+		"AudioFileComponentOpenWithCallbacks":      true,
+		"AudioObjectSetPropertyData":               true,
+		"AudioUnitRemoveRenderNotify":              true,
+		"CFBagRemoveValue":                         true,
+		"CFBinaryHeapGetMinimumIfPresent":          true,
+		"CFURLCopyResourcePropertyForKey":          true,
+		"CGBitmapContextCreate":                    true,
+		"CGBitmapContextCreateWithData":            true,
+		"CGColorSpaceCreateWithPlatformColorSpace": true,
+		"CGConvertColorDataWithFormat":             true,
+		"CGDataConsumerCreate":                     true,
+		"CGDataProviderCreateDirect":               true,
+		"CGDataProviderCreateSequential":           true,
+		"CGDataProviderCreateWithData":             true,
+		"CGDisplayRegisterReconfigurationCallback": true,
+		"CGDisplayRemoveReconfigurationCallback":   true,
+		"CGEventPostToPSN":                         true,
+		"CGEventTapCreate":                         true,
+		"CGEventTapCreateForPSN":                   true,
+		"CGEventTapCreateForPid":                   true,
+		"CGFontCreateWithPlatformFont":             true,
+		"CGFunctionCreate":                         true,
+		"CGPDFArrayApplyBlock":                     true,
+		"CGPDFDictionaryApplyBlock":                true,
+		"CGPDFDictionaryApplyFunction":             true,
+		"CGPDFObjectGetValue":                      true,
+		"CGPDFScannerCreate":                       true,
+		"CGPSConverterCreate":                      true,
+		"CGPathApply":                              true,
+		"CGPatternCreate":                          true,
+		"CGRegisterScreenRefreshCallback":          true,
+		"CGScreenRegisterMoveCallback":             true,
+		"CGScreenUnregisterMoveCallback":           true,
+		"CGUnregisterScreenRefreshCallback":        true,
+		"CMBlockBufferAppendMemoryBlock":           true,
+		"CMIOStreamClockCreate":                    true,
+		"MIDIEndpointSetRefCons":                   true,
+		"NSBeginAlertSheet":                        true,
+		"NSBeginCriticalAlertSheet":                true,
+		"NSShowAnimationEffect":                    true,
+		"NSZoneFromPointer":                        true,
+		"OBEXAddHTTPHeader":                        true,
+		"OBEXAddUserDefinedHeader":                 true,
+	}
+	if knownIssues[sym.Name] {
+		return nil
+	}
 	typ := db.TypeFromSymbol(sym)
-	fmt.Println("typ:", typ)
-	type_ := &typing.FunctionType{
-		Name:   sym.Name,
-		GName:  modules.TrimPrefix(sym.Name),
-		Module: modules.Get(fw),
+	fntyp, ok := typ.(*typing.FunctionType)
+	if !ok {
+		return nil
 	}
 	fn := &codegen.Function{
+		Name:        sym.Name,
+		GoName:      sym.Name,
 		Description: sym.Description,
 		DocURL:      sym.DocURL(),
-		Type:        type_,
+		Type:        fntyp,
 	}
-	for _, arg := range sym.Parameters {
-		fn.Params = append(fn.Params, &codegen.Param{
-			Name: arg.Name,
+	// populate params:
+	for _, p := range fntyp.Parameters {
+		if p.Type == nil {
+			fmt.Printf("skipping %s: %s because of nil type\n", sym.Name, p.Name)
+			continue
+		}
+		fn.Parameters = append(fn.Parameters, &codegen.Param{
+			Name: p.Name,
+			Type: p.Type,
 		})
 	}
+	// populate return type
+	if fntyp.ReturnType != nil {
+		fn.ReturnType = fntyp.ReturnType
+	}
+
 	return fn
 
 }

generate/generator.go

@@ -107,7 +107,12 @@ func (db *Generator) Generate(platform string, version int, rootDir string, fram
 				continue
 			}
 		case "Function":
-			mw.Functions = append(mw.Functions, db.ToFunction(framework, s))
+			fn := db.ToFunction(framework, s)
+			if fn == nil {
+				log.Println("skipping function", s.Name)
+				continue
+			}
+			mw.Functions = append(mw.Functions, fn)
 		}
 	}
 	mw.WriteCode()

generate/modules/modules.go

@@ -100,6 +100,7 @@ func CanIgnoreNotFound(p any) bool {
 		"QuickLook",
 		"force feedback",
 		"opengl es",
+		"ColorSync",
 	} {
 		if strings.EqualFold(m, mod) {
 			return true

generate/types.go

@@ -94,11 +94,28 @@ func (db *Generator) TypeFromSymbol(sym Symbol) typing.Type {
 			Module: modules.Get(module),
 		}
 	case "Function":
+		typ, err := sym.Parse()
+		if err != nil {
+			fmt.Printf("TypeFromSymbol: failed to parse %s: %s\n", sym.Declaration, err)
+			panic("bad function")
+		}
+		fn := typ.Function
+		if fn == nil {
+			fmt.Printf("TypeFromSymbol: name=%s declaration=%s\n", sym.Name, sym.Declaration)
+			panic("bad function")
+		}
 		ft := &typing.FunctionType{
 			Name:   sym.Name,
 			GName:  modules.TrimPrefix(sym.Name),
 			Module: modules.Get(module),
 		}
+		for _, arg := range fn.Args {
+			ft.Parameters = append(ft.Parameters, typing.Parameter{
+				Name: arg.Name,
+				Type: db.ParseType(arg.Type),
+			})
+		}
+		ft.ReturnType = db.ParseType(fn.ReturnType)
 		// TODO: parse function params and return type from declaration
 		return ft
 	default:

generate/typing/function_type.go

@@ -19,7 +19,7 @@ type FunctionType struct {
 	Module *modules.Module // object-c module
 
 	Parameters []Parameter // function parameters
-	Return     Type        // function return type
+	ReturnType Type        // function return type
 }
 
 var Function = &FunctionType{