e97e9fe GIR: Move `tryRegister` back into core with `PuregoSafeRegister` · purego

M internal/core/core.go +12 -10


@@ -15,13 +15,15 @@ import (
15	15		"github.com/jwijenbergh/purego"
16	16		)
17	17
18		-	func PuregoSafeRegister(fptr interface{}, handle uintptr, name string) error {
19		-	sym, err := purego.Dlsym(handle, name)
20		-	if err != nil {
21		-	return err
	18	+	func PuregoSafeRegister(fptr interface{}, libs []uintptr, name string) {
	19	+	for _, lib := range libs {
	20	+	sym, err := purego.Dlsym(lib, name)
	21	+	if err == nil {
	22	+	purego.RegisterFunc(fptr, sym)
	23	+
	24	+	return
	25	+	}
22	26		}
23		-	purego.RegisterFunc(fptr, sym)
24		-	return nil
25	27		}
26	28
27	29		// paths to where the shared object files should be located

@@ -105,7 +107,7 @@ func findPkgConf(name string) string {
105	107		return ""
106	108		}
107	109
108		-	// GetPath gets a shared object file from a library name
	110	+	// getPath gets a shared object file from a library name
109	111		// it does it in the following order
110	112		// see if PUREGOTK_LIBNAME_PATH is set (full path to the lib)
111	113		// - e.g. PUREGOTK_GTK_PATH

@@ -115,7 +117,7 @@ func findPkgConf(name string) string {
115	117		// panic if failed
116	118		// TODO: Hardcore a library shared object with linker -X flag
117	119		// This is useful for packaging
118		-	func GetPath(name string) string {
	120	+	func getPath(name string) string {
119	121		// try to get from env var
120	122		ev := fmt.Sprintf("PUREGOTK_%s_PATH", name)
121	123		if v := os.Getenv(ev); v != "" {

@@ -178,12 +180,12 @@ func GetPaths(name string) []string {
178	180		libNames, ok := names[name]
179	181		if !ok \|\| len(libNames) == 0 {
180	182		// Fallback to single GetPath for backward compatibility
181		-	return []string{GetPath(name)}
	183	+	return []string{getPath(name)}
182	184		}
183	185
184	186		// If only one library, use the original GetPath logic
185	187		if len(libNames) == 1 {
186		-	return []string{GetPath(name)}
	188	+	return []string{getPath(name)}
187	189		}
188	190
189	191		var result []string

 	"github.com/jwijenbergh/purego"
 )
-func PuregoSafeRegister(fptr interface{}, handle uintptr, name string) error {
+func PuregoSafeRegister(fptr interface{}, libs []uintptr, name string) {
-	sym, err := purego.Dlsym(handle, name)
+	for _, lib := range libs {
-	if err != nil {
+		sym, err := purego.Dlsym(lib, name)
-		return err
+		if err == nil {
+			purego.RegisterFunc(fptr, sym)
+			return
+		}
 	}
-	purego.RegisterFunc(fptr, sym)
-	return nil
 }
 // paths to where the shared object files should be located
 	return ""
 }
-// GetPath gets a shared object file from a library name
+// getPath gets a shared object file from a library name
 // it does it in the following order
 // see if PUREGOTK_LIBNAME_PATH is set (full path to the lib)
 // - e.g. PUREGOTK_GTK_PATH
 // panic if failed
 // TODO: Hardcore a library shared object with linker -X flag
 // This is useful for packaging
-func GetPath(name string) string {
+func getPath(name string) string {
 	// try to get from env var
 	ev := fmt.Sprintf("PUREGOTK_%s_PATH", name)
 	if v := os.Getenv(ev); v != "" {
 	libNames, ok := names[name]
 	if !ok || len(libNames) == 0 {
 		// Fallback to single GetPath for backward compatibility
-		return []string{GetPath(name)}
+		return []string{getPath(name)}
 	}
 	// If only one library, use the original GetPath logic
 	if len(libNames) == 1 {
-		return []string{GetPath(name)}
+		return []string{getPath(name)}
 	}
 	var result []string

M pkg/core/core.go +2 -3


@@ -3,10 +3,9 @@ package core
3	3		import "github.com/jwijenbergh/puregotk/internal/core"
4	4
5	5		var (
6		-	PuregoSafeRegister = core.PuregoSafeRegister
7		-	GetPath = core.GetPath
8	6		GetPaths = core.GetPaths
9	7		GoString = core.GoString
10	8		SetPackageName = core.SetPackageName
11		-	SetSharedLibraries = core.SetSharedLibraries
	9	+	SetSharedLibraries = core.SetSharedLibraries
	10	+	PuregoSafeRegister = core.PuregoSafeRegister
12	11		)

 import "github.com/jwijenbergh/puregotk/internal/core"
 var (
-	PuregoSafeRegister = core.PuregoSafeRegister
-	GetPath            = core.GetPath
 	GetPaths           = core.GetPaths
 	GoString           = core.GoString
 	SetPackageName     = core.SetPackageName
-	SetSharedLibraries   = core.SetSharedLibraries
+	SetSharedLibraries = core.SetSharedLibraries
+	PuregoSafeRegister = core.PuregoSafeRegister
 )

M templates/go +12 -20


@@ -348,63 +348,55 @@ func init() {
348	348		libs = append(libs, lib)
349	349		}
350	350
351		-	tryRegister := func(fptr interface{}, name string) {
352		-	for _, lib := range libs {
353		-	if err := core.PuregoSafeRegister(fptr, lib, name); err == nil {
354		-	return
355		-	}
356		-	}
357		-	}
358		-
359	351		{{range .Aliases -}}
360	352		{{if .TypeGetter -}}
361		-	tryRegister(&x{{.Name}}GLibType, "{{.TypeGetter}}")
	353	+	core.PuregoSafeRegister(&x{{.Name}}GLibType, libs, "{{.TypeGetter}}")
362	354		{{end}}
363	355		{{end}}
364	356		{{range .Enums -}}
365	357		{{if .TypeGetter -}}
366		-	tryRegister(&x{{.Name}}GLibType, "{{.TypeGetter}}")
	358	+	core.PuregoSafeRegister(&x{{.Name}}GLibType, libs, "{{.TypeGetter}}")
367	359		{{end}}
368	360		{{end}}
369	361		{{range .Functions -}}
370		-	tryRegister(&x{{.Name}}, "{{.CName}}")
	362	+	core.PuregoSafeRegister(&x{{.Name}}, libs, "{{.CName}}")
371	363		{{end}}
372	364
373	365		{{range .Records -}}
374	366		{{$rec := .}}
375	367		{{if .TypeGetter -}}
376		-	tryRegister(&x{{.Name}}GLibType, "{{.TypeGetter}}")
	368	+	core.PuregoSafeRegister(&x{{.Name}}GLibType, libs, "{{.TypeGetter}}")
377	369		{{end}}
378	370		{{range .Constructors -}}
379		-	tryRegister(&x{{.Name}}, "{{.CName}}")
	371	+	core.PuregoSafeRegister(&x{{.Name}}, libs, "{{.CName}}")
380	372		{{end}}
381	373		{{range .Receivers -}}
382		-	tryRegister(&x{{$rec.Name}}{{.Name}}, "{{.CName}}")
	374	+	core.PuregoSafeRegister(&x{{$rec.Name}}{{.Name}}, libs, "{{.CName}}")
383	375		{{end}}
384	376		{{end}}
385	377
386	378		{{range .Classes -}}
387	379		{{$cls := .}}
388	380		{{if .TypeGetter -}}
389		-	tryRegister(&x{{.Name}}GLibType, "{{.TypeGetter}}")
	381	+	core.PuregoSafeRegister(&x{{.Name}}GLibType, libs, "{{.TypeGetter}}")
390	382		{{end}}
391	383		{{range .Constructors -}}
392		-	tryRegister(&x{{.Name}}, "{{.CName}}")
	384	+	core.PuregoSafeRegister(&x{{.Name}}, libs, "{{.CName}}")
393	385		{{end}}
394	386		{{range .Receivers -}}
395		-	tryRegister(&x{{$cls.Name}}{{.Name}}, "{{.CName}}")
	387	+	core.PuregoSafeRegister(&x{{$cls.Name}}{{.Name}}, libs, "{{.CName}}")
396	388		{{end}}
397	389		{{range .Functions -}}
398		-	tryRegister(&x{{.Name}}, "{{.CName}}")
	390	+	core.PuregoSafeRegister(&x{{.Name}}, libs, "{{.CName}}")
399	391		{{end}}
400	392		{{end}}
401	393
402	394		{{range .Interfaces -}}
403	395		{{if .TypeGetter -}}
404		-	tryRegister(&x{{.Name}}GLibType, "{{.TypeGetter}}")
	396	+	core.PuregoSafeRegister(&x{{.Name}}GLibType, libs, "{{.TypeGetter}}")
405	397		{{end}}
406	398		{{range .Methods -}}
407		-	tryRegister(&{{.Namespace}}X{{.FullName}}, "{{.CName}}")
	399	+	core.PuregoSafeRegister(&{{.Namespace}}X{{.FullName}}, libs, "{{.CName}}")
408	400		{{end}}
409	401		{{end}}
410	402		}

         libs = append(libs, lib)
     }
-    tryRegister := func(fptr interface{}, name string) {
-        for _, lib := range libs {
-            if err := core.PuregoSafeRegister(fptr, lib, name); err == nil {
-                return
-            }
-        }
-    }
     {{range .Aliases -}}
     {{if .TypeGetter -}}
-    tryRegister(&x{{.Name}}GLibType, "{{.TypeGetter}}")
+    core.PuregoSafeRegister(&x{{.Name}}GLibType, libs, "{{.TypeGetter}}")
     {{end}}
     {{end}}
     {{range .Enums -}}
     {{if .TypeGetter -}}
-    tryRegister(&x{{.Name}}GLibType, "{{.TypeGetter}}")
+    core.PuregoSafeRegister(&x{{.Name}}GLibType, libs, "{{.TypeGetter}}")
     {{end}}
     {{end}}
     {{range .Functions -}}
-    tryRegister(&x{{.Name}}, "{{.CName}}")
+    core.PuregoSafeRegister(&x{{.Name}}, libs, "{{.CName}}")
     {{end}}
     {{range .Records -}}
     {{$rec := .}}
     {{if .TypeGetter -}}
-    tryRegister(&x{{.Name}}GLibType, "{{.TypeGetter}}")
+    core.PuregoSafeRegister(&x{{.Name}}GLibType, libs, "{{.TypeGetter}}")
     {{end}}
     {{range .Constructors -}}
-    tryRegister(&x{{.Name}}, "{{.CName}}")
+    core.PuregoSafeRegister(&x{{.Name}}, libs, "{{.CName}}")
     {{end}}
     {{range .Receivers -}}
-    tryRegister(&x{{$rec.Name}}{{.Name}}, "{{.CName}}")
+    core.PuregoSafeRegister(&x{{$rec.Name}}{{.Name}}, libs, "{{.CName}}")
     {{end}}
     {{end}}
     {{range .Classes -}}
     {{$cls := .}}
     {{if .TypeGetter -}}
-    tryRegister(&x{{.Name}}GLibType, "{{.TypeGetter}}")
+    core.PuregoSafeRegister(&x{{.Name}}GLibType, libs, "{{.TypeGetter}}")
     {{end}}
     {{range .Constructors -}}
-    tryRegister(&x{{.Name}}, "{{.CName}}")
+    core.PuregoSafeRegister(&x{{.Name}}, libs, "{{.CName}}")
     {{end}}
     {{range .Receivers -}}
-    tryRegister(&x{{$cls.Name}}{{.Name}}, "{{.CName}}")
+    core.PuregoSafeRegister(&x{{$cls.Name}}{{.Name}}, libs, "{{.CName}}")
     {{end}}
     {{range .Functions -}}
-    tryRegister(&x{{.Name}}, "{{.CName}}")
+    core.PuregoSafeRegister(&x{{.Name}}, libs, "{{.CName}}")
     {{end}}
     {{end}}
     {{range .Interfaces -}}
     {{if .TypeGetter -}}
-    tryRegister(&x{{.Name}}GLibType, "{{.TypeGetter}}")
+    core.PuregoSafeRegister(&x{{.Name}}GLibType, libs, "{{.TypeGetter}}")
     {{end}}
     {{range .Methods -}}
-    tryRegister(&{{.Namespace}}X{{.FullName}}, "{{.CName}}")
+    core.PuregoSafeRegister(&{{.Namespace}}X{{.FullName}}, libs, "{{.CName}}")
     {{end}}
     {{end}}
 }