generate: iterate on supporting functions

Author: tmc

generate/codegen/gen_function.go

@@ -27,87 +27,68 @@ type Function struct {
 	identifier string
 }
 
-func (f *Function) Init() {
-}
-
-func (f *Function) WriteGoCode(cw *CodeWriter) {
-	panic("implement me")
-}
-
-// Copy for copy fetcher cache value
-func (f *Function) Copy() CodeGen {
-	if f == nil {
-		return nil
-	}
-	return &Function{
-		Type:        f.Type,
-		Name:        f.Name,
-		GoName:      f.GoName,
-		Params:      f.Params,
-		ReturnType:  f.ReturnType,
-		Deprecated:  f.Deprecated,
-		Suffix:      f.Suffix,
-		Description: f.Description,
-		DocURL:      f.DocURL,
-		goFuncName:  f.goFuncName,
-		identifier:  f.identifier,
+// GoArgs return go function args
+func (f *Function) GoArgs() string {
+	var args []string
+	for _, p := range f.Params {
+		args = append(args, p.GoName())
 	}
+	return strings.Join(args, ", ")
 }
 
-func (m *Function) needRelease() bool {
-	switch m.ReturnType.(type) {
-	case *typing.PrimitiveType, *typing.StringType:
-		return false
+// GoReturn return go function return
+func (f *Function) GoReturn() string {
+	if f.ReturnType == nil {
+		return ""
 	}
-	return strings.HasPrefix(m.Name, "new") || !strings.HasPrefix(m.Name, "init") && strings.HasPrefix(m.Name, "Initial") ||
-		strings.HasPrefix(m.Name, "copy") || strings.HasPrefix(m.Name, "mutableCopy")
+	return f.ReturnType.GoName(nil, true)
 }
 
 // Selector return full Objc function name
-func (m *Function) Selector() string {
-	if m.identifier == "" {
+func (f *Function) Selector() string {
+	if f.identifier == "" {
 		var sb strings.Builder
-		sb.WriteString(m.Name)
-		for idx, p := range m.Params {
+		sb.WriteString(f.Name)
+		for idx, p := range f.Params {
 			if idx > 0 {
 				sb.WriteString(p.FieldName)
 			}
 			sb.WriteString(":")
 		}
-		m.identifier = sb.String()
+		f.identifier = sb.String()
 	}
-	return m.identifier
+	return f.identifier
 }
 
-func (m *Function) String() string {
-	return m.Selector()
+func (f *Function) String() string {
+	return f.Selector()
 }
 
 // NormalizeInstanceTypeFunction return new init function.
-func (m *Function) NormalizeInstanceTypeFunction(returnType *typing.ClassType) *Function {
+func (f *Function) NormalizeInstanceTypeFunction(returnType *typing.ClassType) *Function {
 	nm := &Function{
-		Name:       m.Name,
-		GoName:     m.GoName,
-		Params:     m.Params,
+		Name:       f.Name,
+		GoName:     f.GoName,
+		Params:     f.Params,
 		ReturnType: returnType,
-		goFuncName: m.goFuncName,
-		Suffix:     m.Suffix,
+		goFuncName: f.goFuncName,
+		Suffix:     f.Suffix,
 	}
 	return nm
 }
 
 // WriteGoCallCode generate go function code to call c wrapper code
-func (m *Function) WriteGoCallCode(currentModule *modules.Module, typeName string, cw *CodeWriter) {
-	funcDeclare := m.GoFuncDeclare(currentModule, typeName)
+func (f *Function) WriteGoCallCode(currentModule *modules.Module, typeName string, cw *CodeWriter) {
+	funcDeclare := f.GoFuncDeclare(currentModule, typeName)
 
-	if m.Deprecated {
+	if f.Deprecated {
 		return
 		cw.WriteLine("// deprecated")
 	}
 
-	if m.DocURL != "" {
-		cw.WriteLine(fmt.Sprintf("// %s [Full Topic]", m.Description))
-		cw.WriteLine(fmt.Sprintf("//\n// [Full Topic]: %s", m.DocURL))
+	if f.DocURL != "" {
+		cw.WriteLine(fmt.Sprintf("// %s [Full Topic]", f.Description))
+		cw.WriteLine(fmt.Sprintf("//\n// [Full Topic]: %s", f.DocURL))
 	}
 
 	var receiver string
@@ -117,16 +98,16 @@ func (m *Function) WriteGoCallCode(currentModule *modules.Module, typeName strin
 	cw.Indent()
 
 	var returnTypeStr string
-	rt := typing.UnwrapAlias(m.ReturnType)
+	rt := typing.UnwrapAlias(f.ReturnType)
 	switch rt.(type) {
 	case *typing.VoidType:
 		returnTypeStr = "objc.Void"
 	default:
-		returnTypeStr = m.ReturnType.GoName(currentModule, true)
+		returnTypeStr = f.ReturnType.GoName(currentModule, true)
 	}
-	callCode := fmt.Sprintf("objc.Call[%s](%s, objc.Sel(\"%s\")", returnTypeStr, receiver, m.Selector())
+	callCode := fmt.Sprintf("objc.Call[%s](%s, objc.Sel(\"%s\")", returnTypeStr, receiver, f.Selector())
 	var sb strings.Builder
-	for idx, p := range m.Params {
+	for idx, p := range f.Params {
 		sb.WriteString(", ")
 		switch tt := p.Type.(type) {
 		case *typing.ClassType:
@@ -154,9 +135,6 @@ func (m *Function) WriteGoCallCode(currentModule *modules.Module, typeName strin
 	default:
 		var resultName = "rv"
 		cw.WriteLine(resultName + " := " + callCode)
-		if m.needRelease() {
-			cw.WriteLine(resultName + ".Autorelease()")
-		}
 		cw.WriteLine("return " + resultName)
 	}
 	cw.UnIndent()

generate/codegen/modulewriter.go

@@ -23,12 +23,14 @@ type ModuleWriter struct {
 	Protocols   []*typing.ProtocolType
 	EnumAliases []*AliasInfo
 	FuncAliases []*AliasInfo
+	Functions   []*Function
 }
 
 func (m *ModuleWriter) WriteCode() {
 	m.WriteDocFile()
 	m.WriteEnumAliases()
 	m.WriteTypeAliases()
+	m.WriteFunctions()
 	if m.Module.Package == "coreimage" {
 		// filter protocols maybe arent "real" protocols?
 		// get "cannot find protocol declaration" with protocol imports
@@ -79,6 +81,48 @@ func (m *ModuleWriter) WriteTypeAliases() {
 	}
 }
 
+func (m *ModuleWriter) WriteFunctions() {
+	if len(m.Functions) == 0 {
+		return
+	}
+
+	filePath := filepath.Join(m.PlatformDir, m.Module.Package, "functions.gen.go")
+	os.MkdirAll(filepath.Dir(filePath), 0755)
+	f, err := os.Create(filePath)
+	if err != nil {
+		panic(err)
+	}
+	defer f.Close()
+
+	cw := &CodeWriter{Writer: f, IndentStr: "\t"}
+	cw.WriteLine(AutoGeneratedMark)
+	cw.WriteLine("package " + m.Module.Package)
+
+	cw.WriteLine("import (")
+
+	// imports
+	var imports = set.New("unsafe")
+	for _, fa := range m.FuncAliases {
+		imports.AddSet(fa.GoImports())
+	}
+	cw.Indent()
+	imports.ForEach(func(value string) {
+		if value != "github.com/progrium/macdriver/macos/objc" {
+			cw.WriteLine("\"" + value + "\"")
+		}
+	})
+	cw.UnIndent()
+	cw.WriteLine(")")
+
+	for _, fa := range m.Functions {
+		if fa.DocURL != "" {
+			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())
+	}
+}
+
 func (m *ModuleWriter) WriteEnumAliases() {
 	enums := make([]*AliasInfo, len(m.EnumAliases))
 	copy(enums, m.EnumAliases)

generate/function.go

@@ -8,26 +8,24 @@ import (
 	"github.com/progrium/macdriver/generate/typing"
 )
 
-func (db *Generator) ToFunctionGen(fw string, sym Symbol) *codegen.Function {
-	if db.genCache == nil {
-		db.genCache = make(map[string]codegen.CodeGen)
-	}
-	key := fmt.Sprintf("%s.%s", fw, sym.Name)
-	fg, ok := db.genCache[key]
-	fmt.Printf("function: %s\n", key, fg, ok)
-
+func (db *Generator) ToFunction(fw string, sym Symbol) *codegen.Function {
+	typ := db.TypeFromSymbol(sym)
+	fmt.Println("typ:", typ)
 	type_ := &typing.FunctionType{
 		Name:   sym.Name,
 		GName:  modules.TrimPrefix(sym.Name),
 		Module: modules.Get(fw),
 	}
-	functionGen := &codegen.Function{
+	fn := &codegen.Function{
 		Description: sym.Description,
 		DocURL:      sym.DocURL(),
 		Type:        type_,
 	}
-
-	db.genCache[key] = functionGen
-	return functionGen
+	for _, arg := range sym.Parameters {
+		fn.Params = append(fn.Params, &codegen.Param{
+			Name: arg.Name,
+		})
+	}
+	return fn
 
 }

generate/generator.go

@@ -107,21 +107,7 @@ func (db *Generator) Generate(platform string, version int, rootDir string, fram
 				continue
 			}
 		case "Function":
-			functionGen := db.ToFunctionGen(framework, s)
-			if functionGen == nil {
-				log.Println("skipping function", s.Name)
-				continue
-			}
-			functionGen.Init()
-			fw := &codegen.FileWriter{
-				Name:        s.Name,
-				Module:      *functionGen.Type.Module,
-				PlatformDir: rootDir,
-			}
-			fw.Add(functionGen)
-			fw.WriteCode()
-		default:
-			log.Println("skipping", s.Kind, s.Name)
+			mw.Functions = append(mw.Functions, db.ToFunction(framework, s))
 		}
 	}
 	mw.WriteCode()

generate/types.go

@@ -93,6 +93,14 @@ func (db *Generator) TypeFromSymbol(sym Symbol) typing.Type {
 			GName:  modules.TrimPrefix(sym.Name),
 			Module: modules.Get(module),
 		}
+	case "Function":
+		ft := &typing.FunctionType{
+			Name:   sym.Name,
+			GName:  modules.TrimPrefix(sym.Name),
+			Module: modules.Get(module),
+		}
+		// TODO: parse function params and return type from declaration
+		return ft
 	default:
 		fmt.Printf("TypeFromSymbol: kind=%s name=%s path=%s\n", sym.Kind, sym.Name, sym.Path)
 		panic("bad type")

generate/typing/function_type.go

@@ -7,11 +7,19 @@ import (
 
 var _ Type = (*FunctionType)(nil)
 
-// FunctionType Objective-c interface type
+type Parameter struct {
+	Type Type
+	Name string // the param name
+}
+
+// FunctionType Objective-c function type
 type FunctionType struct {
 	Name   string          // objc type name
 	GName  string          // Go name, usually is objc type name without prefix 'NS'
 	Module *modules.Module // object-c module
+
+	Parameters []Parameter // function parameters
+	Return     Type        // function return type
 }
 
 var Function = &FunctionType{