1d88bcc all: apply (#439) · purego

M func.go +4 -4


@@ -159,7 +159,7 @@ func RegisterFunc(fptr any, cfn uintptr) {
159	159		}
160	160		}
161	161		case reflect.String, reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
162		-	reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Ptr, reflect.UnsafePointer,
	162	+	reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Pointer, reflect.UnsafePointer,
163	163		reflect.Slice, reflect.Bool:
164	164		if ints < numOfIntegerRegisters() {
165	165		ints++

@@ -343,7 +343,7 @@ func RegisterFunc(fptr any, cfn uintptr) {
343	343		case reflect.UnsafePointer:
344	344		// We take the address and then dereference it to trick go vet from creating a possible miss-use of unsafe.Pointer
345	345		v.SetPointer((unsafe.Pointer)(unsafe.Pointer(&syscall.a1)))
346		-	case reflect.Ptr:
	346	+	case reflect.Pointer:
347	347		v = reflect.NewAt(outType, unsafe.Pointer(&syscall.a1)).Elem()
348	348		case reflect.Func:
349	349		// wrap this C function in a nicely typed Go function

@@ -403,7 +403,7 @@ func addValue(v reflect.Value, keepAlive []any, addInt func(x uintptr), addFloat
403	403		addInt(uintptr(v.Uint()))
404	404		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
405	405		addInt(uintptr(v.Int()))
406		-	case reflect.Ptr, reflect.UnsafePointer, reflect.Slice:
	406	+	case reflect.Pointer, reflect.UnsafePointer, reflect.Slice:
407	407		// There is no need to keepAlive this pointer separately because it is kept alive in the args variable
408	408		addInt(v.Pointer())
409	409		case reflect.Func:

@@ -482,7 +482,7 @@ func checkStructFieldsSupported(ty reflect.Type) {
482	482		switch f.Kind() {
483	483		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
484	484		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
485		-	reflect.Uintptr, reflect.Ptr, reflect.UnsafePointer, reflect.Float64, reflect.Float32,
	485	+	reflect.Uintptr, reflect.Pointer, reflect.UnsafePointer, reflect.Float64, reflect.Float32,
486	486		reflect.Bool:
487	487		default:
488	488		panic(fmt.Sprintf("purego: struct field type %s is not supported", f))


@@ -159,7 +159,7 @@ func RegisterFunc(fptr any, cfn uintptr) {
159		}	159		}
160		}	160		}
161		case reflect.String, reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,	161		case reflect.String, reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
162	-	reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Ptr, reflect.UnsafePointer,	162	+	reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Pointer, reflect.UnsafePointer,
163		reflect.Slice, reflect.Bool:	163		reflect.Slice, reflect.Bool:
164		if ints < numOfIntegerRegisters() {	164		if ints < numOfIntegerRegisters() {
165		ints++	165		ints++

@@ -343,7 +343,7 @@ func RegisterFunc(fptr any, cfn uintptr) {
343		case reflect.UnsafePointer:	343		case reflect.UnsafePointer:
344		// We take the address and then dereference it to trick go vet from creating a possible miss-use of unsafe.Pointer	344		// We take the address and then dereference it to trick go vet from creating a possible miss-use of unsafe.Pointer
345		v.SetPointer((unsafe.Pointer)(unsafe.Pointer(&syscall.a1)))	345		v.SetPointer((unsafe.Pointer)(unsafe.Pointer(&syscall.a1)))
346	-	case reflect.Ptr:	346	+	case reflect.Pointer:
347		v = reflect.NewAt(outType, unsafe.Pointer(&syscall.a1)).Elem()	347		v = reflect.NewAt(outType, unsafe.Pointer(&syscall.a1)).Elem()
348		case reflect.Func:	348		case reflect.Func:
349		// wrap this C function in a nicely typed Go function	349		// wrap this C function in a nicely typed Go function

@@ -403,7 +403,7 @@ func addValue(v reflect.Value, keepAlive []any, addInt func(x uintptr), addFloat
403		addInt(uintptr(v.Uint()))	403		addInt(uintptr(v.Uint()))
404		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:	404		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
405		addInt(uintptr(v.Int()))	405		addInt(uintptr(v.Int()))
406	-	case reflect.Ptr, reflect.UnsafePointer, reflect.Slice:	406	+	case reflect.Pointer, reflect.UnsafePointer, reflect.Slice:
407		// There is no need to keepAlive this pointer separately because it is kept alive in the args variable	407		// There is no need to keepAlive this pointer separately because it is kept alive in the args variable
408		addInt(v.Pointer())	408		addInt(v.Pointer())
409		case reflect.Func:	409		case reflect.Func:

@@ -482,7 +482,7 @@ func checkStructFieldsSupported(ty reflect.Type) {
482		switch f.Kind() {	482		switch f.Kind() {
483		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,	483		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
484		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,	484		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
485	-	reflect.Uintptr, reflect.Ptr, reflect.UnsafePointer, reflect.Float64, reflect.Float32,	485	+	reflect.Uintptr, reflect.Pointer, reflect.UnsafePointer, reflect.Float64, reflect.Float32,
486		reflect.Bool:	486		reflect.Bool:
487		default:	487		default:
488		panic(fmt.Sprintf("purego: struct field type %s is not supported", f))	488		panic(fmt.Sprintf("purego: struct field type %s is not supported", f))

M objc/objc_runtime_darwin.go +15 -13


@@ -12,6 +12,7 @@ import (
12	12		"reflect"
13	13		"regexp"
14	14		"runtime"
	15	+	stdstrings "strings"
15	16		"unicode"
16	17		"unsafe"
17	18

@@ -456,26 +457,27 @@ func encodeType(typ reflect.Type, insidePtr bool) (string, error) {
456	457		return encFloat, nil
457	458		case reflect.Float64:
458	459		return encDouble, nil
459		-	case reflect.Ptr:
	460	+	case reflect.Pointer:
460	461		enc, err := encodeType(typ.Elem(), true)
461	462		return encPtr + enc, err
462	463		case reflect.Struct:
463	464		if insidePtr {
464	465		return encStructBegin + typ.Name() + encStructEnd, nil
465	466		}
466		-	encoding := encStructBegin
467		-	encoding += typ.Name()
468		-	encoding += "="
	467	+	var encoding stdstrings.Builder
	468	+	encoding.WriteString(encStructBegin)
	469	+	encoding.WriteString(typ.Name())
	470	+	encoding.WriteString("=")
469	471		for i := 0; i < typ.NumField(); i++ {
470	472		f := typ.Field(i)
471	473		tmp, err := encodeType(f.Type, false)
472	474		if err != nil {
473	475		return "", err
474	476		}
475		-	encoding += tmp
	477	+	encoding.WriteString(tmp)
476	478		}
477		-	encoding += encStructEnd
478		-	return encoding, nil
	479	+	encoding.WriteString(encStructEnd)
	480	+	return encoding.String(), nil
479	481		case reflect.UnsafePointer:
480	482		return encUnsafePtr, nil
481	483		case reflect.String:

@@ -492,16 +494,16 @@ func encodeFunc(fn any) (string, error) {
492	494		return "", errors.New("not a func")
493	495		}
494	496
495		-	encoding := ""
	497	+	var encoding stdstrings.Builder
496	498		switch typ.NumOut() {
497	499		case 0:
498		-	encoding += encVoid
	500	+	encoding.WriteString(encVoid)
499	501		case 1:
500	502		tmp, err := encodeType(typ.Out(0), false)
501	503		if err != nil {
502	504		return "", err
503	505		}
504		-	encoding += tmp
	506	+	encoding.WriteString(tmp)
505	507		default:
506	508		return "", errors.New("too many output parameters")
507	509		}

@@ -510,16 +512,16 @@ func encodeFunc(fn any) (string, error) {
510	512		return "", errors.New("func doesn't take ID and SEL as its first two parameters")
511	513		}
512	514
513		-	encoding += encId
	515	+	encoding.WriteString(encId)
514	516
515	517		for i := 1; i < typ.NumIn(); i++ {
516	518		tmp, err := encodeType(typ.In(i), false)
517	519		if err != nil {
518	520		return "", err
519	521		}
520		-	encoding += tmp
	522	+	encoding.WriteString(tmp)
521	523		}
522		-	return encoding, nil
	524	+	return encoding.String(), nil
523	525		}
524	526
525	527		// SuperClass returns the superclass of a class.

 	"reflect"
 	"regexp"
 	"runtime"
+	stdstrings "strings"
 	"unicode"
 	"unsafe"
 		return encFloat, nil
 	case reflect.Float64:
 		return encDouble, nil
-	case reflect.Ptr:
+	case reflect.Pointer:
 		enc, err := encodeType(typ.Elem(), true)
 		return encPtr + enc, err
 	case reflect.Struct:
 		if insidePtr {
 			return encStructBegin + typ.Name() + encStructEnd, nil
 		}
-		encoding := encStructBegin
+		var encoding stdstrings.Builder
-		encoding += typ.Name()
+		encoding.WriteString(encStructBegin)
-		encoding += "="
+		encoding.WriteString(typ.Name())
+		encoding.WriteString("=")
 		for i := 0; i < typ.NumField(); i++ {
 			f := typ.Field(i)
 			tmp, err := encodeType(f.Type, false)
 			if err != nil {
 				return "", err
 			}
-			encoding += tmp
+			encoding.WriteString(tmp)
 		}
-		encoding += encStructEnd
+		encoding.WriteString(encStructEnd)
-		return encoding, nil
+		return encoding.String(), nil
 	case reflect.UnsafePointer:
 		return encUnsafePtr, nil
 	case reflect.String:
 		return "", errors.New("not a func")
 	}
-	encoding := ""
+	var encoding stdstrings.Builder
 	switch typ.NumOut() {
 	case 0:
-		encoding += encVoid
+		encoding.WriteString(encVoid)
 	case 1:
 		tmp, err := encodeType(typ.Out(0), false)
 		if err != nil {
 			return "", err
 		}
-		encoding += tmp
+		encoding.WriteString(tmp)
 	default:
 		return "", errors.New("too many output parameters")
 	}
 		return "", errors.New("func doesn't take ID and SEL as its first two parameters")
 	}
-	encoding += encId
+	encoding.WriteString(encId)
 	for i := 1; i < typ.NumIn(); i++ {
 		tmp, err := encodeType(typ.In(i), false)
 		if err != nil {
 			return "", err
 		}
-		encoding += tmp
+		encoding.WriteString(tmp)
 	}
-	return encoding, nil
+	return encoding.String(), nil
 }
 // SuperClass returns the superclass of a class.

M struct_arm64.go +1 -1


@@ -190,7 +190,7 @@ func placeRegistersArm64(v reflect.Value, addFloat func(uintptr), addInt func(ui
190	190		shift = 0
191	191		flushed = true
192	192		class = _NO_CLASS
193		-	case reflect.Ptr, reflect.UnsafePointer:
	193	+	case reflect.Pointer, reflect.UnsafePointer:
194	194		addInt(f.Pointer())
195	195		shift = 0
196	196		flushed = true


@@ -190,7 +190,7 @@ func placeRegistersArm64(v reflect.Value, addFloat func(uintptr), addInt func(ui
190		shift = 0	190		shift = 0
191		flushed = true	191		flushed = true
192		class = _NO_CLASS	192		class = _NO_CLASS
193	-	case reflect.Ptr, reflect.UnsafePointer:	193	+	case reflect.Pointer, reflect.UnsafePointer:
194		addInt(f.Pointer())	194		addInt(f.Pointer())
195		shift = 0	195		shift = 0
196		flushed = true	196		flushed = true