3581026 Merge pull request #4 from bnema/fix/callback-trampoline · purego

M templates/glib +150 -0


@@ -187,6 +187,152 @@ func RemoveCallbackBySource(sourceID uint) {
187	callbacks.Unlock()	187		callbacks.Unlock()
188	}	188		}
189		189
		190	+	// ---------------------------------------------------------------------------
		191	+	// Source callback trampoline
		192	+	//
		193	+	// GLib source functions (IdleAdd, TimeoutAdd, etc.) previously allocated a new
		194	+	// purego callback slot for every invocation. purego has a hard limit of 2000
		195	+	// slots, so long-running programs that schedule many one-shot idle/timeout
		196	+	// callbacks would exhaust the pool and panic.
		197	+	//
		198	+	// The trampoline uses a single purego callback that dispatches through a
		199	+	// Go-side map keyed by an opaque ID passed as GLib's user_data pointer.
		200	+	// This means all IdleAdd/TimeoutAdd calls share ONE purego slot regardless
		201	+	// of how many are outstanding.
		202	+	// ---------------------------------------------------------------------------
		203	+
		204	+	// sourceEntry holds a registered GLib source callback.
		205	+	type sourceEntry struct {
		206	+	fn SourceFunc
		207	+	once bool // if true, automatically remove after first call (SourceOnceFunc semantics)
		208	+	}
		209	+
		210	+	var sourceTrampolines = struct {
		211	+	sync.Mutex
		212	+	nextID uintptr
		213	+	funcs map[uintptr]*sourceEntry
		214	+	sourceToDataID map[uint]uintptr // GLib source ID → trampoline data ID
		215	+	}{
		216	+	funcs: make(map[uintptr]*sourceEntry),
		217	+	sourceToDataID: make(map[uint]uintptr),
		218	+	}
		219	+
		220	+	// sourceTrampolineCb is the single purego callback shared by all source functions.
		221	+	// GLib calls it with the user_data we provided (our map key).
		222	+	var sourceTrampolineCb uintptr
		223	+
		224	+	// sourceTrampolineOnceCb is the single purego callback for SourceOnceFunc sources
		225	+	// (IdleAddOnce, TimeoutAddOnce). These have signature func(uintptr) with no return.
		226	+	var sourceTrampolineOnceCb uintptr
		227	+
		228	+	func initSourceTrampoline() {
		229	+	fn := func(id uintptr) uintptr {
		230	+	sourceTrampolines.Lock()
		231	+	entry, ok := sourceTrampolines.funcs[id]
		232	+	if !ok {
		233	+	sourceTrampolines.Unlock()
		234	+	return 0 // SOURCE_REMOVE — entry already cleaned up (e.g. by SourceRemove)
		235	+	}
		236	+	cb := entry.fn
		237	+	sourceTrampolines.Unlock()
		238	+
		239	+	result := cb(0)
		240	+
		241	+	if !result {
		242	+	sourceTrampolines.Lock()
		243	+	delete(sourceTrampolines.funcs, id)
		244	+	// Also clean up the reverse mapping (source ID → data ID).
		245	+	for sid, did := range sourceTrampolines.sourceToDataID {
		246	+	if did == id {
		247	+	delete(sourceTrampolines.sourceToDataID, sid)
		248	+	break
		249	+	}
		250	+	}
		251	+	sourceTrampolines.Unlock()
		252	+	}
		253	+	if result {
		254	+	return 1
		255	+	}
		256	+	return 0
		257	+	}
		258	+	sourceTrampolineCb = purego.NewCallback(fn)
		259	+
		260	+	onceFn := func(id uintptr) {
		261	+	sourceTrampolines.Lock()
		262	+	entry, ok := sourceTrampolines.funcs[id]
		263	+	if !ok {
		264	+	sourceTrampolines.Unlock()
		265	+	return
		266	+	}
		267	+	cb := entry.fn
		268	+	delete(sourceTrampolines.funcs, id)
		269	+	// Also clean up the reverse mapping.
		270	+	for sid, did := range sourceTrampolines.sourceToDataID {
		271	+	if did == id {
		272	+	delete(sourceTrampolines.sourceToDataID, sid)
		273	+	break
		274	+	}
		275	+	}
		276	+	sourceTrampolines.Unlock()
		277	+
		278	+	cb(0)
		279	+	}
		280	+	sourceTrampolineOnceCb = purego.NewCallback(onceFn)
		281	+	}
		282	+
		283	+	// registerSourceFunc stores a SourceFunc in the trampoline map and returns
		284	+	// the trampoline callback pointer and the user_data key.
		285	+	func registerSourceFunc(fn *SourceFunc, once bool) (trampolineCb uintptr, userData uintptr) {
		286	+	if fn == nil {
		287	+	return 0, 0
		288	+	}
		289	+	sourceTrampolines.Lock()
		290	+	sourceTrampolines.nextID++
		291	+	id := sourceTrampolines.nextID
		292	+	sourceTrampolines.funcs[id] = &sourceEntry{fn: *fn, once: once}
		293	+	sourceTrampolines.Unlock()
		294	+	if once {
		295	+	return sourceTrampolineOnceCb, id
		296	+	}
		297	+	return sourceTrampolineCb, id
		298	+	}
		299	+
		300	+	// registerSourceOnceFunc stores a SourceOnceFunc in the trampoline map and
		301	+	// returns the trampoline callback pointer and the user_data key.
		302	+	func registerSourceOnceFunc(fn *SourceOnceFunc) (trampolineCb uintptr, userData uintptr) {
		303	+	if fn == nil {
		304	+	return 0, 0
		305	+	}
		306	+	// Wrap SourceOnceFunc as SourceFunc so the entry type is uniform.
		307	+	wrapped := SourceFunc(func(data uintptr) bool {
		308	+	(*fn)(data)
		309	+	return false
		310	+	})
		311	+	return registerSourceFunc(&wrapped, true)
		312	+	}
		313	+
		314	+	// saveSourceTrampolineMapping records the GLib source ID → trampoline data ID
		315	+	// mapping so that SourceRemove can clean up the trampoline entry.
		316	+	func saveSourceTrampolineMapping(sourceID uint, dataID uintptr) {
		317	+	if sourceID == 0 {
		318	+	return
		319	+	}
		320	+	sourceTrampolines.Lock()
		321	+	sourceTrampolines.sourceToDataID[sourceID] = dataID
		322	+	sourceTrampolines.Unlock()
		323	+	}
		324	+
		325	+	// removeSourceTrampolineBySourceID cleans up trampoline state when a GLib
		326	+	// source is removed via SourceRemove (before the callback fires).
		327	+	func removeSourceTrampolineBySourceID(sourceID uint) {
		328	+	sourceTrampolines.Lock()
		329	+	if dataID, ok := sourceTrampolines.sourceToDataID[sourceID]; ok {
		330	+	delete(sourceTrampolines.sourceToDataID, sourceID)
		331	+	delete(sourceTrampolines.funcs, dataID)
		332	+	}
		333	+	sourceTrampolines.Unlock()
		334	+	}
		335	+
190	// UnrefCallbackValue unreferences the provided callback by reflect.value to free a purego slot	336		// UnrefCallbackValue unreferences the provided callback by reflect.value to free a purego slot
191	//	337		//
192	// NOTE: Windows does not support unreferencing callbacks, so on that platform this operation is	338		// NOTE: Windows does not support unreferencing callbacks, so on that platform this operation is

@@ -211,6 +357,10 @@ func NewCallbackNullable(fn interface{}) uintptr {
211	return NewCallback(fn)	357		return NewCallback(fn)
212	}	358		}
213		359
		360	+	func init() {
		361	+	initSourceTrampoline()
		362	+	}
		363	+
214	func (e *Error) Error() string {	364		func (e *Error) Error() string {
215	return fmt.Sprintf("Gtk reported an error with message: '%s', domain: '%v' and code: '%v'", e.MessageGo(), e.Domain, e.Code)	365		return fmt.Sprintf("Gtk reported an error with message: '%s', domain: '%v' and code: '%v'", e.MessageGo(), e.Domain, e.Code)
216	}	366		}

M templates/go +48 -5


@@ -289,23 +289,65 @@ const (
289		{{end}}	289		{{end}}
290			290
291		{{- define "glib_source_mapping_post_hook" -}}	291		{{- define "glib_source_mapping_post_hook" -}}
292	-	{{- if or (eq .Name "ChildWatchAdd") (eq .Name "ChildWatchAddFull") (eq .Name "IdleAdd") (eq .Name "IdleAddFull") (eq .Name "IdleAddOnce") (eq .Name "TimeoutAdd") (eq .Name "TimeoutAddFull") (eq .Name "TimeoutAddOnce") (eq .Name "TimeoutAddSeconds") (eq .Name "TimeoutAddSecondsFull") (eq .Name "TimeoutAddSecondsOnce")}}
293	-	if FunctionVar != nil {
294	-	SaveSourceMapping(cret, uintptr(unsafe.Pointer(FunctionVar)))
295	-	}
296	-	{{- end}}
297		{{- if eq .Name "SourceRemove"}}	292		{{- if eq .Name "SourceRemove"}}
298		if cret {	293		if cret {
299		RemoveCallbackBySource(TagVar)	294		RemoveCallbackBySource(TagVar)
			295	+	removeSourceTrampolineBySourceID(TagVar)
300		}	296		}
301		{{- end}}	297		{{- end}}
302		{{- end}}	298		{{- end}}
303			299
			300	+	{{- /* glib_source_trampoline_body emits the entire function body for IdleAdd/TimeoutAdd
			301	+	family functions. These use a shared purego trampoline callback instead of allocating
			302	+	a new purego callback slot per call. */ -}}
			303	+	{{- /* glib_source_trampoline_body emits the entire function body for IdleAdd/TimeoutAdd
			304	+	family functions. These use a shared purego trampoline callback instead of allocating
			305	+	a new purego callback slot per call. */ -}}
			306	+	{{- define "glib_source_trampoline_body" -}}
			307	+	{{- if or (eq .Name "IdleAdd") (eq .Name "TimeoutAdd") (eq .Name "TimeoutAddSeconds") -}}
			308	+	trampolineCb, userData := registerSourceFunc(FunctionVar, false)
			309	+	cret := x{{.Name}}({{- if or (eq .Name "TimeoutAdd") (eq .Name "TimeoutAddSeconds") -}}IntervalVar, {{end}}trampolineCb, userData)
			310	+	saveSourceTrampolineMapping(cret, userData)
			311	+	return cret
			312	+	{{- else if or (eq .Name "IdleAddOnce") (eq .Name "TimeoutAddOnce") (eq .Name "TimeoutAddSecondsOnce") -}}
			313	+	trampolineCb, userData := registerSourceOnceFunc(FunctionVar)
			314	+	cret := x{{.Name}}({{- if or (eq .Name "TimeoutAddOnce") (eq .Name "TimeoutAddSecondsOnce") -}}IntervalVar, {{end}}trampolineCb, userData)
			315	+	saveSourceTrampolineMapping(cret, userData)
			316	+	return cret
			317	+	{{- else if or (eq .Name "IdleAddFull") (eq .Name "TimeoutAddFull") (eq .Name "TimeoutAddSecondsFull") -}}
			318	+	trampolineCb, userData := registerSourceFunc(FunctionVar, false)
			319	+	{{range .Args.Callbacks -}}
			320	+	{{- if eq .Name "NotifyVar" -}}
			321	+	var {{.Name}}Ref uintptr
			322	+	if {{.Name}} != nil {
			323	+	{{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
			324	+	if cbRefPtr, ok := GetCallback({{.Name}}Ptr); ok {
			325	+	{{.Name}}Ref = cbRefPtr
			326	+	} else {
			327	+	fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
			328	+	cbFn := *{{.Name}}
			329	+	{{if .RetRaw}}return {{end}}cbFn({{range $i, $a := .CallArgs}}{{if $i}}, {{end}}{{$a}}{{end}})
			330	+	}
			331	+	{{.Name}}Ref = purego.NewCallback(fcb)
			332	+	SaveCallbackWithClosure({{.Name}}Ptr, {{.Name}}Ref, {{.Name}})
			333	+	}
			334	+	}
			335	+	{{- end}}
			336	+	{{- end}}
			337	+	cret := x{{.Name}}(PriorityVar, {{- if or (eq .Name "TimeoutAddFull") (eq .Name "TimeoutAddSecondsFull") -}}IntervalVar, {{end}}trampolineCb, userData, NotifyVarRef)
			338	+	saveSourceTrampolineMapping(cret, userData)
			339	+	return cret
			340	+	{{- end}}
			341	+	{{- end}}
			342	+
304		{{range .Functions -}}	343		{{range .Functions -}}
305		var x{{.Name}} func({{conv .Args.Pure.Types}}) {{.Ret.Raw}}	344		var x{{.Name}} func({{conv .Args.Pure.Types}}) {{.Ret.Raw}}
306			345
307		{{.Doc}}	346		{{.Doc}}
308		func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {	347		func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
			348	+	{{- if and (not $NotGLib) (or (eq .Name "IdleAdd") (eq .Name "IdleAddFull") (eq .Name "IdleAddOnce") (eq .Name "TimeoutAdd") (eq .Name "TimeoutAddFull") (eq .Name "TimeoutAddOnce") (eq .Name "TimeoutAddSeconds") (eq .Name "TimeoutAddSecondsFull") (eq .Name "TimeoutAddSecondsOnce"))}}
			349	+	{{template "glib_source_trampoline_body" .}}
			350	+	{{- else}}
309		{{.Ret.Preamble $NotGLib}}	351		{{.Ret.Preamble $NotGLib}}
310		{{range .Args.Callbacks}}	352		{{range .Args.Callbacks}}
311		var {{.Name}}Ref uintptr	353		var {{.Name}}Ref uintptr

@@ -332,6 +374,7 @@ func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
332		{{template "glib_source_mapping_post_hook" .}}	374		{{template "glib_source_mapping_post_hook" .}}
333		{{- end}}	375		{{- end}}
334		{{.Ret.Fmt $NotGObject}}	376		{{.Ret.Fmt $NotGObject}}
			377	+	{{- end}}
335		}	378		}
336		{{end}}	379		{{end}}
337			380

M v4/glib/garray.go +21 -0


@@ -387,6 +387,7 @@ var xArrayNewTake func(uintptr, uint, bool, uint) uintptr
387	func ArrayNewTake(DataVar uintptr, LenVar uint, ClearVar bool, ElementSizeVar uint) uintptr {	387		func ArrayNewTake(DataVar uintptr, LenVar uint, ClearVar bool, ElementSizeVar uint) uintptr {
388		388
389	cret := xArrayNewTake(DataVar, LenVar, ClearVar, ElementSizeVar)	389		cret := xArrayNewTake(DataVar, LenVar, ClearVar, ElementSizeVar)
		390	+
390	return cret	391		return cret
391	}	392		}
392		393

@@ -414,6 +415,7 @@ var xArrayNewTakeZeroTerminated func(uintptr, bool, uint) uintptr
414	func ArrayNewTakeZeroTerminated(DataVar uintptr, ClearVar bool, ElementSizeVar uint) uintptr {	415		func ArrayNewTakeZeroTerminated(DataVar uintptr, ClearVar bool, ElementSizeVar uint) uintptr {
415		416
416	cret := xArrayNewTakeZeroTerminated(DataVar, ClearVar, ElementSizeVar)	417		cret := xArrayNewTakeZeroTerminated(DataVar, ClearVar, ElementSizeVar)
		418	+
417	return cret	419		return cret
418	}	420		}
419		421

@@ -424,6 +426,7 @@ var xByteArrayAppend func([]byte, []byte, uint) uintptr
424	func ByteArrayAppend(ArrayVar []byte, DataVar []byte, LenVar uint) uintptr {	426		func ByteArrayAppend(ArrayVar []byte, DataVar []byte, LenVar uint) uintptr {
425		427
426	cret := xByteArrayAppend(ArrayVar, DataVar, LenVar)	428		cret := xByteArrayAppend(ArrayVar, DataVar, LenVar)
		429	+
427	return cret	430		return cret
428	}	431		}
429		432

@@ -436,6 +439,7 @@ var xByteArrayFree func([]byte, bool) uintptr
436	func ByteArrayFree(ArrayVar []byte, FreeSegmentVar bool) uintptr {	439		func ByteArrayFree(ArrayVar []byte, FreeSegmentVar bool) uintptr {
437		440
438	cret := xByteArrayFree(ArrayVar, FreeSegmentVar)	441		cret := xByteArrayFree(ArrayVar, FreeSegmentVar)
		442	+
439	return cret	443		return cret
440	}	444		}
441		445

@@ -453,6 +457,7 @@ var xByteArrayFreeToBytes func([]byte) *Bytes
453	func ByteArrayFreeToBytes(ArrayVar []byte) *Bytes {	457		func ByteArrayFreeToBytes(ArrayVar []byte) *Bytes {
454		458
455	cret := xByteArrayFreeToBytes(ArrayVar)	459		cret := xByteArrayFreeToBytes(ArrayVar)
		460	+
456	return cret	461		return cret
457	}	462		}
458		463

@@ -462,6 +467,7 @@ var xByteArrayNew func() uintptr
462	func ByteArrayNew() uintptr {	467		func ByteArrayNew() uintptr {
463		468
464	cret := xByteArrayNew()	469		cret := xByteArrayNew()
		470	+
465	return cret	471		return cret
466	}	472		}
467		473

@@ -478,6 +484,7 @@ var xByteArrayNewTake func([]byte, uint) uintptr
478	func ByteArrayNewTake(DataVar []byte, LenVar uint) uintptr {	484		func ByteArrayNewTake(DataVar []byte, LenVar uint) uintptr {
479		485
480	cret := xByteArrayNewTake(DataVar, LenVar)	486		cret := xByteArrayNewTake(DataVar, LenVar)
		487	+
481	return cret	488		return cret
482	}	489		}
483		490

@@ -488,6 +495,7 @@ var xByteArrayPrepend func([]byte, []byte, uint) uintptr
488	func ByteArrayPrepend(ArrayVar []byte, DataVar []byte, LenVar uint) uintptr {	495		func ByteArrayPrepend(ArrayVar []byte, DataVar []byte, LenVar uint) uintptr {
489		496
490	cret := xByteArrayPrepend(ArrayVar, DataVar, LenVar)	497		cret := xByteArrayPrepend(ArrayVar, DataVar, LenVar)
		498	+
491	return cret	499		return cret
492	}	500		}
493		501

@@ -498,6 +506,7 @@ var xByteArrayRef func([]byte) uintptr
498	func ByteArrayRef(ArrayVar []byte) uintptr {	506		func ByteArrayRef(ArrayVar []byte) uintptr {
499		507
500	cret := xByteArrayRef(ArrayVar)	508		cret := xByteArrayRef(ArrayVar)
		509	+
501	return cret	510		return cret
502	}	511		}
503		512

@@ -508,6 +517,7 @@ var xByteArrayRemoveIndex func([]byte, uint) uintptr
508	func ByteArrayRemoveIndex(ArrayVar []byte, IndexVar uint) uintptr {	517		func ByteArrayRemoveIndex(ArrayVar []byte, IndexVar uint) uintptr {
509		518
510	cret := xByteArrayRemoveIndex(ArrayVar, IndexVar)	519		cret := xByteArrayRemoveIndex(ArrayVar, IndexVar)
		520	+
511	return cret	521		return cret
512	}	522		}
513		523

@@ -520,6 +530,7 @@ var xByteArrayRemoveIndexFast func([]byte, uint) uintptr
520	func ByteArrayRemoveIndexFast(ArrayVar []byte, IndexVar uint) uintptr {	530		func ByteArrayRemoveIndexFast(ArrayVar []byte, IndexVar uint) uintptr {
521		531
522	cret := xByteArrayRemoveIndexFast(ArrayVar, IndexVar)	532		cret := xByteArrayRemoveIndexFast(ArrayVar, IndexVar)
		533	+
523	return cret	534		return cret
524	}	535		}
525		536

@@ -530,6 +541,7 @@ var xByteArrayRemoveRange func([]byte, uint, uint) uintptr
530	func ByteArrayRemoveRange(ArrayVar []byte, IndexVar uint, LengthVar uint) uintptr {	541		func ByteArrayRemoveRange(ArrayVar []byte, IndexVar uint, LengthVar uint) uintptr {
531		542
532	cret := xByteArrayRemoveRange(ArrayVar, IndexVar, LengthVar)	543		cret := xByteArrayRemoveRange(ArrayVar, IndexVar, LengthVar)
		544	+
533	return cret	545		return cret
534	}	546		}
535		547

@@ -539,6 +551,7 @@ var xByteArraySetSize func([]byte, uint) uintptr
539	func ByteArraySetSize(ArrayVar []byte, LengthVar uint) uintptr {	551		func ByteArraySetSize(ArrayVar []byte, LengthVar uint) uintptr {
540		552
541	cret := xByteArraySetSize(ArrayVar, LengthVar)	553		cret := xByteArraySetSize(ArrayVar, LengthVar)
		554	+
542	return cret	555		return cret
543	}	556		}
544		557

@@ -551,6 +564,7 @@ var xByteArraySizedNew func(uint) uintptr
551	func ByteArraySizedNew(ReservedSizeVar uint) uintptr {	564		func ByteArraySizedNew(ReservedSizeVar uint) uintptr {
552		565
553	cret := xByteArraySizedNew(ReservedSizeVar)	566		cret := xByteArraySizedNew(ReservedSizeVar)
		567	+
554	return cret	568		return cret
555	}	569		}
556		570

@@ -620,6 +634,7 @@ var xByteArraySteal func([]byte, *uint) uintptr
620	func ByteArraySteal(ArrayVar []byte, LenVar *uint) uintptr {	634		func ByteArraySteal(ArrayVar []byte, LenVar *uint) uintptr {
621		635
622	cret := xByteArraySteal(ArrayVar, LenVar)	636		cret := xByteArraySteal(ArrayVar, LenVar)
		637	+
623	return cret	638		return cret
624	}	639		}
625		640

@@ -648,6 +663,7 @@ var xPtrArrayFind func([]uintptr, uintptr, *uint) bool
648	func PtrArrayFind(HaystackVar []uintptr, NeedleVar uintptr, IndexVar *uint) bool {	663		func PtrArrayFind(HaystackVar []uintptr, NeedleVar uintptr, IndexVar *uint) bool {
649		664
650	cret := xPtrArrayFind(HaystackVar, NeedleVar, IndexVar)	665		cret := xPtrArrayFind(HaystackVar, NeedleVar, IndexVar)
		666	+
651	return cret	667		return cret
652	}	668		}
653		669

@@ -680,6 +696,7 @@ func PtrArrayFindWithEqualFunc(HaystackVar []uintptr, NeedleVar uintptr, EqualFu
680	}	696		}
681		697
682	cret := xPtrArrayFindWithEqualFunc(HaystackVar, NeedleVar, EqualFuncVarRef, IndexVar)	698		cret := xPtrArrayFindWithEqualFunc(HaystackVar, NeedleVar, EqualFuncVarRef, IndexVar)
		699	+
683	return cret	700		return cret
684	}	701		}
685		702

@@ -735,6 +752,7 @@ func PtrArrayNewFromArray(DataVar []uintptr, LenVar uint, CopyFuncVar *CopyFunc,
735	}	752		}
736		753
737	cret := xPtrArrayNewFromArray(DataVar, LenVar, CopyFuncVarRef, CopyFuncUserDataVar, ElementFreeFuncVarRef)	754		cret := xPtrArrayNewFromArray(DataVar, LenVar, CopyFuncVarRef, CopyFuncUserDataVar, ElementFreeFuncVarRef)
		755	+
738	return cret	756		return cret
739	}	757		}
740		758

@@ -786,6 +804,7 @@ func PtrArrayNewFromNullTerminatedArray(DataVar []uintptr, CopyFuncVar *CopyFunc
786	}	804		}
787		805
788	cret := xPtrArrayNewFromNullTerminatedArray(DataVar, CopyFuncVarRef, CopyFuncUserDataVar, ElementFreeFuncVarRef)	806		cret := xPtrArrayNewFromNullTerminatedArray(DataVar, CopyFuncVarRef, CopyFuncUserDataVar, ElementFreeFuncVarRef)
		807	+
789	return cret	808		return cret
790	}	809		}
791		810

@@ -825,6 +844,7 @@ func PtrArrayNewTake(DataVar []uintptr, LenVar uint, ElementFreeFuncVar *Destroy
825	}	844		}
826		845
827	cret := xPtrArrayNewTake(DataVar, LenVar, ElementFreeFuncVarRef)	846		cret := xPtrArrayNewTake(DataVar, LenVar, ElementFreeFuncVarRef)
		847	+
828	return cret	848		return cret
829	}	849		}
830		850

@@ -867,6 +887,7 @@ func PtrArrayNewTakeNullTerminated(DataVar []uintptr, ElementFreeFuncVar *Destro
867	}	887		}
868		888
869	cret := xPtrArrayNewTakeNullTerminated(DataVar, ElementFreeFuncVarRef)	889		cret := xPtrArrayNewTakeNullTerminated(DataVar, ElementFreeFuncVarRef)
		890	+
870	return cret	891		return cret
871	}	892		}
872		893

M v4/glib/gasyncqueue.go +2 -0


@@ -457,6 +457,7 @@ var xAsyncQueueNew func() *AsyncQueue
457	func AsyncQueueNew() *AsyncQueue {	457		func AsyncQueueNew() *AsyncQueue {
458		458
459	cret := xAsyncQueueNew()	459		cret := xAsyncQueueNew()
		460	+
460	return cret	461		return cret
461	}	462		}
462		463

@@ -483,6 +484,7 @@ func AsyncQueueNewFull(ItemFreeFuncVar DestroyNotify) AsyncQueue {
483	}	484		}
484		485
485	cret := xAsyncQueueNewFull(ItemFreeFuncVarRef)	486		cret := xAsyncQueueNewFull(ItemFreeFuncVarRef)
		487	+
486	return cret	488		return cret
487	}	489		}
488		490

M v4/glib/gatomic.go +18 -0


@@ -23,6 +23,7 @@ var xAtomicIntAdd func(uintptr, int) int
23	func AtomicIntAdd(AtomicVar uintptr, ValVar int) int {	23		func AtomicIntAdd(AtomicVar uintptr, ValVar int) int {
24		24
25	cret := xAtomicIntAdd(AtomicVar, ValVar)	25		cret := xAtomicIntAdd(AtomicVar, ValVar)
		26	+
26	return cret	27		return cret
27	}	28		}
28		29

@@ -41,6 +42,7 @@ var xAtomicIntAnd func(uintptr, uint) uint
41	func AtomicIntAnd(AtomicVar uintptr, ValVar uint) uint {	42		func AtomicIntAnd(AtomicVar uintptr, ValVar uint) uint {
42		43
43	cret := xAtomicIntAnd(AtomicVar, ValVar)	44		cret := xAtomicIntAnd(AtomicVar, ValVar)
		45	+
44	return cret	46		return cret
45	}	47		}
46		48

@@ -61,6 +63,7 @@ var xAtomicIntCompareAndExchange func(uintptr, int, int) bool
61	func AtomicIntCompareAndExchange(AtomicVar uintptr, OldvalVar int, NewvalVar int) bool {	63		func AtomicIntCompareAndExchange(AtomicVar uintptr, OldvalVar int, NewvalVar int) bool {
62		64
63	cret := xAtomicIntCompareAndExchange(AtomicVar, OldvalVar, NewvalVar)	65		cret := xAtomicIntCompareAndExchange(AtomicVar, OldvalVar, NewvalVar)
		66	+
64	return cret	67		return cret
65	}	68		}
66		69

@@ -81,6 +84,7 @@ var xAtomicIntCompareAndExchangeFull func(uintptr, int, int, *int) bool
81	func AtomicIntCompareAndExchangeFull(AtomicVar uintptr, OldvalVar int, NewvalVar int, PrevalVar *int) bool {	84		func AtomicIntCompareAndExchangeFull(AtomicVar uintptr, OldvalVar int, NewvalVar int, PrevalVar *int) bool {
82		85
83	cret := xAtomicIntCompareAndExchangeFull(AtomicVar, OldvalVar, NewvalVar, PrevalVar)	86		cret := xAtomicIntCompareAndExchangeFull(AtomicVar, OldvalVar, NewvalVar, PrevalVar)
		87	+
84	return cret	88		return cret
85	}	89		}
86		90

@@ -98,6 +102,7 @@ var xAtomicIntDecAndTest func(uintptr) bool
98	func AtomicIntDecAndTest(AtomicVar uintptr) bool {	102		func AtomicIntDecAndTest(AtomicVar uintptr) bool {
99		103
100	cret := xAtomicIntDecAndTest(AtomicVar)	104		cret := xAtomicIntDecAndTest(AtomicVar)
		105	+
101	return cret	106		return cret
102	}	107		}
103		108

@@ -114,6 +119,7 @@ var xAtomicIntExchange func(uintptr, int) int
114	func AtomicIntExchange(AtomicVar uintptr, NewvalVar int) int {	119		func AtomicIntExchange(AtomicVar uintptr, NewvalVar int) int {
115		120
116	cret := xAtomicIntExchange(AtomicVar, NewvalVar)	121		cret := xAtomicIntExchange(AtomicVar, NewvalVar)
		122	+
117	return cret	123		return cret
118	}	124		}
119		125

@@ -125,6 +131,7 @@ var xAtomicIntExchangeAndAdd func(uintptr, int) int
125	func AtomicIntExchangeAndAdd(AtomicVar uintptr, ValVar int) int {	131		func AtomicIntExchangeAndAdd(AtomicVar uintptr, ValVar int) int {
126		132
127	cret := xAtomicIntExchangeAndAdd(AtomicVar, ValVar)	133		cret := xAtomicIntExchangeAndAdd(AtomicVar, ValVar)
		134	+
128	return cret	135		return cret
129	}	136		}
130		137

@@ -140,6 +147,7 @@ var xAtomicIntGet func(uintptr) int
140	func AtomicIntGet(AtomicVar uintptr) int {	147		func AtomicIntGet(AtomicVar uintptr) int {
141		148
142	cret := xAtomicIntGet(AtomicVar)	149		cret := xAtomicIntGet(AtomicVar)
		150	+
143	return cret	151		return cret
144	}	152		}
145		153

@@ -174,6 +182,7 @@ var xAtomicIntOr func(uintptr, uint) uint
174	func AtomicIntOr(AtomicVar uintptr, ValVar uint) uint {	182		func AtomicIntOr(AtomicVar uintptr, ValVar uint) uint {
175		183
176	cret := xAtomicIntOr(AtomicVar, ValVar)	184		cret := xAtomicIntOr(AtomicVar, ValVar)
		185	+
177	return cret	186		return cret
178	}	187		}
179		188

@@ -207,6 +216,7 @@ var xAtomicIntXor func(uintptr, uint) uint
207	func AtomicIntXor(AtomicVar uintptr, ValVar uint) uint {	216		func AtomicIntXor(AtomicVar uintptr, ValVar uint) uint {
208		217
209	cret := xAtomicIntXor(AtomicVar, ValVar)	218		cret := xAtomicIntXor(AtomicVar, ValVar)
		219	+
210	return cret	220		return cret
211	}	221		}
212		222

@@ -228,6 +238,7 @@ var xAtomicPointerAdd func(uintptr, int) int
228	func AtomicPointerAdd(AtomicVar uintptr, ValVar int) int {	238		func AtomicPointerAdd(AtomicVar uintptr, ValVar int) int {
229		239
230	cret := xAtomicPointerAdd(AtomicVar, ValVar)	240		cret := xAtomicPointerAdd(AtomicVar, ValVar)
		241	+
231	return cret	242		return cret
232	}	243		}
233		244

@@ -250,6 +261,7 @@ var xAtomicPointerAnd func(uintptr, uint) uintptr
250	func AtomicPointerAnd(AtomicVar uintptr, ValVar uint) uintptr {	261		func AtomicPointerAnd(AtomicVar uintptr, ValVar uint) uintptr {
251		262
252	cret := xAtomicPointerAnd(AtomicVar, ValVar)	263		cret := xAtomicPointerAnd(AtomicVar, ValVar)
		264	+
253	return cret	265		return cret
254	}	266		}
255		267

@@ -270,6 +282,7 @@ var xAtomicPointerCompareAndExchange func(uintptr, uintptr, uintptr) bool
270	func AtomicPointerCompareAndExchange(AtomicVar uintptr, OldvalVar uintptr, NewvalVar uintptr) bool {	282		func AtomicPointerCompareAndExchange(AtomicVar uintptr, OldvalVar uintptr, NewvalVar uintptr) bool {
271		283
272	cret := xAtomicPointerCompareAndExchange(AtomicVar, OldvalVar, NewvalVar)	284		cret := xAtomicPointerCompareAndExchange(AtomicVar, OldvalVar, NewvalVar)
		285	+
273	return cret	286		return cret
274	}	287		}
275		288

@@ -290,6 +303,7 @@ var xAtomicPointerCompareAndExchangeFull func(uintptr, uintptr, uintptr, *uintpt
290	func AtomicPointerCompareAndExchangeFull(AtomicVar uintptr, OldvalVar uintptr, NewvalVar uintptr, PrevalVar *uintptr) bool {	303		func AtomicPointerCompareAndExchangeFull(AtomicVar uintptr, OldvalVar uintptr, NewvalVar uintptr, PrevalVar *uintptr) bool {
291		304
292	cret := xAtomicPointerCompareAndExchangeFull(AtomicVar, OldvalVar, NewvalVar, PrevalVar)	305		cret := xAtomicPointerCompareAndExchangeFull(AtomicVar, OldvalVar, NewvalVar, PrevalVar)
		306	+
293	return cret	307		return cret
294	}	308		}
295		309

@@ -306,6 +320,7 @@ var xAtomicPointerExchange func(uintptr, uintptr) uintptr
306	func AtomicPointerExchange(AtomicVar uintptr, NewvalVar uintptr) uintptr {	320		func AtomicPointerExchange(AtomicVar uintptr, NewvalVar uintptr) uintptr {
307		321
308	cret := xAtomicPointerExchange(AtomicVar, NewvalVar)	322		cret := xAtomicPointerExchange(AtomicVar, NewvalVar)
		323	+
309	return cret	324		return cret
310	}	325		}
311		326

@@ -321,6 +336,7 @@ var xAtomicPointerGet func(uintptr) uintptr
321	func AtomicPointerGet(AtomicVar uintptr) uintptr {	336		func AtomicPointerGet(AtomicVar uintptr) uintptr {
322		337
323	cret := xAtomicPointerGet(AtomicVar)	338		cret := xAtomicPointerGet(AtomicVar)
		339	+
324	return cret	340		return cret
325	}	341		}
326		342

@@ -343,6 +359,7 @@ var xAtomicPointerOr func(uintptr, uint) uintptr
343	func AtomicPointerOr(AtomicVar uintptr, ValVar uint) uintptr {	359		func AtomicPointerOr(AtomicVar uintptr, ValVar uint) uintptr {
344		360
345	cret := xAtomicPointerOr(AtomicVar, ValVar)	361		cret := xAtomicPointerOr(AtomicVar, ValVar)
		362	+
346	return cret	363		return cret
347	}	364		}
348		365

@@ -380,6 +397,7 @@ var xAtomicPointerXor func(uintptr, uint) uintptr
380	func AtomicPointerXor(AtomicVar uintptr, ValVar uint) uintptr {	397		func AtomicPointerXor(AtomicVar uintptr, ValVar uint) uintptr {
381		398
382	cret := xAtomicPointerXor(AtomicVar, ValVar)	399		cret := xAtomicPointerXor(AtomicVar, ValVar)
		400	+
383	return cret	401		return cret
384	}	402		}
385		403

M v4/glib/gbase64.go +6 -0


@@ -14,6 +14,7 @@ var xBase64Decode func(string, *uint) uintptr
14	func Base64Decode(TextVar string, OutLenVar *uint) uintptr {	14		func Base64Decode(TextVar string, OutLenVar *uint) uintptr {
15		15
16	cret := xBase64Decode(TextVar, OutLenVar)	16		cret := xBase64Decode(TextVar, OutLenVar)
		17	+
17	return cret	18		return cret
18	}	19		}
19		20

@@ -24,6 +25,7 @@ var xBase64DecodeInplace func([]byte, uint) byte
24	func Base64DecodeInplace(TextVar []byte, OutLenVar uint) byte {	25		func Base64DecodeInplace(TextVar []byte, OutLenVar uint) byte {
25		26
26	cret := xBase64DecodeInplace(TextVar, OutLenVar)	27		cret := xBase64DecodeInplace(TextVar, OutLenVar)
		28	+
27	return cret	29		return cret
28	}	30		}
29		31

@@ -40,6 +42,7 @@ var xBase64DecodeStep func([]byte, uint, *[]byte, int, uint) uint
40	func Base64DecodeStep(InVar []byte, LenVar uint, OutVar *[]byte, StateVar int, SaveVar uint) uint {	42		func Base64DecodeStep(InVar []byte, LenVar uint, OutVar *[]byte, StateVar int, SaveVar uint) uint {
41		43
42	cret := xBase64DecodeStep(InVar, LenVar, OutVar, StateVar, SaveVar)	44		cret := xBase64DecodeStep(InVar, LenVar, OutVar, StateVar, SaveVar)
		45	+
43	return cret	46		return cret
44	}	47		}
45		48

@@ -50,6 +53,7 @@ var xBase64Encode func([]byte, uint) string
50	func Base64Encode(DataVar []byte, LenVar uint) string {	53		func Base64Encode(DataVar []byte, LenVar uint) string {
51		54
52	cret := xBase64Encode(DataVar, LenVar)	55		cret := xBase64Encode(DataVar, LenVar)
		56	+
53	return cret	57		return cret
54	}	58		}
55		59

@@ -65,6 +69,7 @@ var xBase64EncodeClose func(bool, *[]byte, int, int) uint
65	func Base64EncodeClose(BreakLinesVar bool, OutVar *[]byte, StateVar int, SaveVar int) uint {	69		func Base64EncodeClose(BreakLinesVar bool, OutVar *[]byte, StateVar int, SaveVar int) uint {
66		70
67	cret := xBase64EncodeClose(BreakLinesVar, OutVar, StateVar, SaveVar)	71		cret := xBase64EncodeClose(BreakLinesVar, OutVar, StateVar, SaveVar)
		72	+
68	return cret	73		return cret
69	}	74		}
70		75

@@ -92,6 +97,7 @@ var xBase64EncodeStep func([]byte, uint, bool, *[]byte, int, int) uint
92	func Base64EncodeStep(InVar []byte, LenVar uint, BreakLinesVar bool, OutVar *[]byte, StateVar int, SaveVar int) uint {	97		func Base64EncodeStep(InVar []byte, LenVar uint, BreakLinesVar bool, OutVar *[]byte, StateVar int, SaveVar int) uint {
93		98
94	cret := xBase64EncodeStep(InVar, LenVar, BreakLinesVar, OutVar, StateVar, SaveVar)	99		cret := xBase64EncodeStep(InVar, LenVar, BreakLinesVar, OutVar, StateVar, SaveVar)
		100	+
95	return cret	101		return cret
96	}	102		}
97		103

M v4/glib/gbitlock.go +3 -0


@@ -59,6 +59,7 @@ var xBitTrylock func(uintptr, int) bool
59	func BitTrylock(AddressVar uintptr, LockBitVar int) bool {	59		func BitTrylock(AddressVar uintptr, LockBitVar int) bool {
60		60
61	cret := xBitTrylock(AddressVar, LockBitVar)	61		cret := xBitTrylock(AddressVar, LockBitVar)
		62	+
62	return cret	63		return cret
63	}	64		}
64		65

@@ -130,6 +131,7 @@ var xPointerBitLockMaskPtr func(uintptr, uint, bool, uintptr, uintptr) uintptr
130	func PointerBitLockMaskPtr(PtrVar uintptr, LockBitVar uint, SetVar bool, PreserveMaskVar uintptr, PreservePtrVar uintptr) uintptr {	131		func PointerBitLockMaskPtr(PtrVar uintptr, LockBitVar uint, SetVar bool, PreserveMaskVar uintptr, PreservePtrVar uintptr) uintptr {
131		132
132	cret := xPointerBitLockMaskPtr(PtrVar, LockBitVar, SetVar, PreserveMaskVar, PreservePtrVar)	133		cret := xPointerBitLockMaskPtr(PtrVar, LockBitVar, SetVar, PreserveMaskVar, PreservePtrVar)
		134	+
133	return cret	135		return cret
134	}	136		}
135		137

@@ -146,6 +148,7 @@ var xPointerBitTrylock func(uintptr, int) bool
146	func PointerBitTrylock(AddressVar uintptr, LockBitVar int) bool {	148		func PointerBitTrylock(AddressVar uintptr, LockBitVar int) bool {
147		149
148	cret := xPointerBitTrylock(AddressVar, LockBitVar)	150		cret := xPointerBitTrylock(AddressVar, LockBitVar)
		151	+
149	return cret	152		return cret
150	}	153		}
151		154

M v4/glib/gcharset.go +6 -0


@@ -32,6 +32,7 @@ var xGetCharset func(*string) bool
32	func GetCharset(CharsetVar *string) bool {	32		func GetCharset(CharsetVar *string) bool {
33		33
34	cret := xGetCharset(CharsetVar)	34		cret := xGetCharset(CharsetVar)
		35	+
35	return cret	36		return cret
36	}	37		}
37		38

@@ -41,6 +42,7 @@ var xGetCodeset func() string
41	func GetCodeset() string {	42		func GetCodeset() string {
42		43
43	cret := xGetCodeset()	44		cret := xGetCodeset()
		45	+
44	return cret	46		return cret
45	}	47		}
46		48

@@ -66,6 +68,7 @@ var xGetConsoleCharset func(*string) bool
66	func GetConsoleCharset(CharsetVar *string) bool {	68		func GetConsoleCharset(CharsetVar *string) bool {
67		69
68	cret := xGetConsoleCharset(CharsetVar)	70		cret := xGetConsoleCharset(CharsetVar)
		71	+
69	return cret	72		return cret
70	}	73		}
71		74

@@ -85,6 +88,7 @@ var xGetLanguageNames func() []string
85	func GetLanguageNames() []string {	88		func GetLanguageNames() []string {
86		89
87	cret := xGetLanguageNames()	90		cret := xGetLanguageNames()
		91	+
88	return cret	92		return cret
89	}	93		}
90		94

@@ -103,6 +107,7 @@ var xGetLanguageNamesWithCategory func(string) []string
103	func GetLanguageNamesWithCategory(CategoryNameVar string) []string {	107		func GetLanguageNamesWithCategory(CategoryNameVar string) []string {
104		108
105	cret := xGetLanguageNamesWithCategory(CategoryNameVar)	109		cret := xGetLanguageNamesWithCategory(CategoryNameVar)
		110	+
106	return cret	111		return cret
107	}	112		}
108		113

@@ -126,6 +131,7 @@ var xGetLocaleVariants func(string) []string
126	func GetLocaleVariants(LocaleVar string) []string {	131		func GetLocaleVariants(LocaleVar string) []string {
127		132
128	cret := xGetLocaleVariants(LocaleVar)	133		cret := xGetLocaleVariants(LocaleVar)
		134	+
129	return cret	135		return cret
130	}	136		}
131		137

M v4/glib/gchecksum.go +4 -0


@@ -155,6 +155,7 @@ var xChecksumTypeGetLength func(ChecksumType) int
155	func ChecksumTypeGetLength(ChecksumTypeVar ChecksumType) int {	155		func ChecksumTypeGetLength(ChecksumTypeVar ChecksumType) int {
156		156
157	cret := xChecksumTypeGetLength(ChecksumTypeVar)	157		cret := xChecksumTypeGetLength(ChecksumTypeVar)
		158	+
158	return cret	159		return cret
159	}	160		}
160		161

@@ -168,6 +169,7 @@ var xComputeChecksumForBytes func(ChecksumType, *Bytes) string
168	func ComputeChecksumForBytes(ChecksumTypeVar ChecksumType, DataVar *Bytes) string {	169		func ComputeChecksumForBytes(ChecksumTypeVar ChecksumType, DataVar *Bytes) string {
169		170
170	cret := xComputeChecksumForBytes(ChecksumTypeVar, DataVar)	171		cret := xComputeChecksumForBytes(ChecksumTypeVar, DataVar)
		172	+
171	return cret	173		return cret
172	}	174		}
173		175

@@ -181,6 +183,7 @@ var xComputeChecksumForData func(ChecksumType, []byte, uint) string
181	func ComputeChecksumForData(ChecksumTypeVar ChecksumType, DataVar []byte, LengthVar uint) string {	183		func ComputeChecksumForData(ChecksumTypeVar ChecksumType, DataVar []byte, LengthVar uint) string {
182		184
183	cret := xComputeChecksumForData(ChecksumTypeVar, DataVar, LengthVar)	185		cret := xComputeChecksumForData(ChecksumTypeVar, DataVar, LengthVar)
		186	+
184	return cret	187		return cret
185	}	188		}
186		189

@@ -192,6 +195,7 @@ var xComputeChecksumForString func(ChecksumType, string, int) string
192	func ComputeChecksumForString(ChecksumTypeVar ChecksumType, StrVar string, LengthVar int) string {	195		func ComputeChecksumForString(ChecksumTypeVar ChecksumType, StrVar string, LengthVar int) string {
193		196
194	cret := xComputeChecksumForString(ChecksumTypeVar, StrVar, LengthVar)	197		cret := xComputeChecksumForString(ChecksumTypeVar, StrVar, LengthVar)
		198	+
195	return cret	199		return cret
196	}	200		}
197		201

M v4/glib/gconvert.go +15 -0


@@ -107,6 +107,7 @@ func Convert(StrVar []byte, LenVar int, ToCodesetVar string, FromCodesetVar stri
107	var cerr *Error	107		var cerr *Error
108		108
109	cret := xConvert(StrVar, LenVar, ToCodesetVar, FromCodesetVar, BytesReadVar, BytesWrittenVar, &cerr)	109		cret := xConvert(StrVar, LenVar, ToCodesetVar, FromCodesetVar, BytesReadVar, BytesWrittenVar, &cerr)
		110	+
110	if cerr == nil {	111		if cerr == nil {
111	return cret, nil	112		return cret, nil
112	}	113		}

@@ -137,6 +138,7 @@ func ConvertWithFallback(StrVar []byte, LenVar int, ToCodesetVar string, FromCod
137	var cerr *Error	138		var cerr *Error
138		139
139	cret := xConvertWithFallback(StrVar, LenVar, ToCodesetVar, FromCodesetVar, FallbackVar, BytesReadVar, BytesWrittenVar, &cerr)	140		cret := xConvertWithFallback(StrVar, LenVar, ToCodesetVar, FromCodesetVar, FallbackVar, BytesReadVar, BytesWrittenVar, &cerr)
		141	+
140	if cerr == nil {	142		if cerr == nil {
141	return cret, nil	143		return cret, nil
142	}	144		}

@@ -169,6 +171,7 @@ func ConvertWithIconv(StrVar []byte, LenVar int, ConverterVar uintptr, BytesRead
169	var cerr *Error	171		var cerr *Error
170		172
171	cret := xConvertWithIconv(StrVar, LenVar, ConverterVar, BytesReadVar, BytesWrittenVar, &cerr)	173		cret := xConvertWithIconv(StrVar, LenVar, ConverterVar, BytesReadVar, BytesWrittenVar, &cerr)
		174	+
172	if cerr == nil {	175		if cerr == nil {
173	return cret, nil	176		return cret, nil
174	}	177		}

@@ -197,6 +200,7 @@ var xFilenameDisplayBasename func(string) string
197	func FilenameDisplayBasename(FilenameVar string) string {	200		func FilenameDisplayBasename(FilenameVar string) string {
198		201
199	cret := xFilenameDisplayBasename(FilenameVar)	202		cret := xFilenameDisplayBasename(FilenameVar)
		203	+
200	return cret	204		return cret
201	}	205		}
202		206

@@ -220,6 +224,7 @@ var xFilenameDisplayName func(string) string
220	func FilenameDisplayName(FilenameVar string) string {	224		func FilenameDisplayName(FilenameVar string) string {
221		225
222	cret := xFilenameDisplayName(FilenameVar)	226		cret := xFilenameDisplayName(FilenameVar)
		227	+
223	return cret	228		return cret
224	}	229		}
225		230

@@ -236,6 +241,7 @@ func FilenameFromUri(UriVar string, HostnameVar *string) (string, error) {
236	var cerr *Error	241		var cerr *Error
237		242
238	cret := xFilenameFromUri(UriVar, HostnameVar, &cerr)	243		cret := xFilenameFromUri(UriVar, HostnameVar, &cerr)
		244	+
239	if cerr == nil {	245		if cerr == nil {
240	return cret, nil	246		return cret, nil
241	}	247		}

@@ -259,6 +265,7 @@ func FilenameFromUtf8(Utf8stringVar string, LenVar int, BytesReadVar *uint, Byte
259	var cerr *Error	265		var cerr *Error
260		266
261	cret := xFilenameFromUtf8(Utf8stringVar, LenVar, BytesReadVar, BytesWrittenVar, &cerr)	267		cret := xFilenameFromUtf8(Utf8stringVar, LenVar, BytesReadVar, BytesWrittenVar, &cerr)
		268	+
262	if cerr == nil {	269		if cerr == nil {
263	return cret, nil	270		return cret, nil
264	}	271		}

@@ -277,6 +284,7 @@ func FilenameToUri(FilenameVar string, HostnameVar *string) (string, error) {
277	defer core.GFreeNullable(HostnameVarPtr)	284		defer core.GFreeNullable(HostnameVarPtr)
278		285
279	cret := xFilenameToUri(FilenameVar, HostnameVarPtr, &cerr)	286		cret := xFilenameToUri(FilenameVar, HostnameVarPtr, &cerr)
		287	+
280	if cerr == nil {	288		if cerr == nil {
281	return cret, nil	289		return cret, nil
282	}	290		}

@@ -302,6 +310,7 @@ func FilenameToUtf8(OpsysstringVar string, LenVar int, BytesReadVar *uint, Bytes
302	var cerr *Error	310		var cerr *Error
303		311
304	cret := xFilenameToUtf8(OpsysstringVar, LenVar, BytesReadVar, BytesWrittenVar, &cerr)	312		cret := xFilenameToUtf8(OpsysstringVar, LenVar, BytesReadVar, BytesWrittenVar, &cerr)
		313	+
305	if cerr == nil {	314		if cerr == nil {
306	return cret, nil	315		return cret, nil
307	}	316		}

@@ -338,6 +347,7 @@ var xGetFilenameCharsets func(*[]string) bool
338	func GetFilenameCharsets(FilenameCharsetsVar *[]string) bool {	347		func GetFilenameCharsets(FilenameCharsetsVar *[]string) bool {
339		348
340	cret := xGetFilenameCharsets(FilenameCharsetsVar)	349		cret := xGetFilenameCharsets(FilenameCharsetsVar)
		350	+
341	return cret	351		return cret
342	}	352		}
343		353

@@ -362,6 +372,7 @@ var xIconv func(uintptr, string, uint, string, uint) uint
362	func Iconv(ConverterVar uintptr, InbufVar string, InbytesLeftVar uint, OutbufVar string, OutbytesLeftVar uint) uint {	372		func Iconv(ConverterVar uintptr, InbufVar string, InbytesLeftVar uint, OutbufVar string, OutbytesLeftVar uint) uint {
363		373
364	cret := xIconv(ConverterVar, InbufVar, InbytesLeftVar, OutbufVar, OutbytesLeftVar)	374		cret := xIconv(ConverterVar, InbufVar, InbytesLeftVar, OutbufVar, OutbytesLeftVar)
		375	+
365	return cret	376		return cret
366	}	377		}
367		378

@@ -376,6 +387,7 @@ var xIconvOpen func(string, string) uintptr
376	func IconvOpen(ToCodesetVar string, FromCodesetVar string) uintptr {	387		func IconvOpen(ToCodesetVar string, FromCodesetVar string) uintptr {
377		388
378	cret := xIconvOpen(ToCodesetVar, FromCodesetVar)	389		cret := xIconvOpen(ToCodesetVar, FromCodesetVar)
		390	+
379	return cret	391		return cret
380	}	392		}
381		393

@@ -394,6 +406,7 @@ func LocaleFromUtf8(Utf8stringVar string, LenVar int, BytesReadVar *uint, BytesW
394	var cerr *Error	406		var cerr *Error
395		407
396	cret := xLocaleFromUtf8(Utf8stringVar, LenVar, BytesReadVar, BytesWrittenVar, &cerr)	408		cret := xLocaleFromUtf8(Utf8stringVar, LenVar, BytesReadVar, BytesWrittenVar, &cerr)
		409	+
397	if cerr == nil {	410		if cerr == nil {
398	return cret, nil	411		return cret, nil
399	}	412		}

@@ -418,6 +431,7 @@ func LocaleToUtf8(OpsysstringVar []byte, LenVar int, BytesReadVar *uint, BytesWr
418	var cerr *Error	431		var cerr *Error
419		432
420	cret := xLocaleToUtf8(OpsysstringVar, LenVar, BytesReadVar, BytesWrittenVar, &cerr)	433		cret := xLocaleToUtf8(OpsysstringVar, LenVar, BytesReadVar, BytesWrittenVar, &cerr)
		434	+
421	if cerr == nil {	435		if cerr == nil {
422	return cret, nil	436		return cret, nil
423	}	437		}

@@ -433,6 +447,7 @@ var xUriListExtractUris func(string) []string
433	func UriListExtractUris(UriListVar string) []string {	447		func UriListExtractUris(UriListVar string) []string {
434		448
435	cret := xUriListExtractUris(UriListVar)	449		cret := xUriListExtractUris(UriListVar)
		450	+
436	return cret	451		return cret
437	}	452		}
438		453

M v4/glib/gdataset.go +8 -0


@@ -89,6 +89,7 @@ var xDatalistGetData func(**Data, string) uintptr
89	func DatalistGetData(DatalistVar **Data, KeyVar string) uintptr {	89		func DatalistGetData(DatalistVar **Data, KeyVar string) uintptr {
90		90
91	cret := xDatalistGetData(DatalistVar, KeyVar)	91		cret := xDatalistGetData(DatalistVar, KeyVar)
		92	+
92	return cret	93		return cret
93	}	94		}
94		95

@@ -99,6 +100,7 @@ var xDatalistGetFlags func(**Data) uint
99	func DatalistGetFlags(DatalistVar **Data) uint {	100		func DatalistGetFlags(DatalistVar **Data) uint {
100		101
101	cret := xDatalistGetFlags(DatalistVar)	102		cret := xDatalistGetFlags(DatalistVar)
		103	+
102	return cret	104		return cret
103	}	105		}
104		106

@@ -135,6 +137,7 @@ func DatalistIdDupData(DatalistVar *Data, KeyIdVar Quark, DupFuncVar Duplicate
135	}	137		}
136		138
137	cret := xDatalistIdDupData(DatalistVar, KeyIdVar, DupFuncVarRef, UserDataVar)	139		cret := xDatalistIdDupData(DatalistVar, KeyIdVar, DupFuncVarRef, UserDataVar)
		140	+
138	return cret	141		return cret
139	}	142		}
140		143

@@ -144,6 +147,7 @@ var xDatalistIdGetData func(**Data, Quark) uintptr
144	func DatalistIdGetData(DatalistVar **Data, KeyIdVar Quark) uintptr {	147		func DatalistIdGetData(DatalistVar **Data, KeyIdVar Quark) uintptr {
145		148
146	cret := xDatalistIdGetData(DatalistVar, KeyIdVar)	149		cret := xDatalistIdGetData(DatalistVar, KeyIdVar)
		150	+
147	return cret	151		return cret
148	}	152		}
149		153

@@ -169,6 +173,7 @@ var xDatalistIdRemoveNoNotify func(**Data, Quark) uintptr
169	func DatalistIdRemoveNoNotify(DatalistVar **Data, KeyIdVar Quark) uintptr {	173		func DatalistIdRemoveNoNotify(DatalistVar **Data, KeyIdVar Quark) uintptr {
170		174
171	cret := xDatalistIdRemoveNoNotify(DatalistVar, KeyIdVar)	175		cret := xDatalistIdRemoveNoNotify(DatalistVar, KeyIdVar)
		176	+
172	return cret	177		return cret
173	}	178		}
174		179

@@ -205,6 +210,7 @@ func DatalistIdReplaceData(DatalistVar **Data, KeyIdVar Quark, OldvalVar uintptr
205	}	210		}
206		211
207	cret := xDatalistIdReplaceData(DatalistVar, KeyIdVar, OldvalVar, NewvalVar, DestroyVarRef, OldDestroyVar)	212		cret := xDatalistIdReplaceData(DatalistVar, KeyIdVar, OldvalVar, NewvalVar, DestroyVarRef, OldDestroyVar)
		213	+
208	return cret	214		return cret
209	}	215		}
210		216

@@ -315,6 +321,7 @@ var xDatasetIdGetData func(uintptr, Quark) uintptr
315	func DatasetIdGetData(DatasetLocationVar uintptr, KeyIdVar Quark) uintptr {	321		func DatasetIdGetData(DatasetLocationVar uintptr, KeyIdVar Quark) uintptr {
316		322
317	cret := xDatasetIdGetData(DatasetLocationVar, KeyIdVar)	323		cret := xDatasetIdGetData(DatasetLocationVar, KeyIdVar)
		324	+
318	return cret	325		return cret
319	}	326		}
320		327

@@ -325,6 +332,7 @@ var xDatasetIdRemoveNoNotify func(uintptr, Quark) uintptr
325	func DatasetIdRemoveNoNotify(DatasetLocationVar uintptr, KeyIdVar Quark) uintptr {	332		func DatasetIdRemoveNoNotify(DatasetLocationVar uintptr, KeyIdVar Quark) uintptr {
326		333
327	cret := xDatasetIdRemoveNoNotify(DatasetLocationVar, KeyIdVar)	334		cret := xDatasetIdRemoveNoNotify(DatasetLocationVar, KeyIdVar)
		335	+
328	return cret	336		return cret
329	}	337		}
330		338

M v4/glib/gdate.go +12 -0


@@ -647,6 +647,7 @@ var xDateGetDaysInMonth func(DateMonth, DateYear) byte
647	func DateGetDaysInMonth(MonthVar DateMonth, YearVar DateYear) byte {	647		func DateGetDaysInMonth(MonthVar DateMonth, YearVar DateYear) byte {
648		648
649	cret := xDateGetDaysInMonth(MonthVar, YearVar)	649		cret := xDateGetDaysInMonth(MonthVar, YearVar)
		650	+
650	return cret	651		return cret
651	}	652		}
652		653

@@ -662,6 +663,7 @@ var xDateGetMondayWeeksInYear func(DateYear) byte
662	func DateGetMondayWeeksInYear(YearVar DateYear) byte {	663		func DateGetMondayWeeksInYear(YearVar DateYear) byte {
663		664
664	cret := xDateGetMondayWeeksInYear(YearVar)	665		cret := xDateGetMondayWeeksInYear(YearVar)
		666	+
665	return cret	667		return cret
666	}	668		}
667		669

@@ -677,6 +679,7 @@ var xDateGetSundayWeeksInYear func(DateYear) byte
677	func DateGetSundayWeeksInYear(YearVar DateYear) byte {	679		func DateGetSundayWeeksInYear(YearVar DateYear) byte {
678		680
679	cret := xDateGetSundayWeeksInYear(YearVar)	681		cret := xDateGetSundayWeeksInYear(YearVar)
		682	+
680	return cret	683		return cret
681	}	684		}
682		685

@@ -694,6 +697,7 @@ var xDateGetWeeksInYear func(DateYear, DateWeekday) byte
694	func DateGetWeeksInYear(YearVar DateYear, FirstDayOfWeekVar DateWeekday) byte {	697		func DateGetWeeksInYear(YearVar DateYear, FirstDayOfWeekVar DateWeekday) byte {
695		698
696	cret := xDateGetWeeksInYear(YearVar, FirstDayOfWeekVar)	699		cret := xDateGetWeeksInYear(YearVar, FirstDayOfWeekVar)
		700	+
697	return cret	701		return cret
698	}	702		}
699		703

@@ -708,6 +712,7 @@ var xDateIsLeapYear func(DateYear) bool
708	func DateIsLeapYear(YearVar DateYear) bool {	712		func DateIsLeapYear(YearVar DateYear) bool {
709		713
710	cret := xDateIsLeapYear(YearVar)	714		cret := xDateIsLeapYear(YearVar)
		715	+
711	return cret	716		return cret
712	}	717		}
713		718

@@ -729,6 +734,7 @@ var xDateStrftime func(string, uint, string, *Date) uint
729	func DateStrftime(SVar string, SlenVar uint, FormatVar string, DateVar *Date) uint {	734		func DateStrftime(SVar string, SlenVar uint, FormatVar string, DateVar *Date) uint {
730		735
731	cret := xDateStrftime(SVar, SlenVar, FormatVar, DateVar)	736		cret := xDateStrftime(SVar, SlenVar, FormatVar, DateVar)
		737	+
732	return cret	738		return cret
733	}	739		}
734		740

@@ -739,6 +745,7 @@ var xDateValidDay func(DateDay) bool
739	func DateValidDay(DayVar DateDay) bool {	745		func DateValidDay(DayVar DateDay) bool {
740		746
741	cret := xDateValidDay(DayVar)	747		cret := xDateValidDay(DayVar)
		748	+
742	return cret	749		return cret
743	}	750		}
744		751

@@ -750,6 +757,7 @@ var xDateValidDmy func(DateDay, DateMonth, DateYear) bool
750	func DateValidDmy(DayVar DateDay, MonthVar DateMonth, YearVar DateYear) bool {	757		func DateValidDmy(DayVar DateDay, MonthVar DateMonth, YearVar DateYear) bool {
751		758
752	cret := xDateValidDmy(DayVar, MonthVar, YearVar)	759		cret := xDateValidDmy(DayVar, MonthVar, YearVar)
		760	+
753	return cret	761		return cret
754	}	762		}
755		763

@@ -760,6 +768,7 @@ var xDateValidJulian func(uint32) bool
760	func DateValidJulian(JulianDateVar uint32) bool {	768		func DateValidJulian(JulianDateVar uint32) bool {
761		769
762	cret := xDateValidJulian(JulianDateVar)	770		cret := xDateValidJulian(JulianDateVar)
		771	+
763	return cret	772		return cret
764	}	773		}
765		774

@@ -770,6 +779,7 @@ var xDateValidMonth func(DateMonth) bool
770	func DateValidMonth(MonthVar DateMonth) bool {	779		func DateValidMonth(MonthVar DateMonth) bool {
771		780
772	cret := xDateValidMonth(MonthVar)	781		cret := xDateValidMonth(MonthVar)
		782	+
773	return cret	783		return cret
774	}	784		}
775		785

@@ -780,6 +790,7 @@ var xDateValidWeekday func(DateWeekday) bool
780	func DateValidWeekday(WeekdayVar DateWeekday) bool {	790		func DateValidWeekday(WeekdayVar DateWeekday) bool {
781		791
782	cret := xDateValidWeekday(WeekdayVar)	792		cret := xDateValidWeekday(WeekdayVar)
		793	+
783	return cret	794		return cret
784	}	795		}
785		796

@@ -790,6 +801,7 @@ var xDateValidYear func(DateYear) bool
790	func DateValidYear(YearVar DateYear) bool {	801		func DateValidYear(YearVar DateYear) bool {
791		802
792	cret := xDateValidYear(YearVar)	803		cret := xDateValidYear(YearVar)
		804	+
793	return cret	805		return cret
794	}	806		}
795		807

M v4/glib/genviron.go +7 -0


@@ -13,6 +13,7 @@ var xEnvironGetenv func([]string, string) string
13	func EnvironGetenv(EnvpVar []string, VariableVar string) string {	13		func EnvironGetenv(EnvpVar []string, VariableVar string) string {
14		14
15	cret := xEnvironGetenv(EnvpVar, VariableVar)	15		cret := xEnvironGetenv(EnvpVar, VariableVar)
		16	+
16	return cret	17		return cret
17	}	18		}
18		19

@@ -23,6 +24,7 @@ var xEnvironSetenv func([]string, string, string, bool) []string
23	func EnvironSetenv(EnvpVar []string, VariableVar string, ValueVar string, OverwriteVar bool) []string {	24		func EnvironSetenv(EnvpVar []string, VariableVar string, ValueVar string, OverwriteVar bool) []string {
24		25
25	cret := xEnvironSetenv(EnvpVar, VariableVar, ValueVar, OverwriteVar)	26		cret := xEnvironSetenv(EnvpVar, VariableVar, ValueVar, OverwriteVar)
		27	+
26	return cret	28		return cret
27	}	29		}
28		30

@@ -33,6 +35,7 @@ var xEnvironUnsetenv func([]string, string) []string
33	func EnvironUnsetenv(EnvpVar []string, VariableVar string) []string {	35		func EnvironUnsetenv(EnvpVar []string, VariableVar string) []string {
34		36
35	cret := xEnvironUnsetenv(EnvpVar, VariableVar)	37		cret := xEnvironUnsetenv(EnvpVar, VariableVar)
		38	+
36	return cret	39		return cret
37	}	40		}
38		41

@@ -51,6 +54,7 @@ var xGetEnviron func() []string
51	func GetEnviron() []string {	54		func GetEnviron() []string {
52		55
53	cret := xGetEnviron()	56		cret := xGetEnviron()
		57	+
54	return cret	58		return cret
55	}	59		}
56		60

@@ -66,6 +70,7 @@ var xGetenv func(string) string
66	func Getenv(VariableVar string) string {	70		func Getenv(VariableVar string) string {
67		71
68	cret := xGetenv(VariableVar)	72		cret := xGetenv(VariableVar)
		73	+
69	return cret	74		return cret
70	}	75		}
71		76

@@ -82,6 +87,7 @@ var xListenv func() []string
82	func Listenv() []string {	87		func Listenv() []string {
83		88
84	cret := xListenv()	89		cret := xListenv()
		90	+
85	return cret	91		return cret
86	}	92		}
87		93

@@ -109,6 +115,7 @@ var xSetenv func(string, string, bool) bool
109	func Setenv(VariableVar string, ValueVar string, OverwriteVar bool) bool {	115		func Setenv(VariableVar string, ValueVar string, OverwriteVar bool) bool {
110		116
111	cret := xSetenv(VariableVar, ValueVar, OverwriteVar)	117		cret := xSetenv(VariableVar, ValueVar, OverwriteVar)
		118	+
112	return cret	119		return cret
113	}	120		}
114		121

M v4/glib/gerror.go +3 -0


@@ -135,6 +135,7 @@ func ClearError() error {
135	var cerr *Error	135		var cerr *Error
136		136
137	xClearError()	137		xClearError()
		138	+
138	if cerr == nil {	139		if cerr == nil {
139	return nil	140		return nil
140	}	141		}

@@ -195,6 +196,7 @@ func ErrorDomainRegister(ErrorTypeNameVar string, ErrorTypePrivateSizeVar uint,
195	}	196		}
196		197
197	cret := xErrorDomainRegister(ErrorTypeNameVar, ErrorTypePrivateSizeVar, ErrorTypeInitVarRef, ErrorTypeCopyVarRef, ErrorTypeClearVarRef)	198		cret := xErrorDomainRegister(ErrorTypeNameVar, ErrorTypePrivateSizeVar, ErrorTypeInitVarRef, ErrorTypeCopyVarRef, ErrorTypeClearVarRef)
		199	+
198	return cret	200		return cret
199	}	201		}
200		202

@@ -265,6 +267,7 @@ func ErrorDomainRegisterStatic(ErrorTypeNameVar string, ErrorTypePrivateSizeVar
265	}	267		}
266		268
267	cret := xErrorDomainRegisterStatic(ErrorTypeNameVar, ErrorTypePrivateSizeVar, ErrorTypeInitVarRef, ErrorTypeCopyVarRef, ErrorTypeClearVarRef)	269		cret := xErrorDomainRegisterStatic(ErrorTypeNameVar, ErrorTypePrivateSizeVar, ErrorTypeInitVarRef, ErrorTypeCopyVarRef, ErrorTypeClearVarRef)
		270	+
268	return cret	271		return cret
269	}	272		}
270		273

M v4/glib/gfileutils.go +25 -0


@@ -172,6 +172,7 @@ var xBasename func(string) string
172	func Basename(FileNameVar string) string {	172		func Basename(FileNameVar string) string {
173		173
174	cret := xBasename(FileNameVar)	174		cret := xBasename(FileNameVar)
		175	+
175	return cret	176		return cret
176	}	177		}
177		178

@@ -198,6 +199,7 @@ var xBuildFilename func(string, ...interface{}) string
198	func BuildFilename(FirstElementVar string, varArgs ...interface{}) string {	199		func BuildFilename(FirstElementVar string, varArgs ...interface{}) string {
199		200
200	cret := xBuildFilename(FirstElementVar, varArgs...)	201		cret := xBuildFilename(FirstElementVar, varArgs...)
		202	+
201	return cret	203		return cret
202	}	204		}
203		205

@@ -214,6 +216,7 @@ var xBuildFilenameValist func(string, []interface{}) string
214	func BuildFilenameValist(FirstElementVar string, ArgsVar []interface{}) string {	216		func BuildFilenameValist(FirstElementVar string, ArgsVar []interface{}) string {
215		217
216	cret := xBuildFilenameValist(FirstElementVar, ArgsVar)	218		cret := xBuildFilenameValist(FirstElementVar, ArgsVar)
		219	+
217	return cret	220		return cret
218	}	221		}
219		222

@@ -231,6 +234,7 @@ var xBuildFilenamev func([]string) string
231	func BuildFilenamev(ArgsVar []string) string {	234		func BuildFilenamev(ArgsVar []string) string {
232		235
233	cret := xBuildFilenamev(ArgsVar)	236		cret := xBuildFilenamev(ArgsVar)
		237	+
234	return cret	238		return cret
235	}	239		}
236		240

@@ -267,6 +271,7 @@ var xBuildPath func(string, string, ...interface{}) string
267	func BuildPath(SeparatorVar string, FirstElementVar string, varArgs ...interface{}) string {	271		func BuildPath(SeparatorVar string, FirstElementVar string, varArgs ...interface{}) string {
268		272
269	cret := xBuildPath(SeparatorVar, FirstElementVar, varArgs...)	273		cret := xBuildPath(SeparatorVar, FirstElementVar, varArgs...)
		274	+
270	return cret	275		return cret
271	}	276		}
272		277

@@ -279,6 +284,7 @@ var xBuildPathv func(string, []string) string
279	func BuildPathv(SeparatorVar string, ArgsVar []string) string {	284		func BuildPathv(SeparatorVar string, ArgsVar []string) string {
280		285
281	cret := xBuildPathv(SeparatorVar, ArgsVar)	286		cret := xBuildPathv(SeparatorVar, ArgsVar)
		287	+
282	return cret	288		return cret
283	}	289		}
284		290

@@ -304,6 +310,7 @@ func CanonicalizeFilename(FilenameVar string, RelativeToVar *string) string {
304	defer core.GFreeNullable(RelativeToVarPtr)	310		defer core.GFreeNullable(RelativeToVarPtr)
305		311
306	cret := xCanonicalizeFilename(FilenameVar, RelativeToVarPtr)	312		cret := xCanonicalizeFilename(FilenameVar, RelativeToVarPtr)
		313	+
307	return cret	314		return cret
308	}	315		}
309		316

@@ -327,6 +334,7 @@ func DirMakeTmp(TmplVar *string) (string, error) {
327	defer core.GFreeNullable(TmplVarPtr)	334		defer core.GFreeNullable(TmplVarPtr)
328		335
329	cret := xDirMakeTmp(TmplVarPtr, &cerr)	336		cret := xDirMakeTmp(TmplVarPtr, &cerr)
		337	+
330	if cerr == nil {	338		if cerr == nil {
331	return cret, nil	339		return cret, nil
332	}	340		}

@@ -348,6 +356,7 @@ var xFileErrorFromErrno func(int) FileError
348	func FileErrorFromErrno(ErrNoVar int) FileError {	356		func FileErrorFromErrno(ErrNoVar int) FileError {
349		357
350	cret := xFileErrorFromErrno(ErrNoVar)	358		cret := xFileErrorFromErrno(ErrNoVar)
		359	+
351	return cret	360		return cret
352	}	361		}
353		362

@@ -367,6 +376,7 @@ func FileGetContents(FilenameVar string, ContentsVar []byte, LengthVar uint) (
367	var cerr *Error	376		var cerr *Error
368		377
369	cret := xFileGetContents(FilenameVar, ContentsVar, LengthVar, &cerr)	378		cret := xFileGetContents(FilenameVar, ContentsVar, LengthVar, &cerr)
		379	+
370	if cerr == nil {	380		if cerr == nil {
371	return cret, nil	381		return cret, nil
372	}	382		}

@@ -399,6 +409,7 @@ func FileOpenTmp(TmplVar string, NameUsedVar string) (int, error) {
399	defer core.GFreeNullable(TmplVarPtr)	409		defer core.GFreeNullable(TmplVarPtr)
400		410
401	cret := xFileOpenTmp(TmplVarPtr, NameUsedVar, &cerr)	411		cret := xFileOpenTmp(TmplVarPtr, NameUsedVar, &cerr)
		412	+
402	if cerr == nil {	413		if cerr == nil {
403	return cret, nil	414		return cret, nil
404	}	415		}

@@ -438,6 +449,7 @@ func FileReadLink(FilenameVar string) (string, error) {
438	var cerr *Error	449		var cerr *Error
439		450
440	cret := xFileReadLink(FilenameVar, &cerr)	451		cret := xFileReadLink(FilenameVar, &cerr)
		452	+
441	if cerr == nil {	453		if cerr == nil {
442	return cret, nil	454		return cret, nil
443	}	455		}

@@ -455,6 +467,7 @@ func FileSetContents(FilenameVar string, ContentsVar []byte, LengthVar int) (boo
455	var cerr *Error	467		var cerr *Error
456		468
457	cret := xFileSetContents(FilenameVar, ContentsVar, LengthVar, &cerr)	469		cret := xFileSetContents(FilenameVar, ContentsVar, LengthVar, &cerr)
		470	+
458	if cerr == nil {	471		if cerr == nil {
459	return cret, nil	472		return cret, nil
460	}	473		}

@@ -522,6 +535,7 @@ func FileSetContentsFull(FilenameVar string, ContentsVar []byte, LengthVar int,
522	var cerr *Error	535		var cerr *Error
523		536
524	cret := xFileSetContentsFull(FilenameVar, ContentsVar, LengthVar, FlagsVar, ModeVar, &cerr)	537		cret := xFileSetContentsFull(FilenameVar, ContentsVar, LengthVar, FlagsVar, ModeVar, &cerr)
		538	+
525	if cerr == nil {	539		if cerr == nil {
526	return cret, nil	540		return cret, nil
527	}	541		}

@@ -595,6 +609,7 @@ var xNewFileTest func(string, FileTest) bool
595	func NewFileTest(FilenameVar string, TestVar FileTest) bool {	609		func NewFileTest(FilenameVar string, TestVar FileTest) bool {
596		610
597	cret := xNewFileTest(FilenameVar, TestVar)	611		cret := xNewFileTest(FilenameVar, TestVar)
		612	+
598	return cret	613		return cret
599	}	614		}
600		615

@@ -613,6 +628,7 @@ var xGetCurrentDir func() string
613	func GetCurrentDir() string {	628		func GetCurrentDir() string {
614		629
615	cret := xGetCurrentDir()	630		cret := xGetCurrentDir()
		631	+
616	return cret	632		return cret
617	}	633		}
618		634

@@ -623,6 +639,7 @@ var xMkdirWithParents func(string, int) int
623	func MkdirWithParents(PathnameVar string, ModeVar int) int {	639		func MkdirWithParents(PathnameVar string, ModeVar int) int {
624		640
625	cret := xMkdirWithParents(PathnameVar, ModeVar)	641		cret := xMkdirWithParents(PathnameVar, ModeVar)
		642	+
626	return cret	643		return cret
627	}	644		}
628		645

@@ -647,6 +664,7 @@ var xMkdtemp func(string) string
647	func Mkdtemp(TmplVar string) string {	664		func Mkdtemp(TmplVar string) string {
648		665
649	cret := xMkdtemp(TmplVar)	666		cret := xMkdtemp(TmplVar)
		667	+
650	return cret	668		return cret
651	}	669		}
652		670

@@ -671,6 +689,7 @@ var xMkdtempFull func(string, int) string
671	func MkdtempFull(TmplVar string, ModeVar int) string {	689		func MkdtempFull(TmplVar string, ModeVar int) string {
672		690
673	cret := xMkdtempFull(TmplVar, ModeVar)	691		cret := xMkdtempFull(TmplVar, ModeVar)
		692	+
674	return cret	693		return cret
675	}	694		}
676		695

@@ -690,6 +709,7 @@ var xMkstemp func(string) int
690	func Mkstemp(TmplVar string) int {	709		func Mkstemp(TmplVar string) int {
691		710
692	cret := xMkstemp(TmplVar)	711		cret := xMkstemp(TmplVar)
		712	+
693	return cret	713		return cret
694	}	714		}
695		715

@@ -710,6 +730,7 @@ var xMkstempFull func(string, int, int) int
710	func MkstempFull(TmplVar string, FlagsVar int, ModeVar int) int {	730		func MkstempFull(TmplVar string, FlagsVar int, ModeVar int) int {
711		731
712	cret := xMkstempFull(TmplVar, FlagsVar, ModeVar)	732		cret := xMkstempFull(TmplVar, FlagsVar, ModeVar)
		733	+
713	return cret	734		return cret
714	}	735		}
715		736

@@ -724,6 +745,7 @@ var xPathGetBasename func(string) string
724	func PathGetBasename(FileNameVar string) string {	745		func PathGetBasename(FileNameVar string) string {
725		746
726	cret := xPathGetBasename(FileNameVar)	747		cret := xPathGetBasename(FileNameVar)
		748	+
727	return cret	749		return cret
728	}	750		}
729		751

@@ -738,6 +760,7 @@ var xPathGetDirname func(string) string
738	func PathGetDirname(FileNameVar string) string {	760		func PathGetDirname(FileNameVar string) string {
739		761
740	cret := xPathGetDirname(FileNameVar)	762		cret := xPathGetDirname(FileNameVar)
		763	+
741	return cret	764		return cret
742	}	765		}
743		766

@@ -770,6 +793,7 @@ var xPathIsAbsolute func(string) bool
770	func PathIsAbsolute(FileNameVar string) bool {	793		func PathIsAbsolute(FileNameVar string) bool {
771		794
772	cret := xPathIsAbsolute(FileNameVar)	795		cret := xPathIsAbsolute(FileNameVar)
		796	+
773	return cret	797		return cret
774	}	798		}
775		799

@@ -781,6 +805,7 @@ var xPathSkipRoot func(string) string
781	func PathSkipRoot(FileNameVar string) string {	805		func PathSkipRoot(FileNameVar string) string {
782		806
783	cret := xPathSkipRoot(FileNameVar)	807		cret := xPathSkipRoot(FileNameVar)
		808	+
784	return cret	809		return cret
785	}	810		}
786		811

M v4/glib/ggettext.go +6 -0


@@ -18,6 +18,7 @@ func Dcgettext(DomainVar *string, MsgidVar string, CategoryVar int) string {
18	defer core.GFreeNullable(DomainVarPtr)	18		defer core.GFreeNullable(DomainVarPtr)
19		19
20	cret := xDcgettext(DomainVarPtr, MsgidVar, CategoryVar)	20		cret := xDcgettext(DomainVarPtr, MsgidVar, CategoryVar)
		21	+
21	return cret	22		return cret
22	}	23		}
23		24

@@ -61,6 +62,7 @@ func Dgettext(DomainVar *string, MsgidVar string) string {
61	defer core.GFreeNullable(DomainVarPtr)	62		defer core.GFreeNullable(DomainVarPtr)
62		63
63	cret := xDgettext(DomainVarPtr, MsgidVar)	64		cret := xDgettext(DomainVarPtr, MsgidVar)
		65	+
64	return cret	66		return cret
65	}	67		}
66		68

@@ -78,6 +80,7 @@ func Dngettext(DomainVar *string, MsgidVar string, MsgidPluralVar string, NVar u
78	defer core.GFreeNullable(DomainVarPtr)	80		defer core.GFreeNullable(DomainVarPtr)
79		81
80	cret := xDngettext(DomainVarPtr, MsgidVar, MsgidPluralVar, NVar)	82		cret := xDngettext(DomainVarPtr, MsgidVar, MsgidPluralVar, NVar)
		83	+
81	return cret	84		return cret
82	}	85		}
83		86

@@ -102,6 +105,7 @@ func Dpgettext(DomainVar *string, MsgctxtidVar string, MsgidoffsetVar uint) stri
102	defer core.GFreeNullable(DomainVarPtr)	105		defer core.GFreeNullable(DomainVarPtr)
103		106
104	cret := xDpgettext(DomainVarPtr, MsgctxtidVar, MsgidoffsetVar)	107		cret := xDpgettext(DomainVarPtr, MsgctxtidVar, MsgidoffsetVar)
		108	+
105	return cret	109		return cret
106	}	110		}
107		111

@@ -123,6 +127,7 @@ func Dpgettext2(DomainVar *string, ContextVar string, MsgidVar string) string {
123	defer core.GFreeNullable(DomainVarPtr)	127		defer core.GFreeNullable(DomainVarPtr)
124		128
125	cret := xDpgettext2(DomainVarPtr, ContextVar, MsgidVar)	129		cret := xDpgettext2(DomainVarPtr, ContextVar, MsgidVar)
		130	+
126	return cret	131		return cret
127	}	132		}
128		133

@@ -132,6 +137,7 @@ var xStripContext func(string, string) string
132	func StripContext(MsgidVar string, MsgvalVar string) string {	137		func StripContext(MsgidVar string, MsgvalVar string) string {
133		138
134	cret := xStripContext(MsgidVar, MsgvalVar)	139		cret := xStripContext(MsgidVar, MsgvalVar)
		140	+
135	return cret	141		return cret
136	}	142		}
137		143

M v4/glib/ghash.go +29 -0


@@ -180,6 +180,7 @@ var xDirectEqual func(uintptr, uintptr) bool
180	func DirectEqual(V1Var uintptr, V2Var uintptr) bool {	180		func DirectEqual(V1Var uintptr, V2Var uintptr) bool {
181		181
182	cret := xDirectEqual(V1Var, V2Var)	182		cret := xDirectEqual(V1Var, V2Var)
		183	+
183	return cret	184		return cret
184	}	185		}
185		186

@@ -195,6 +196,7 @@ var xDirectHash func(uintptr) uint
195	func DirectHash(VVar uintptr) uint {	196		func DirectHash(VVar uintptr) uint {
196		197
197	cret := xDirectHash(VVar)	198		cret := xDirectHash(VVar)
		199	+
198	return cret	200		return cret
199	}	201		}
200		202

@@ -208,6 +210,7 @@ var xDoubleEqual func(uintptr, uintptr) bool
208	func DoubleEqual(V1Var uintptr, V2Var uintptr) bool {	210		func DoubleEqual(V1Var uintptr, V2Var uintptr) bool {
209		211
210	cret := xDoubleEqual(V1Var, V2Var)	212		cret := xDoubleEqual(V1Var, V2Var)
		213	+
211	return cret	214		return cret
212	}	215		}
213		216

@@ -220,6 +223,7 @@ var xDoubleHash func(uintptr) uint
220	func DoubleHash(VVar uintptr) uint {	223		func DoubleHash(VVar uintptr) uint {
221		224
222	cret := xDoubleHash(VVar)	225		cret := xDoubleHash(VVar)
		226	+
223	return cret	227		return cret
224	}	228		}
225		229

@@ -243,6 +247,7 @@ var xHashTableAdd func(*HashTable, uintptr) bool
243	func HashTableAdd(HashTableVar *HashTable, KeyVar uintptr) bool {	247		func HashTableAdd(HashTableVar *HashTable, KeyVar uintptr) bool {
244		248
245	cret := xHashTableAdd(HashTableVar, KeyVar)	249		cret := xHashTableAdd(HashTableVar, KeyVar)
		250	+
246	return cret	251		return cret
247	}	252		}
248		253

@@ -252,6 +257,7 @@ var xHashTableContains func(*HashTable, uintptr) bool
252	func HashTableContains(HashTableVar *HashTable, KeyVar uintptr) bool {	257		func HashTableContains(HashTableVar *HashTable, KeyVar uintptr) bool {
253		258
254	cret := xHashTableContains(HashTableVar, KeyVar)	259		cret := xHashTableContains(HashTableVar, KeyVar)
		260	+
255	return cret	261		return cret
256	}	262		}
257		263

@@ -302,6 +308,7 @@ func HashTableFind(HashTableVar HashTable, PredicateVar HRFunc, UserDataVar ui
302	}	308		}
303		309
304	cret := xHashTableFind(HashTableVar, PredicateVarRef, UserDataVar)	310		cret := xHashTableFind(HashTableVar, PredicateVarRef, UserDataVar)
		311	+
305	return cret	312		return cret
306	}	313		}
307		314

@@ -368,6 +375,7 @@ func HashTableForeachRemove(HashTableVar HashTable, FuncVar HRFunc, UserDataVa
368	}	375		}
369		376
370	cret := xHashTableForeachRemove(HashTableVar, FuncVarRef, UserDataVar)	377		cret := xHashTableForeachRemove(HashTableVar, FuncVarRef, UserDataVar)
		378	+
371	return cret	379		return cret
372	}	380		}
373		381

@@ -398,6 +406,7 @@ func HashTableForeachSteal(HashTableVar HashTable, FuncVar HRFunc, UserDataVar
398	}	406		}
399		407
400	cret := xHashTableForeachSteal(HashTableVar, FuncVarRef, UserDataVar)	408		cret := xHashTableForeachSteal(HashTableVar, FuncVarRef, UserDataVar)
		409	+
401	return cret	410		return cret
402	}	411		}
403		412

@@ -414,6 +423,7 @@ var xHashTableGetKeysAsPtrArray func(*HashTable) uintptr
414	func HashTableGetKeysAsPtrArray(HashTableVar *HashTable) uintptr {	423		func HashTableGetKeysAsPtrArray(HashTableVar *HashTable) uintptr {
415		424
416	cret := xHashTableGetKeysAsPtrArray(HashTableVar)	425		cret := xHashTableGetKeysAsPtrArray(HashTableVar)
		426	+
417	return cret	427		return cret
418	}	428		}
419		429

@@ -430,6 +440,7 @@ var xHashTableGetValuesAsPtrArray func(*HashTable) uintptr
430	func HashTableGetValuesAsPtrArray(HashTableVar *HashTable) uintptr {	440		func HashTableGetValuesAsPtrArray(HashTableVar *HashTable) uintptr {
431		441
432	cret := xHashTableGetValuesAsPtrArray(HashTableVar)	442		cret := xHashTableGetValuesAsPtrArray(HashTableVar)
		443	+
433	return cret	444		return cret
434	}	445		}
435		446

@@ -450,6 +461,7 @@ var xHashTableInsert func(*HashTable, uintptr, uintptr) bool
450	func HashTableInsert(HashTableVar *HashTable, KeyVar uintptr, ValueVar uintptr) bool {	461		func HashTableInsert(HashTableVar *HashTable, KeyVar uintptr, ValueVar uintptr) bool {
451		462
452	cret := xHashTableInsert(HashTableVar, KeyVar, ValueVar)	463		cret := xHashTableInsert(HashTableVar, KeyVar, ValueVar)
		464	+
453	return cret	465		return cret
454	}	466		}
455		467

@@ -462,6 +474,7 @@ var xHashTableLookup func(*HashTable, uintptr) uintptr
462	func HashTableLookup(HashTableVar *HashTable, KeyVar uintptr) uintptr {	474		func HashTableLookup(HashTableVar *HashTable, KeyVar uintptr) uintptr {
463		475
464	cret := xHashTableLookup(HashTableVar, KeyVar)	476		cret := xHashTableLookup(HashTableVar, KeyVar)
		477	+
465	return cret	478		return cret
466	}	479		}
467		480

@@ -478,6 +491,7 @@ var xHashTableLookupExtended func(HashTable, uintptr, uintptr, *uintptr) bool
478	func HashTableLookupExtended(HashTableVar HashTable, LookupKeyVar uintptr, OrigKeyVar uintptr, ValueVar *uintptr) bool {	491		func HashTableLookupExtended(HashTableVar HashTable, LookupKeyVar uintptr, OrigKeyVar uintptr, ValueVar *uintptr) bool {
479		492
480	cret := xHashTableLookupExtended(HashTableVar, LookupKeyVar, OrigKeyVar, ValueVar)	493		cret := xHashTableLookupExtended(HashTableVar, LookupKeyVar, OrigKeyVar, ValueVar)
		494	+
481	return cret	495		return cret
482	}	496		}
483		497

@@ -494,6 +508,7 @@ var xHashTableNewSimilar func(HashTable) HashTable
494	func HashTableNewSimilar(OtherHashTableVar HashTable) HashTable {	508		func HashTableNewSimilar(OtherHashTableVar HashTable) HashTable {
495		509
496	cret := xHashTableNewSimilar(OtherHashTableVar)	510		cret := xHashTableNewSimilar(OtherHashTableVar)
		511	+
497	return cret	512		return cret
498	}	513		}
499		514

@@ -504,6 +519,7 @@ var xHashTableRef func(HashTable) HashTable
504	func HashTableRef(HashTableVar HashTable) HashTable {	519		func HashTableRef(HashTableVar HashTable) HashTable {
505		520
506	cret := xHashTableRef(HashTableVar)	521		cret := xHashTableRef(HashTableVar)
		522	+
507	return cret	523		return cret
508	}	524		}
509		525

@@ -518,6 +534,7 @@ var xHashTableRemove func(*HashTable, uintptr) bool
518	func HashTableRemove(HashTableVar *HashTable, KeyVar uintptr) bool {	534		func HashTableRemove(HashTableVar *HashTable, KeyVar uintptr) bool {
519		535
520	cret := xHashTableRemove(HashTableVar, KeyVar)	536		cret := xHashTableRemove(HashTableVar, KeyVar)
		537	+
521	return cret	538		return cret
522	}	539		}
523		540

@@ -551,6 +568,7 @@ var xHashTableReplace func(*HashTable, uintptr, uintptr) bool
551	func HashTableReplace(HashTableVar *HashTable, KeyVar uintptr, ValueVar uintptr) bool {	568		func HashTableReplace(HashTableVar *HashTable, KeyVar uintptr, ValueVar uintptr) bool {
552		569
553	cret := xHashTableReplace(HashTableVar, KeyVar, ValueVar)	570		cret := xHashTableReplace(HashTableVar, KeyVar, ValueVar)
		571	+
554	return cret	572		return cret
555	}	573		}
556		574

@@ -560,6 +578,7 @@ var xHashTableSize func(*HashTable) uint
560	func HashTableSize(HashTableVar *HashTable) uint {	578		func HashTableSize(HashTableVar *HashTable) uint {
561		579
562	cret := xHashTableSize(HashTableVar)	580		cret := xHashTableSize(HashTableVar)
		581	+
563	return cret	582		return cret
564	}	583		}
565		584

@@ -570,6 +589,7 @@ var xHashTableSteal func(*HashTable, uintptr) bool
570	func HashTableSteal(HashTableVar *HashTable, KeyVar uintptr) bool {	589		func HashTableSteal(HashTableVar *HashTable, KeyVar uintptr) bool {
571		590
572	cret := xHashTableSteal(HashTableVar, KeyVar)	591		cret := xHashTableSteal(HashTableVar, KeyVar)
		592	+
573	return cret	593		return cret
574	}	594		}
575		595

@@ -592,6 +612,7 @@ var xHashTableStealAllKeys func(*HashTable) uintptr
592	func HashTableStealAllKeys(HashTableVar *HashTable) uintptr {	612		func HashTableStealAllKeys(HashTableVar *HashTable) uintptr {
593		613
594	cret := xHashTableStealAllKeys(HashTableVar)	614		cret := xHashTableStealAllKeys(HashTableVar)
		615	+
595	return cret	616		return cret
596	}	617		}
597		618

@@ -604,6 +625,7 @@ var xHashTableStealAllValues func(*HashTable) uintptr
604	func HashTableStealAllValues(HashTableVar *HashTable) uintptr {	625		func HashTableStealAllValues(HashTableVar *HashTable) uintptr {
605		626
606	cret := xHashTableStealAllValues(HashTableVar)	627		cret := xHashTableStealAllValues(HashTableVar)
		628	+
607	return cret	629		return cret
608	}	630		}
609		631

@@ -629,6 +651,7 @@ var xHashTableStealExtended func(HashTable, uintptr, uintptr, *uintptr) bool
629	func HashTableStealExtended(HashTableVar HashTable, LookupKeyVar uintptr, StolenKeyVar uintptr, StolenValueVar *uintptr) bool {	651		func HashTableStealExtended(HashTableVar HashTable, LookupKeyVar uintptr, StolenKeyVar uintptr, StolenValueVar *uintptr) bool {
630		652
631	cret := xHashTableStealExtended(HashTableVar, LookupKeyVar, StolenKeyVar, StolenValueVar)	653		cret := xHashTableStealExtended(HashTableVar, LookupKeyVar, StolenKeyVar, StolenValueVar)
		654	+
632	return cret	655		return cret
633	}	656		}
634		657

@@ -654,6 +677,7 @@ var xInt64Equal func(uintptr, uintptr) bool
654	func Int64Equal(V1Var uintptr, V2Var uintptr) bool {	677		func Int64Equal(V1Var uintptr, V2Var uintptr) bool {
655		678
656	cret := xInt64Equal(V1Var, V2Var)	679		cret := xInt64Equal(V1Var, V2Var)
		680	+
657	return cret	681		return cret
658	}	682		}
659		683

@@ -667,6 +691,7 @@ var xInt64Hash func(uintptr) uint
667	func Int64Hash(VVar uintptr) uint {	691		func Int64Hash(VVar uintptr) uint {
668		692
669	cret := xInt64Hash(VVar)	693		cret := xInt64Hash(VVar)
		694	+
670	return cret	695		return cret
671	}	696		}
672		697

@@ -684,6 +709,7 @@ var xIntEqual func(uintptr, uintptr) bool
684	func IntEqual(V1Var uintptr, V2Var uintptr) bool {	709		func IntEqual(V1Var uintptr, V2Var uintptr) bool {
685		710
686	cret := xIntEqual(V1Var, V2Var)	711		cret := xIntEqual(V1Var, V2Var)
		712	+
687	return cret	713		return cret
688	}	714		}
689		715

@@ -699,6 +725,7 @@ var xIntHash func(uintptr) uint
699	func IntHash(VVar uintptr) uint {	725		func IntHash(VVar uintptr) uint {
700		726
701	cret := xIntHash(VVar)	727		cret := xIntHash(VVar)
		728	+
702	return cret	729		return cret
703	}	730		}
704		731

@@ -715,6 +742,7 @@ var xStrEqual func(uintptr, uintptr) bool
715	func StrEqual(V1Var uintptr, V2Var uintptr) bool {	742		func StrEqual(V1Var uintptr, V2Var uintptr) bool {
716		743
717	cret := xStrEqual(V1Var, V2Var)	744		cret := xStrEqual(V1Var, V2Var)
		745	+
718	return cret	746		return cret
719	}	747		}
720		748

@@ -737,6 +765,7 @@ var xStrHash func(uintptr) uint
737	func StrHash(VVar uintptr) uint {	765		func StrHash(VVar uintptr) uint {
738		766
739	cret := xStrHash(VVar)	767		cret := xStrHash(VVar)
		768	+
740	return cret	769		return cret
741	}	770		}
742		771

M v4/glib/ghmac.go +3 -0


@@ -148,6 +148,7 @@ var xComputeHmacForBytes func(ChecksumType, Bytes, Bytes) string
148	func ComputeHmacForBytes(DigestTypeVar ChecksumType, KeyVar Bytes, DataVar Bytes) string {	148		func ComputeHmacForBytes(DigestTypeVar ChecksumType, KeyVar Bytes, DataVar Bytes) string {
149		149
150	cret := xComputeHmacForBytes(DigestTypeVar, KeyVar, DataVar)	150		cret := xComputeHmacForBytes(DigestTypeVar, KeyVar, DataVar)
		151	+
151	return cret	152		return cret
152	}	153		}
153		154

@@ -161,6 +162,7 @@ var xComputeHmacForData func(ChecksumType, []byte, uint, []byte, uint) string
161	func ComputeHmacForData(DigestTypeVar ChecksumType, KeyVar []byte, KeyLenVar uint, DataVar []byte, LengthVar uint) string {	162		func ComputeHmacForData(DigestTypeVar ChecksumType, KeyVar []byte, KeyLenVar uint, DataVar []byte, LengthVar uint) string {
162		163
163	cret := xComputeHmacForData(DigestTypeVar, KeyVar, KeyLenVar, DataVar, LengthVar)	164		cret := xComputeHmacForData(DigestTypeVar, KeyVar, KeyLenVar, DataVar, LengthVar)
		165	+
164	return cret	166		return cret
165	}	167		}
166		168

@@ -172,6 +174,7 @@ var xComputeHmacForString func(ChecksumType, []byte, uint, string, int) string
172	func ComputeHmacForString(DigestTypeVar ChecksumType, KeyVar []byte, KeyLenVar uint, StrVar string, LengthVar int) string {	174		func ComputeHmacForString(DigestTypeVar ChecksumType, KeyVar []byte, KeyLenVar uint, StrVar string, LengthVar int) string {
173		175
174	cret := xComputeHmacForString(DigestTypeVar, KeyVar, KeyLenVar, StrVar, LengthVar)	176		cret := xComputeHmacForString(DigestTypeVar, KeyVar, KeyLenVar, StrVar, LengthVar)
		177	+
175	return cret	178		return cret
176	}	179		}
177		180

M v4/glib/ghook.go +1 -0


@@ -207,6 +207,7 @@ var xHookDestroy func(*HookList, uint) bool
207	func HookDestroy(HookListVar *HookList, HookIdVar uint) bool {	207		func HookDestroy(HookListVar *HookList, HookIdVar uint) bool {
208		208
209	cret := xHookDestroy(HookListVar, HookIdVar)	209		cret := xHookDestroy(HookListVar, HookIdVar)
		210	+
210	return cret	211		return cret
211	}	212		}
212		213

M v4/glib/ghostutils.go +5 -0


@@ -19,6 +19,7 @@ var xHostnameIsAsciiEncoded func(string) bool
19	func HostnameIsAsciiEncoded(HostnameVar string) bool {	19		func HostnameIsAsciiEncoded(HostnameVar string) bool {
20		20
21	cret := xHostnameIsAsciiEncoded(HostnameVar)	21		cret := xHostnameIsAsciiEncoded(HostnameVar)
		22	+
22	return cret	23		return cret
23	}	24		}
24		25

@@ -31,6 +32,7 @@ var xHostnameIsIpAddress func(string) bool
31	func HostnameIsIpAddress(HostnameVar string) bool {	32		func HostnameIsIpAddress(HostnameVar string) bool {
32		33
33	cret := xHostnameIsIpAddress(HostnameVar)	34		cret := xHostnameIsIpAddress(HostnameVar)
		35	+
34	return cret	36		return cret
35	}	37		}
36		38

@@ -46,6 +48,7 @@ var xHostnameIsNonAscii func(string) bool
46	func HostnameIsNonAscii(HostnameVar string) bool {	48		func HostnameIsNonAscii(HostnameVar string) bool {
47		49
48	cret := xHostnameIsNonAscii(HostnameVar)	50		cret := xHostnameIsNonAscii(HostnameVar)
		51	+
49	return cret	52		return cret
50	}	53		}
51		54

@@ -57,6 +60,7 @@ var xHostnameToAscii func(string) string
57	func HostnameToAscii(HostnameVar string) string {	60		func HostnameToAscii(HostnameVar string) string {
58		61
59	cret := xHostnameToAscii(HostnameVar)	62		cret := xHostnameToAscii(HostnameVar)
		63	+
60	return cret	64		return cret
61	}	65		}
62		66

@@ -72,6 +76,7 @@ var xHostnameToUnicode func(string) string
72	func HostnameToUnicode(HostnameVar string) string {	76		func HostnameToUnicode(HostnameVar string) string {
73		77
74	cret := xHostnameToUnicode(HostnameVar)	78		cret := xHostnameToUnicode(HostnameVar)
		79	+
75	return cret	80		return cret
76	}	81		}
77		82

M v4/glib/giochannel.go +4 -0


@@ -1040,6 +1040,7 @@ func IoAddWatch(ChannelVar IOChannel, ConditionVar IOCondition, FuncVar IOFunc
1040	}	1040		}
1041		1041
1042	cret := xIoAddWatch(ChannelVar, ConditionVar, FuncVarRef, UserDataVar)	1042		cret := xIoAddWatch(ChannelVar, ConditionVar, FuncVarRef, UserDataVar)
		1043	+
1043	return cret	1044		return cret
1044	}	1045		}
1045		1046

@@ -1084,6 +1085,7 @@ func IoAddWatchFull(ChannelVar *IOChannel, PriorityVar int, ConditionVar IOCondi
1084	}	1085		}
1085		1086
1086	cret := xIoAddWatchFull(ChannelVar, PriorityVar, ConditionVar, FuncVarRef, UserDataVar, NotifyVarRef)	1087		cret := xIoAddWatchFull(ChannelVar, PriorityVar, ConditionVar, FuncVarRef, UserDataVar, NotifyVarRef)
		1088	+
1087	return cret	1089		return cret
1088	}	1090		}
1089		1091

@@ -1093,6 +1095,7 @@ var xIoChannelErrorFromErrno func(int) IOChannelError
1093	func IoChannelErrorFromErrno(EnVar int) IOChannelError {	1095		func IoChannelErrorFromErrno(EnVar int) IOChannelError {
1094		1096
1095	cret := xIoChannelErrorFromErrno(EnVar)	1097		cret := xIoChannelErrorFromErrno(EnVar)
		1098	+
1096	return cret	1099		return cret
1097	}	1100		}
1098		1101

@@ -1115,6 +1118,7 @@ var xIoCreateWatch func(IOChannel, IOCondition) Source
1115	func IoCreateWatch(ChannelVar IOChannel, ConditionVar IOCondition) Source {	1118		func IoCreateWatch(ChannelVar IOChannel, ConditionVar IOCondition) Source {
1116		1119
1117	cret := xIoCreateWatch(ChannelVar, ConditionVar)	1120		cret := xIoCreateWatch(ChannelVar, ConditionVar)
		1121	+
1118	return cret	1122		return cret
1119	}	1123		}
1120		1124

M v4/glib/glib-types.go +2 -0


@@ -12,6 +12,7 @@ var xStrvGetType func() types.GType
12	func StrvGetType() types.GType {	12		func StrvGetType() types.GType {
13		13
14	cret := xStrvGetType()	14		cret := xStrvGetType()
		15	+
15	return cret	16		return cret
16	}	17		}
17		18

@@ -20,6 +21,7 @@ var xVariantGetGtype func() types.GType
20	func VariantGetGtype() types.GType {	21		func VariantGetGtype() types.GType {
21		22
22	cret := xVariantGetGtype()	23		cret := xVariantGetGtype()
		24	+
23	return cret	25		return cret
24	}	26		}
25		27

M v4/glib/glib-unix.go +11 -0


@@ -57,6 +57,7 @@ var xClosefrom func(int) int
57	func Closefrom(LowfdVar int) int {	57		func Closefrom(LowfdVar int) int {
58		58
59	cret := xClosefrom(LowfdVar)	59		cret := xClosefrom(LowfdVar)
		60	+
60	return cret	61		return cret
61	}	62		}
62		63

@@ -79,6 +80,7 @@ var xFdwalkSetCloexec func(int) int
79	func FdwalkSetCloexec(LowfdVar int) int {	80		func FdwalkSetCloexec(LowfdVar int) int {
80		81
81	cret := xFdwalkSetCloexec(LowfdVar)	82		cret := xFdwalkSetCloexec(LowfdVar)
		83	+
82	return cret	84		return cret
83	}	85		}
84		86

@@ -115,6 +117,7 @@ func UnixFdAdd(FdVar int, ConditionVar IOCondition, FunctionVar *UnixFDSourceFun
115	}	117		}
116		118
117	cret := xUnixFdAdd(FdVar, ConditionVar, FunctionVarRef, UserDataVar)	119		cret := xUnixFdAdd(FdVar, ConditionVar, FunctionVarRef, UserDataVar)
		120	+
118	return cret	121		return cret
119	}	122		}
120		123

@@ -159,6 +162,7 @@ func UnixFdAddFull(PriorityVar int, FdVar int, ConditionVar IOCondition, Functio
159	}	162		}
160		163
161	cret := xUnixFdAddFull(PriorityVar, FdVar, ConditionVar, FunctionVarRef, UserDataVar, NotifyVarRef)	164		cret := xUnixFdAddFull(PriorityVar, FdVar, ConditionVar, FunctionVarRef, UserDataVar, NotifyVarRef)
		165	+
162	return cret	166		return cret
163	}	167		}
164		168

@@ -174,6 +178,7 @@ var xUnixFdSourceNew func(int, IOCondition) *Source
174	func UnixFdSourceNew(FdVar int, ConditionVar IOCondition) *Source {	178		func UnixFdSourceNew(FdVar int, ConditionVar IOCondition) *Source {
175		179
176	cret := xUnixFdSourceNew(FdVar, ConditionVar)	180		cret := xUnixFdSourceNew(FdVar, ConditionVar)
		181	+
177	return cret	182		return cret
178	}	183		}
179		184

@@ -194,6 +199,7 @@ func UnixGetPasswdEntry(UserNameVar string) (uintptr, error) {
194	var cerr *Error	199		var cerr *Error
195		200
196	cret := xUnixGetPasswdEntry(UserNameVar, &cerr)	201		cret := xUnixGetPasswdEntry(UserNameVar, &cerr)
		202	+
197	if cerr == nil {	203		if cerr == nil {
198	return cret, nil	204		return cret, nil
199	}	205		}

@@ -226,6 +232,7 @@ func UnixOpenPipe(FdsVar [2]int, FlagsVar int) (bool, error) {
226	var cerr *Error	232		var cerr *Error
227		233
228	cret := xUnixOpenPipe(FdsVar, FlagsVar, &cerr)	234		cret := xUnixOpenPipe(FdsVar, FlagsVar, &cerr)
		235	+
229	if cerr == nil {	236		if cerr == nil {
230	return cret, nil	237		return cret, nil
231	}	238		}

@@ -242,6 +249,7 @@ func UnixSetFdNonblocking(FdVar int, NonblockVar bool) (bool, error) {
242	var cerr *Error	249		var cerr *Error
243		250
244	cret := xUnixSetFdNonblocking(FdVar, NonblockVar, &cerr)	251		cret := xUnixSetFdNonblocking(FdVar, NonblockVar, &cerr)
		252	+
245	if cerr == nil {	253		if cerr == nil {
246	return cret, nil	254		return cret, nil
247	}	255		}

@@ -272,6 +280,7 @@ func UnixSignalAdd(SignumVar int, HandlerVar *SourceFunc, UserDataVar uintptr) u
272	}	280		}
273		281
274	cret := xUnixSignalAdd(SignumVar, HandlerVarRef, UserDataVar)	282		cret := xUnixSignalAdd(SignumVar, HandlerVarRef, UserDataVar)
		283	+
275	return cret	284		return cret
276	}	285		}
277		286

@@ -313,6 +322,7 @@ func UnixSignalAddFull(PriorityVar int, SignumVar int, HandlerVar *SourceFunc, U
313	}	322		}
314		323
315	cret := xUnixSignalAddFull(PriorityVar, SignumVar, HandlerVarRef, UserDataVar, NotifyVarRef)	324		cret := xUnixSignalAddFull(PriorityVar, SignumVar, HandlerVarRef, UserDataVar, NotifyVarRef)
		325	+
316	return cret	326		return cret
317	}	327		}
318		328

@@ -344,6 +354,7 @@ var xUnixSignalSourceNew func(int) *Source
344	func UnixSignalSourceNew(SignumVar int) *Source {	354		func UnixSignalSourceNew(SignumVar int) *Source {
345		355
346	cret := xUnixSignalSourceNew(SignumVar)	356		cret := xUnixSignalSourceNew(SignumVar)
		357	+
347	return cret	358		return cret
348	}	359		}
349		360

M v4/glib/gmain.go +45 -189


@@ -1716,9 +1716,7 @@ func ChildWatchAdd(PidVar Pid, FunctionVar *ChildWatchFunc, DataVar uintptr) uin
1716		}	1716		}
1717			1717
1718		cret := xChildWatchAdd(PidVar, FunctionVarRef, DataVar)	1718		cret := xChildWatchAdd(PidVar, FunctionVarRef, DataVar)
1719	-	if FunctionVar != nil {	1719	+
1720	-	SaveSourceMapping(cret, uintptr(unsafe.Pointer(FunctionVar)))
1721	-	}
1722		return cret	1720		return cret
1723		}	1721		}
1724			1722

@@ -1782,9 +1780,7 @@ func ChildWatchAddFull(PriorityVar int, PidVar Pid, FunctionVar *ChildWatchFunc,
1782		}	1780		}
1783			1781
1784		cret := xChildWatchAddFull(PriorityVar, PidVar, FunctionVarRef, DataVar, NotifyVarRef)	1782		cret := xChildWatchAddFull(PriorityVar, PidVar, FunctionVarRef, DataVar, NotifyVarRef)
1785	-	if FunctionVar != nil {	1783	+
1786	-	SaveSourceMapping(cret, uintptr(unsafe.Pointer(FunctionVar)))
1787	-	}
1788		return cret	1784		return cret
1789		}	1785		}
1790			1786

@@ -1833,6 +1829,7 @@ var xChildWatchSourceNew func(Pid) *Source
1833		func ChildWatchSourceNew(PidVar Pid) *Source {	1829		func ChildWatchSourceNew(PidVar Pid) *Source {
1834			1830
1835		cret := xChildWatchSourceNew(PidVar)	1831		cret := xChildWatchSourceNew(PidVar)
			1832	+
1836		return cret	1833		return cret
1837		}	1834		}
1838			1835

@@ -1899,6 +1896,7 @@ var xGetMonotonicTime func() int64
1899		func GetMonotonicTime() int64 {	1896		func GetMonotonicTime() int64 {
1900			1897
1901		cret := xGetMonotonicTime()	1898		cret := xGetMonotonicTime()
			1899	+
1902		return cret	1900		return cret
1903		}	1901		}
1904			1902

@@ -1915,6 +1913,7 @@ var xGetRealTime func() int64
1915		func GetRealTime() int64 {	1913		func GetRealTime() int64 {
1916			1914
1917		cret := xGetRealTime()	1915		cret := xGetRealTime()
			1916	+
1918		return cret	1917		return cret
1919		}	1918		}
1920			1919

@@ -1937,26 +1936,9 @@ var xIdleAdd func(uintptr, uintptr) uint
1937		// thread is running that main context. You can do these steps manually if you	1936		// thread is running that main context. You can do these steps manually if you
1938		// need greater control or to use a custom main context.	1937		// need greater control or to use a custom main context.
1939		func IdleAdd(FunctionVar *SourceFunc, DataVar uintptr) uint {	1938		func IdleAdd(FunctionVar *SourceFunc, DataVar uintptr) uint {
1940	-		1939	+	trampolineCb, userData := registerSourceFunc(FunctionVar, false)
1941	-	var FunctionVarRef uintptr	1940	+	cret := xIdleAdd(trampolineCb, userData)
1942	-	if FunctionVar != nil {	1941	+	saveSourceTrampolineMapping(cret, userData)
1943	-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
1944	-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
1945	-	FunctionVarRef = cbRefPtr
1946	-	} else {
1947	-	fcb := func(arg0 uintptr) bool {
1948	-	cbFn := *FunctionVar
1949	-	return cbFn(arg0)
1950	-	}
1951	-	FunctionVarRef = purego.NewCallback(fcb)
1952	-	SaveCallbackWithClosure(FunctionVarPtr, FunctionVarRef, FunctionVar)
1953	-	}
1954	-	}
1955	-
1956	-	cret := xIdleAdd(FunctionVarRef, DataVar)
1957	-	if FunctionVar != nil {
1958	-	SaveSourceMapping(cret, uintptr(unsafe.Pointer(FunctionVar)))
1959	-	}
1960		return cret	1942		return cret
1961		}	1943		}
1962			1944

@@ -1977,22 +1959,7 @@ var xIdleAddFull func(int, uintptr, uintptr, uintptr) uint
1977		// thread is running that main context. You can do these steps manually if you	1959		// thread is running that main context. You can do these steps manually if you
1978		// need greater control or to use a custom main context.	1960		// need greater control or to use a custom main context.
1979		func IdleAddFull(PriorityVar int, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {	1961		func IdleAddFull(PriorityVar int, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {
1980	-		1962	+	trampolineCb, userData := registerSourceFunc(FunctionVar, false)
1981	-	var FunctionVarRef uintptr
1982	-	if FunctionVar != nil {
1983	-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
1984	-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
1985	-	FunctionVarRef = cbRefPtr
1986	-	} else {
1987	-	fcb := func(arg0 uintptr) bool {
1988	-	cbFn := *FunctionVar
1989	-	return cbFn(arg0)
1990	-	}
1991	-	FunctionVarRef = purego.NewCallback(fcb)
1992	-	SaveCallbackWithClosure(FunctionVarPtr, FunctionVarRef, FunctionVar)
1993	-	}
1994	-	}
1995	-
1996		var NotifyVarRef uintptr	1963		var NotifyVarRef uintptr
1997		if NotifyVar != nil {	1964		if NotifyVar != nil {
1998		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))	1965		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))

@@ -2007,11 +1974,8 @@ func IdleAddFull(PriorityVar int, FunctionVar *SourceFunc, DataVar uintptr, Noti
2007		SaveCallbackWithClosure(NotifyVarPtr, NotifyVarRef, NotifyVar)	1974		SaveCallbackWithClosure(NotifyVarPtr, NotifyVarRef, NotifyVar)
2008		}	1975		}
2009		}	1976		}
2010	-		1977	+	cret := xIdleAddFull(PriorityVar, trampolineCb, userData, NotifyVarRef)
2011	-	cret := xIdleAddFull(PriorityVar, FunctionVarRef, DataVar, NotifyVarRef)	1978	+	saveSourceTrampolineMapping(cret, userData)
2012	-	if FunctionVar != nil {
2013	-	SaveSourceMapping(cret, uintptr(unsafe.Pointer(FunctionVar)))
2014	-	}
2015		return cret	1979		return cret
2016		}	1980		}
2017			1981

@@ -2028,26 +1992,9 @@ var xIdleAddOnce func(uintptr, uintptr) uint
2028		//	1992		//
2029		// This function otherwise behaves like [func@GLib.idle_add].	1993		// This function otherwise behaves like [func@GLib.idle_add].
2030		func IdleAddOnce(FunctionVar *SourceOnceFunc, DataVar uintptr) uint {	1994		func IdleAddOnce(FunctionVar *SourceOnceFunc, DataVar uintptr) uint {
2031	-		1995	+	trampolineCb, userData := registerSourceOnceFunc(FunctionVar)
2032	-	var FunctionVarRef uintptr	1996	+	cret := xIdleAddOnce(trampolineCb, userData)
2033	-	if FunctionVar != nil {	1997	+	saveSourceTrampolineMapping(cret, userData)
2034	-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
2035	-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
2036	-	FunctionVarRef = cbRefPtr
2037	-	} else {
2038	-	fcb := func(arg0 uintptr) {
2039	-	cbFn := *FunctionVar
2040	-	cbFn(arg0)
2041	-	}
2042	-	FunctionVarRef = purego.NewCallback(fcb)
2043	-	SaveCallbackWithClosure(FunctionVarPtr, FunctionVarRef, FunctionVar)
2044	-	}
2045	-	}
2046	-
2047	-	cret := xIdleAddOnce(FunctionVarRef, DataVar)
2048	-	if FunctionVar != nil {
2049	-	SaveSourceMapping(cret, uintptr(unsafe.Pointer(FunctionVar)))
2050	-	}
2051		return cret	1998		return cret
2052		}	1999		}
2053			2000

@@ -2057,6 +2004,7 @@ var xIdleRemoveByData func(uintptr) bool
2057		func IdleRemoveByData(DataVar uintptr) bool {	2004		func IdleRemoveByData(DataVar uintptr) bool {
2058			2005
2059		cret := xIdleRemoveByData(DataVar)	2006		cret := xIdleRemoveByData(DataVar)
			2007	+
2060		return cret	2008		return cret
2061		}	2009		}
2062			2010

@@ -2073,6 +2021,7 @@ var xIdleSourceNew func() *Source
2073		func IdleSourceNew() *Source {	2021		func IdleSourceNew() *Source {
2074			2022
2075		cret := xIdleSourceNew()	2023		cret := xIdleSourceNew()
			2024	+
2076		return cret	2025		return cret
2077		}	2026		}
2078			2027

@@ -2087,6 +2036,7 @@ var xMainContextDefault func() *MainContext
2087		func MainContextDefault() *MainContext {	2036		func MainContextDefault() *MainContext {
2088			2037
2089		cret := xMainContextDefault()	2038		cret := xMainContextDefault()
			2039	+
2090		return cret	2040		return cret
2091		}	2041		}
2092			2042

@@ -2107,6 +2057,7 @@ var xMainContextGetThreadDefault func() *MainContext
2107		func MainContextGetThreadDefault() *MainContext {	2057		func MainContextGetThreadDefault() *MainContext {
2108			2058
2109		cret := xMainContextGetThreadDefault()	2059		cret := xMainContextGetThreadDefault()
			2060	+
2110		return cret	2061		return cret
2111		}	2062		}
2112			2063

@@ -2125,6 +2076,7 @@ var xMainContextRefThreadDefault func() *MainContext
2125		func MainContextRefThreadDefault() *MainContext {	2076		func MainContextRefThreadDefault() *MainContext {
2126			2077
2127		cret := xMainContextRefThreadDefault()	2078		cret := xMainContextRefThreadDefault()
			2079	+
2128		return cret	2080		return cret
2129		}	2081		}
2130			2082

@@ -2134,6 +2086,7 @@ var xMainCurrentSource func() *Source
2134		func MainCurrentSource() *Source {	2086		func MainCurrentSource() *Source {
2135			2087
2136		cret := xMainCurrentSource()	2088		cret := xMainCurrentSource()
			2089	+
2137		return cret	2090		return cret
2138		}	2091		}
2139			2092

@@ -2251,6 +2204,7 @@ var xMainDepth func() int
2251		func MainDepth() int {	2204		func MainDepth() int {
2252			2205
2253		cret := xMainDepth()	2206		cret := xMainDepth()
			2207	+
2254		return cret	2208		return cret
2255		}	2209		}
2256			2210

@@ -2281,8 +2235,10 @@ var xSourceRemove func(uint) bool
2281		func SourceRemove(TagVar uint) bool {	2235		func SourceRemove(TagVar uint) bool {
2282			2236
2283		cret := xSourceRemove(TagVar)	2237		cret := xSourceRemove(TagVar)
			2238	+
2284		if cret {	2239		if cret {
2285		RemoveCallbackBySource(TagVar)	2240		RemoveCallbackBySource(TagVar)
			2241	+	removeSourceTrampolineBySourceID(TagVar)
2286		}	2242		}
2287		return cret	2243		return cret
2288		}	2244		}

@@ -2297,6 +2253,7 @@ var xSourceRemoveByFuncsUserData func(*SourceFuncs, uintptr) bool
2297		func SourceRemoveByFuncsUserData(FuncsVar *SourceFuncs, UserDataVar uintptr) bool {	2253		func SourceRemoveByFuncsUserData(FuncsVar *SourceFuncs, UserDataVar uintptr) bool {
2298			2254
2299		cret := xSourceRemoveByFuncsUserData(FuncsVar, UserDataVar)	2255		cret := xSourceRemoveByFuncsUserData(FuncsVar, UserDataVar)
			2256	+
2300		return cret	2257		return cret
2301		}	2258		}
2302			2259

@@ -2309,6 +2266,7 @@ var xSourceRemoveByUserData func(uintptr) bool
2309		func SourceRemoveByUserData(UserDataVar uintptr) bool {	2266		func SourceRemoveByUserData(UserDataVar uintptr) bool {
2310			2267
2311		cret := xSourceRemoveByUserData(UserDataVar)	2268		cret := xSourceRemoveByUserData(UserDataVar)
			2269	+
2312		return cret	2270		return cret
2313		}	2271		}
2314			2272

@@ -2372,26 +2330,9 @@ var xTimeoutAdd func(uint, uintptr, uintptr) uint
2372		// The interval given is in terms of monotonic time, not wall clock	2330		// The interval given is in terms of monotonic time, not wall clock
2373		// time. See [func@GLib.get_monotonic_time].	2331		// time. See [func@GLib.get_monotonic_time].
2374		func TimeoutAdd(IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr) uint {	2332		func TimeoutAdd(IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr) uint {
2375	-		2333	+	trampolineCb, userData := registerSourceFunc(FunctionVar, false)
2376	-	var FunctionVarRef uintptr	2334	+	cret := xTimeoutAdd(IntervalVar, trampolineCb, userData)
2377	-	if FunctionVar != nil {	2335	+	saveSourceTrampolineMapping(cret, userData)
2378	-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
2379	-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
2380	-	FunctionVarRef = cbRefPtr
2381	-	} else {
2382	-	fcb := func(arg0 uintptr) bool {
2383	-	cbFn := *FunctionVar
2384	-	return cbFn(arg0)
2385	-	}
2386	-	FunctionVarRef = purego.NewCallback(fcb)
2387	-	SaveCallbackWithClosure(FunctionVarPtr, FunctionVarRef, FunctionVar)
2388	-	}
2389	-	}
2390	-
2391	-	cret := xTimeoutAdd(IntervalVar, FunctionVarRef, DataVar)
2392	-	if FunctionVar != nil {
2393	-	SaveSourceMapping(cret, uintptr(unsafe.Pointer(FunctionVar)))
2394	-	}
2395		return cret	2336		return cret
2396		}	2337		}
2397			2338

@@ -2426,22 +2367,7 @@ var xTimeoutAddFull func(int, uint, uintptr, uintptr, uintptr) uint
2426		// The interval given is in terms of monotonic time, not wall clock time.	2367		// The interval given is in terms of monotonic time, not wall clock time.
2427		// See [func@GLib.get_monotonic_time].	2368		// See [func@GLib.get_monotonic_time].
2428		func TimeoutAddFull(PriorityVar int, IntervalVar uint, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {	2369		func TimeoutAddFull(PriorityVar int, IntervalVar uint, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {
2429	-		2370	+	trampolineCb, userData := registerSourceFunc(FunctionVar, false)
2430	-	var FunctionVarRef uintptr
2431	-	if FunctionVar != nil {
2432	-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
2433	-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
2434	-	FunctionVarRef = cbRefPtr
2435	-	} else {
2436	-	fcb := func(arg0 uintptr) bool {
2437	-	cbFn := *FunctionVar
2438	-	return cbFn(arg0)
2439	-	}
2440	-	FunctionVarRef = purego.NewCallback(fcb)
2441	-	SaveCallbackWithClosure(FunctionVarPtr, FunctionVarRef, FunctionVar)
2442	-	}
2443	-	}
2444	-
2445		var NotifyVarRef uintptr	2371		var NotifyVarRef uintptr
2446		if NotifyVar != nil {	2372		if NotifyVar != nil {
2447		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))	2373		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))

@@ -2456,11 +2382,8 @@ func TimeoutAddFull(PriorityVar int, IntervalVar uint, FunctionVar *SourceFunc,
2456		SaveCallbackWithClosure(NotifyVarPtr, NotifyVarRef, NotifyVar)	2382		SaveCallbackWithClosure(NotifyVarPtr, NotifyVarRef, NotifyVar)
2457		}	2383		}
2458		}	2384		}
2459	-		2385	+	cret := xTimeoutAddFull(PriorityVar, IntervalVar, trampolineCb, userData, NotifyVarRef)
2460	-	cret := xTimeoutAddFull(PriorityVar, IntervalVar, FunctionVarRef, DataVar, NotifyVarRef)	2386	+	saveSourceTrampolineMapping(cret, userData)
2461	-	if FunctionVar != nil {
2462	-	SaveSourceMapping(cret, uintptr(unsafe.Pointer(FunctionVar)))
2463	-	}
2464		return cret	2387		return cret
2465		}	2388		}
2466			2389

@@ -2474,26 +2397,9 @@ var xTimeoutAddOnce func(uint, uintptr, uintptr) uint
2474		//	2397		//
2475		// This function otherwise behaves like [func@GLib.timeout_add].	2398		// This function otherwise behaves like [func@GLib.timeout_add].
2476		func TimeoutAddOnce(IntervalVar uint, FunctionVar *SourceOnceFunc, DataVar uintptr) uint {	2399		func TimeoutAddOnce(IntervalVar uint, FunctionVar *SourceOnceFunc, DataVar uintptr) uint {
2477	-		2400	+	trampolineCb, userData := registerSourceOnceFunc(FunctionVar)
2478	-	var FunctionVarRef uintptr	2401	+	cret := xTimeoutAddOnce(IntervalVar, trampolineCb, userData)
2479	-	if FunctionVar != nil {	2402	+	saveSourceTrampolineMapping(cret, userData)
2480	-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
2481	-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
2482	-	FunctionVarRef = cbRefPtr
2483	-	} else {
2484	-	fcb := func(arg0 uintptr) {
2485	-	cbFn := *FunctionVar
2486	-	cbFn(arg0)
2487	-	}
2488	-	FunctionVarRef = purego.NewCallback(fcb)
2489	-	SaveCallbackWithClosure(FunctionVarPtr, FunctionVarRef, FunctionVar)
2490	-	}
2491	-	}
2492	-
2493	-	cret := xTimeoutAddOnce(IntervalVar, FunctionVarRef, DataVar)
2494	-	if FunctionVar != nil {
2495	-	SaveSourceMapping(cret, uintptr(unsafe.Pointer(FunctionVar)))
2496	-	}
2497		return cret	2403		return cret
2498		}	2404		}
2499			2405

@@ -2523,26 +2429,9 @@ var xTimeoutAddSeconds func(uint, uintptr, uintptr) uint
2523		// The interval given is in terms of monotonic time, not wall clock	2429		// The interval given is in terms of monotonic time, not wall clock
2524		// time. See [func@GLib.get_monotonic_time].	2430		// time. See [func@GLib.get_monotonic_time].
2525		func TimeoutAddSeconds(IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr) uint {	2431		func TimeoutAddSeconds(IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr) uint {
2526	-		2432	+	trampolineCb, userData := registerSourceFunc(FunctionVar, false)
2527	-	var FunctionVarRef uintptr	2433	+	cret := xTimeoutAddSeconds(IntervalVar, trampolineCb, userData)
2528	-	if FunctionVar != nil {	2434	+	saveSourceTrampolineMapping(cret, userData)
2529	-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
2530	-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
2531	-	FunctionVarRef = cbRefPtr
2532	-	} else {
2533	-	fcb := func(arg0 uintptr) bool {
2534	-	cbFn := *FunctionVar
2535	-	return cbFn(arg0)
2536	-	}
2537	-	FunctionVarRef = purego.NewCallback(fcb)
2538	-	SaveCallbackWithClosure(FunctionVarPtr, FunctionVarRef, FunctionVar)
2539	-	}
2540	-	}
2541	-
2542	-	cret := xTimeoutAddSeconds(IntervalVar, FunctionVarRef, DataVar)
2543	-	if FunctionVar != nil {
2544	-	SaveSourceMapping(cret, uintptr(unsafe.Pointer(FunctionVar)))
2545	-	}
2546		return cret	2435		return cret
2547		}	2436		}
2548			2437

@@ -2589,22 +2478,7 @@ var xTimeoutAddSecondsFull func(int, uint, uintptr, uintptr, uintptr) uint
2589		// The interval given is in terms of monotonic time, not wall clock	2478		// The interval given is in terms of monotonic time, not wall clock
2590		// time. See [func@GLib.get_monotonic_time].	2479		// time. See [func@GLib.get_monotonic_time].
2591		func TimeoutAddSecondsFull(PriorityVar int, IntervalVar uint, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {	2480		func TimeoutAddSecondsFull(PriorityVar int, IntervalVar uint, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {
2592	-		2481	+	trampolineCb, userData := registerSourceFunc(FunctionVar, false)
2593	-	var FunctionVarRef uintptr
2594	-	if FunctionVar != nil {
2595	-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
2596	-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
2597	-	FunctionVarRef = cbRefPtr
2598	-	} else {
2599	-	fcb := func(arg0 uintptr) bool {
2600	-	cbFn := *FunctionVar
2601	-	return cbFn(arg0)
2602	-	}
2603	-	FunctionVarRef = purego.NewCallback(fcb)
2604	-	SaveCallbackWithClosure(FunctionVarPtr, FunctionVarRef, FunctionVar)
2605	-	}
2606	-	}
2607	-
2608		var NotifyVarRef uintptr	2482		var NotifyVarRef uintptr
2609		if NotifyVar != nil {	2483		if NotifyVar != nil {
2610		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))	2484		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))

@@ -2619,11 +2493,8 @@ func TimeoutAddSecondsFull(PriorityVar int, IntervalVar uint, FunctionVar *Sourc
2619		SaveCallbackWithClosure(NotifyVarPtr, NotifyVarRef, NotifyVar)	2493		SaveCallbackWithClosure(NotifyVarPtr, NotifyVarRef, NotifyVar)
2620		}	2494		}
2621		}	2495		}
2622	-		2496	+	cret := xTimeoutAddSecondsFull(PriorityVar, IntervalVar, trampolineCb, userData, NotifyVarRef)
2623	-	cret := xTimeoutAddSecondsFull(PriorityVar, IntervalVar, FunctionVarRef, DataVar, NotifyVarRef)	2497	+	saveSourceTrampolineMapping(cret, userData)
2624	-	if FunctionVar != nil {
2625	-	SaveSourceMapping(cret, uintptr(unsafe.Pointer(FunctionVar)))
2626	-	}
2627		return cret	2498		return cret
2628		}	2499		}
2629			2500

@@ -2632,26 +2503,9 @@ var xTimeoutAddSecondsOnce func(uint, uintptr, uintptr) uint
2632		// This function behaves like [func@GLib.timeout_add_once] but with a range in	2503		// This function behaves like [func@GLib.timeout_add_once] but with a range in
2633		// seconds.	2504		// seconds.
2634		func TimeoutAddSecondsOnce(IntervalVar uint, FunctionVar *SourceOnceFunc, DataVar uintptr) uint {	2505		func TimeoutAddSecondsOnce(IntervalVar uint, FunctionVar *SourceOnceFunc, DataVar uintptr) uint {
2635	-		2506	+	trampolineCb, userData := registerSourceOnceFunc(FunctionVar)
2636	-	var FunctionVarRef uintptr	2507	+	cret := xTimeoutAddSecondsOnce(IntervalVar, trampolineCb, userData)
2637	-	if FunctionVar != nil {	2508	+	saveSourceTrampolineMapping(cret, userData)
2638	-	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
2639	-	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
2640	-	FunctionVarRef = cbRefPtr
2641	-	} else {
2642	-	fcb := func(arg0 uintptr) {
2643	-	cbFn := *FunctionVar
2644	-	cbFn(arg0)
2645	-	}
2646	-	FunctionVarRef = purego.NewCallback(fcb)
2647	-	SaveCallbackWithClosure(FunctionVarPtr, FunctionVarRef, FunctionVar)
2648	-	}
2649	-	}
2650	-
2651	-	cret := xTimeoutAddSecondsOnce(IntervalVar, FunctionVarRef, DataVar)
2652	-	if FunctionVar != nil {
2653	-	SaveSourceMapping(cret, uintptr(unsafe.Pointer(FunctionVar)))
2654	-	}
2655		return cret	2509		return cret
2656		}	2510		}
2657			2511

@@ -2668,6 +2522,7 @@ var xTimeoutSourceNew func(uint) *Source
2668		func TimeoutSourceNew(IntervalVar uint) *Source {	2522		func TimeoutSourceNew(IntervalVar uint) *Source {
2669			2523
2670		cret := xTimeoutSourceNew(IntervalVar)	2524		cret := xTimeoutSourceNew(IntervalVar)
			2525	+
2671		return cret	2526		return cret
2672		}	2527		}
2673			2528

@@ -2687,6 +2542,7 @@ var xTimeoutSourceNewSeconds func(uint) *Source
2687		func TimeoutSourceNewSeconds(IntervalVar uint) *Source {	2542		func TimeoutSourceNewSeconds(IntervalVar uint) *Source {
2688			2543
2689		cret := xTimeoutSourceNewSeconds(IntervalVar)	2544		cret := xTimeoutSourceNewSeconds(IntervalVar)
			2545	+
2690		return cret	2546		return cret
2691		}	2547		}
2692			2548

M v4/glib/gmarkup.go +4 -0


@@ -657,6 +657,7 @@ var xMarkupCollectAttributes func(string, string, string, **Error, MarkupCollect
657	func MarkupCollectAttributes(ElementNameVar string, AttributeNamesVar string, AttributeValuesVar string, ErrorVar **Error, FirstTypeVar MarkupCollectType, FirstAttrVar string, varArgs ...interface{}) bool {	657		func MarkupCollectAttributes(ElementNameVar string, AttributeNamesVar string, AttributeValuesVar string, ErrorVar **Error, FirstTypeVar MarkupCollectType, FirstAttrVar string, varArgs ...interface{}) bool {
658		658
659	cret := xMarkupCollectAttributes(ElementNameVar, AttributeNamesVar, AttributeValuesVar, ErrorVar, FirstTypeVar, FirstAttrVar, varArgs...)	659		cret := xMarkupCollectAttributes(ElementNameVar, AttributeNamesVar, AttributeValuesVar, ErrorVar, FirstTypeVar, FirstAttrVar, varArgs...)
		660	+
660	return cret	661		return cret
661	}	662		}
662		663

@@ -679,6 +680,7 @@ var xMarkupEscapeText func(string, int) string
679	func MarkupEscapeText(TextVar string, LengthVar int) string {	680		func MarkupEscapeText(TextVar string, LengthVar int) string {
680		681
681	cret := xMarkupEscapeText(TextVar, LengthVar)	682		cret := xMarkupEscapeText(TextVar, LengthVar)
		683	+
682	return cret	684		return cret
683	}	685		}
684		686

@@ -707,6 +709,7 @@ var xMarkupPrintfEscaped func(string, ...interface{}) string
707	func MarkupPrintfEscaped(FormatVar string, varArgs ...interface{}) string {	709		func MarkupPrintfEscaped(FormatVar string, varArgs ...interface{}) string {
708		710
709	cret := xMarkupPrintfEscaped(FormatVar, varArgs...)	711		cret := xMarkupPrintfEscaped(FormatVar, varArgs...)
		712	+
710	return cret	713		return cret
711	}	714		}
712		715

@@ -718,6 +721,7 @@ var xMarkupVprintfEscaped func(string, []interface{}) string
718	func MarkupVprintfEscaped(FormatVar string, ArgsVar []interface{}) string {	721		func MarkupVprintfEscaped(FormatVar string, ArgsVar []interface{}) string {
719		722
720	cret := xMarkupVprintfEscaped(FormatVar, ArgsVar)	723		cret := xMarkupVprintfEscaped(FormatVar, ArgsVar)
		724	+
721	return cret	725		return cret
722	}	726		}
723		727

M v4/glib/gmem.go +15 -0


@@ -199,6 +199,7 @@ var xAlignedAlloc func(uint, uint, uint) uintptr
199	func AlignedAlloc(NBlocksVar uint, NBlockBytesVar uint, AlignmentVar uint) uintptr {	199		func AlignedAlloc(NBlocksVar uint, NBlockBytesVar uint, AlignmentVar uint) uintptr {
200		200
201	cret := xAlignedAlloc(NBlocksVar, NBlockBytesVar, AlignmentVar)	201		cret := xAlignedAlloc(NBlocksVar, NBlockBytesVar, AlignmentVar)
		202	+
202	return cret	203		return cret
203	}	204		}
204		205

@@ -209,6 +210,7 @@ var xAlignedAlloc0 func(uint, uint, uint) uintptr
209	func AlignedAlloc0(NBlocksVar uint, NBlockBytesVar uint, AlignmentVar uint) uintptr {	210		func AlignedAlloc0(NBlocksVar uint, NBlockBytesVar uint, AlignmentVar uint) uintptr {
210		211
211	cret := xAlignedAlloc0(NBlocksVar, NBlockBytesVar, AlignmentVar)	212		cret := xAlignedAlloc0(NBlocksVar, NBlockBytesVar, AlignmentVar)
		213	+
212	return cret	214		return cret
213	}	215		}
214		216

@@ -348,6 +350,7 @@ var xMalloc func(uint) uintptr
348	func Malloc(NBytesVar uint) uintptr {	350		func Malloc(NBytesVar uint) uintptr {
349		351
350	cret := xMalloc(NBytesVar)	352		cret := xMalloc(NBytesVar)
		353	+
351	return cret	354		return cret
352	}	355		}
353		356

@@ -361,6 +364,7 @@ var xMalloc0 func(uint) uintptr
361	func Malloc0(NBytesVar uint) uintptr {	364		func Malloc0(NBytesVar uint) uintptr {
362		365
363	cret := xMalloc0(NBytesVar)	366		cret := xMalloc0(NBytesVar)
		367	+
364	return cret	368		return cret
365	}	369		}
366		370

@@ -374,6 +378,7 @@ var xMalloc0N func(uint, uint) uintptr
374	func Malloc0N(NBlocksVar uint, NBlockBytesVar uint) uintptr {	378		func Malloc0N(NBlocksVar uint, NBlockBytesVar uint) uintptr {
375		379
376	cret := xMalloc0N(NBlocksVar, NBlockBytesVar)	380		cret := xMalloc0N(NBlocksVar, NBlockBytesVar)
		381	+
377	return cret	382		return cret
378	}	383		}
379		384

@@ -387,6 +392,7 @@ var xMallocN func(uint, uint) uintptr
387	func MallocN(NBlocksVar uint, NBlockBytesVar uint) uintptr {	392		func MallocN(NBlocksVar uint, NBlockBytesVar uint) uintptr {
388		393
389	cret := xMallocN(NBlocksVar, NBlockBytesVar)	394		cret := xMallocN(NBlocksVar, NBlockBytesVar)
		395	+
390	return cret	396		return cret
391	}	397		}
392		398

@@ -400,6 +406,7 @@ var xMemIsSystemMalloc func() bool
400	func MemIsSystemMalloc() bool {	406		func MemIsSystemMalloc() bool {
401		407
402	cret := xMemIsSystemMalloc()	408		cret := xMemIsSystemMalloc()
		409	+
403	return cret	410		return cret
404	}	411		}
405		412

@@ -439,6 +446,7 @@ var xRealloc func(uintptr, uint) uintptr
439	func Realloc(MemVar uintptr, NBytesVar uint) uintptr {	446		func Realloc(MemVar uintptr, NBytesVar uint) uintptr {
440		447
441	cret := xRealloc(MemVar, NBytesVar)	448		cret := xRealloc(MemVar, NBytesVar)
		449	+
442	return cret	450		return cret
443	}	451		}
444		452

@@ -452,6 +460,7 @@ var xReallocN func(uintptr, uint, uint) uintptr
452	func ReallocN(MemVar uintptr, NBlocksVar uint, NBlockBytesVar uint) uintptr {	460		func ReallocN(MemVar uintptr, NBlocksVar uint, NBlockBytesVar uint) uintptr {
453		461
454	cret := xReallocN(MemVar, NBlocksVar, NBlockBytesVar)	462		cret := xReallocN(MemVar, NBlocksVar, NBlockBytesVar)
		463	+
455	return cret	464		return cret
456	}	465		}
457		466

@@ -462,6 +471,7 @@ var xTryMalloc func(uint) uintptr
462	func TryMalloc(NBytesVar uint) uintptr {	471		func TryMalloc(NBytesVar uint) uintptr {
463		472
464	cret := xTryMalloc(NBytesVar)	473		cret := xTryMalloc(NBytesVar)
		474	+
465	return cret	475		return cret
466	}	476		}
467		477

@@ -472,6 +482,7 @@ var xTryMalloc0 func(uint) uintptr
472	func TryMalloc0(NBytesVar uint) uintptr {	482		func TryMalloc0(NBytesVar uint) uintptr {
473		483
474	cret := xTryMalloc0(NBytesVar)	484		cret := xTryMalloc0(NBytesVar)
		485	+
475	return cret	486		return cret
476	}	487		}
477		488

@@ -482,6 +493,7 @@ var xTryMalloc0N func(uint, uint) uintptr
482	func TryMalloc0N(NBlocksVar uint, NBlockBytesVar uint) uintptr {	493		func TryMalloc0N(NBlocksVar uint, NBlockBytesVar uint) uintptr {
483		494
484	cret := xTryMalloc0N(NBlocksVar, NBlockBytesVar)	495		cret := xTryMalloc0N(NBlocksVar, NBlockBytesVar)
		496	+
485	return cret	497		return cret
486	}	498		}
487		499

@@ -492,6 +504,7 @@ var xTryMallocN func(uint, uint) uintptr
492	func TryMallocN(NBlocksVar uint, NBlockBytesVar uint) uintptr {	504		func TryMallocN(NBlocksVar uint, NBlockBytesVar uint) uintptr {
493		505
494	cret := xTryMallocN(NBlocksVar, NBlockBytesVar)	506		cret := xTryMallocN(NBlocksVar, NBlockBytesVar)
		507	+
495	return cret	508		return cret
496	}	509		}
497		510

@@ -505,6 +518,7 @@ var xTryRealloc func(uintptr, uint) uintptr
505	func TryRealloc(MemVar uintptr, NBytesVar uint) uintptr {	518		func TryRealloc(MemVar uintptr, NBytesVar uint) uintptr {
506		519
507	cret := xTryRealloc(MemVar, NBytesVar)	520		cret := xTryRealloc(MemVar, NBytesVar)
		521	+
508	return cret	522		return cret
509	}	523		}
510		524

@@ -515,6 +529,7 @@ var xTryReallocN func(uintptr, uint, uint) uintptr
515	func TryReallocN(MemVar uintptr, NBlocksVar uint, NBlockBytesVar uint) uintptr {	529		func TryReallocN(MemVar uintptr, NBlocksVar uint, NBlockBytesVar uint) uintptr {
516		530
517	cret := xTryReallocN(MemVar, NBlocksVar, NBlockBytesVar)	531		cret := xTryReallocN(MemVar, NBlocksVar, NBlockBytesVar)
		532	+
518	return cret	533		return cret
519	}	534		}
520		535

M v4/glib/gmessages.go +18 -0


@@ -263,6 +263,7 @@ var xLogGetAlwaysFatal func() LogLevelFlags
263	func LogGetAlwaysFatal() LogLevelFlags {	263		func LogGetAlwaysFatal() LogLevelFlags {
264		264
265	cret := xLogGetAlwaysFatal()	265		cret := xLogGetAlwaysFatal()
		266	+
266	return cret	267		return cret
267	}	268		}
268		269

@@ -280,6 +281,7 @@ var xLogGetDebugEnabled func() bool
280	func LogGetDebugEnabled() bool {	281		func LogGetDebugEnabled() bool {
281		282
282	cret := xLogGetDebugEnabled()	283		cret := xLogGetDebugEnabled()
		284	+
283	return cret	285		return cret
284	}	286		}
285		287

@@ -317,6 +319,7 @@ var xLogSetAlwaysFatal func(LogLevelFlags) LogLevelFlags
317	func LogSetAlwaysFatal(FatalMaskVar LogLevelFlags) LogLevelFlags {	319		func LogSetAlwaysFatal(FatalMaskVar LogLevelFlags) LogLevelFlags {
318		320
319	cret := xLogSetAlwaysFatal(FatalMaskVar)	321		cret := xLogSetAlwaysFatal(FatalMaskVar)
		322	+
320	return cret	323		return cret
321	}	324		}
322		325

@@ -364,6 +367,7 @@ func LogSetDefaultHandler(LogFuncVar *LogFunc, UserDataVar uintptr) uintptr {
364	}	367		}
365		368
366	cret := xLogSetDefaultHandler(LogFuncVarRef, UserDataVar)	369		cret := xLogSetDefaultHandler(LogFuncVarRef, UserDataVar)
		370	+
367	return cret	371		return cret
368	}	372		}
369		373

@@ -386,6 +390,7 @@ var xLogSetFatalMask func(string, LogLevelFlags) LogLevelFlags
386	func LogSetFatalMask(LogDomainVar string, FatalMaskVar LogLevelFlags) LogLevelFlags {	390		func LogSetFatalMask(LogDomainVar string, FatalMaskVar LogLevelFlags) LogLevelFlags {
387		391
388	cret := xLogSetFatalMask(LogDomainVar, FatalMaskVar)	392		cret := xLogSetFatalMask(LogDomainVar, FatalMaskVar)
		393	+
389	return cret	394		return cret
390	}	395		}
391		396

@@ -455,6 +460,7 @@ func LogSetHandler(LogDomainVar *string, LogLevelsVar LogLevelFlags, LogFuncVar
455	defer core.GFreeNullable(LogDomainVarPtr)	460		defer core.GFreeNullable(LogDomainVarPtr)
456		461
457	cret := xLogSetHandler(LogDomainVarPtr, LogLevelsVar, LogFuncVarRef, UserDataVar)	462		cret := xLogSetHandler(LogDomainVarPtr, LogLevelsVar, LogFuncVarRef, UserDataVar)
		463	+
458	return cret	464		return cret
459	}	465		}
460		466

@@ -503,6 +509,7 @@ func LogSetHandlerFull(LogDomainVar *string, LogLevelsVar LogLevelFlags, LogFunc
503	defer core.GFreeNullable(LogDomainVarPtr)	509		defer core.GFreeNullable(LogDomainVarPtr)
504		510
505	cret := xLogSetHandlerFull(LogDomainVarPtr, LogLevelsVar, LogFuncVarRef, UserDataVar, DestroyVarRef)	511		cret := xLogSetHandlerFull(LogDomainVarPtr, LogLevelsVar, LogFuncVarRef, UserDataVar, DestroyVarRef)
		512	+
506	return cret	513		return cret
507	}	514		}
508		515

@@ -736,6 +743,7 @@ var xLogWriterDefault func(LogLevelFlags, []LogField, uint, uintptr) LogWriterOu
736	func LogWriterDefault(LogLevelVar LogLevelFlags, FieldsVar []LogField, NFieldsVar uint, UserDataVar uintptr) LogWriterOutput {	743		func LogWriterDefault(LogLevelVar LogLevelFlags, FieldsVar []LogField, NFieldsVar uint, UserDataVar uintptr) LogWriterOutput {
737		744
738	cret := xLogWriterDefault(LogLevelVar, FieldsVar, NFieldsVar, UserDataVar)	745		cret := xLogWriterDefault(LogLevelVar, FieldsVar, NFieldsVar, UserDataVar)
		746	+
739	return cret	747		return cret
740	}	748		}
741		749

@@ -816,6 +824,7 @@ func LogWriterDefaultWouldDrop(LogLevelVar LogLevelFlags, LogDomainVar *string)
816	defer core.GFreeNullable(LogDomainVarPtr)	824		defer core.GFreeNullable(LogDomainVarPtr)
817		825
818	cret := xLogWriterDefaultWouldDrop(LogLevelVar, LogDomainVarPtr)	826		cret := xLogWriterDefaultWouldDrop(LogLevelVar, LogDomainVarPtr)
		827	+
819	return cret	828		return cret
820	}	829		}
821		830

@@ -835,6 +844,7 @@ var xLogWriterFormatFields func(LogLevelFlags, []LogField, uint, bool) string
835	func LogWriterFormatFields(LogLevelVar LogLevelFlags, FieldsVar []LogField, NFieldsVar uint, UseColorVar bool) string {	844		func LogWriterFormatFields(LogLevelVar LogLevelFlags, FieldsVar []LogField, NFieldsVar uint, UseColorVar bool) string {
836		845
837	cret := xLogWriterFormatFields(LogLevelVar, FieldsVar, NFieldsVar, UseColorVar)	846		cret := xLogWriterFormatFields(LogLevelVar, FieldsVar, NFieldsVar, UseColorVar)
		847	+
838	return cret	848		return cret
839	}	849		}
840		850

@@ -852,6 +862,7 @@ var xLogWriterIsJournald func(int) bool
852	func LogWriterIsJournald(OutputFdVar int) bool {	862		func LogWriterIsJournald(OutputFdVar int) bool {
853		863
854	cret := xLogWriterIsJournald(OutputFdVar)	864		cret := xLogWriterIsJournald(OutputFdVar)
		865	+
855	return cret	866		return cret
856	}	867		}
857		868

@@ -871,6 +882,7 @@ var xLogWriterJournald func(LogLevelFlags, []LogField, uint, uintptr) LogWriterO
871	func LogWriterJournald(LogLevelVar LogLevelFlags, FieldsVar []LogField, NFieldsVar uint, UserDataVar uintptr) LogWriterOutput {	882		func LogWriterJournald(LogLevelVar LogLevelFlags, FieldsVar []LogField, NFieldsVar uint, UserDataVar uintptr) LogWriterOutput {
872		883
873	cret := xLogWriterJournald(LogLevelVar, FieldsVar, NFieldsVar, UserDataVar)	884		cret := xLogWriterJournald(LogLevelVar, FieldsVar, NFieldsVar, UserDataVar)
		885	+
874	return cret	886		return cret
875	}	887		}
876		888

@@ -896,6 +908,7 @@ var xLogWriterStandardStreams func(LogLevelFlags, []LogField, uint, uintptr) Log
896	func LogWriterStandardStreams(LogLevelVar LogLevelFlags, FieldsVar []LogField, NFieldsVar uint, UserDataVar uintptr) LogWriterOutput {	908		func LogWriterStandardStreams(LogLevelVar LogLevelFlags, FieldsVar []LogField, NFieldsVar uint, UserDataVar uintptr) LogWriterOutput {
897		909
898	cret := xLogWriterStandardStreams(LogLevelVar, FieldsVar, NFieldsVar, UserDataVar)	910		cret := xLogWriterStandardStreams(LogLevelVar, FieldsVar, NFieldsVar, UserDataVar)
		911	+
899	return cret	912		return cret
900	}	913		}
901		914

@@ -908,6 +921,7 @@ var xLogWriterSupportsColor func(int) bool
908	func LogWriterSupportsColor(OutputFdVar int) bool {	921		func LogWriterSupportsColor(OutputFdVar int) bool {
909		922
910	cret := xLogWriterSupportsColor(OutputFdVar)	923		cret := xLogWriterSupportsColor(OutputFdVar)
		924	+
911	return cret	925		return cret
912	}	926		}
913		927

@@ -928,6 +942,7 @@ var xLogWriterSyslog func(LogLevelFlags, []LogField, uint, uintptr) LogWriterOut
928	func LogWriterSyslog(LogLevelVar LogLevelFlags, FieldsVar []LogField, NFieldsVar uint, UserDataVar uintptr) LogWriterOutput {	942		func LogWriterSyslog(LogLevelVar LogLevelFlags, FieldsVar []LogField, NFieldsVar uint, UserDataVar uintptr) LogWriterOutput {
929		943
930	cret := xLogWriterSyslog(LogLevelVar, FieldsVar, NFieldsVar, UserDataVar)	944		cret := xLogWriterSyslog(LogLevelVar, FieldsVar, NFieldsVar, UserDataVar)
		945	+
931	return cret	946		return cret
932	}	947		}
933		948

@@ -1008,6 +1023,7 @@ var xPrintfStringUpperBound func(string, []interface{}) uint
1008	func PrintfStringUpperBound(FormatVar string, ArgsVar []interface{}) uint {	1023		func PrintfStringUpperBound(FormatVar string, ArgsVar []interface{}) uint {
1009		1024
1010	cret := xPrintfStringUpperBound(FormatVar, ArgsVar)	1025		cret := xPrintfStringUpperBound(FormatVar, ArgsVar)
		1026	+
1011	return cret	1027		return cret
1012	}	1028		}
1013		1029

@@ -1062,6 +1078,7 @@ func SetPrintHandler(FuncVar *PrintFunc) uintptr {
1062	}	1078		}
1063		1079
1064	cret := xSetPrintHandler(FuncVarRef)	1080		cret := xSetPrintHandler(FuncVarRef)
		1081	+
1065	return cret	1082		return cret
1066	}	1083		}
1067		1084

@@ -1100,6 +1117,7 @@ func SetPrinterrHandler(FuncVar *PrintFunc) uintptr {
1100	}	1117		}
1101		1118
1102	cret := xSetPrinterrHandler(FuncVarRef)	1119		cret := xSetPrinterrHandler(FuncVarRef)
		1120	+
1103	return cret	1121		return cret
1104	}	1122		}
1105		1123

M v4/glib/gpathbuf.go +1 -0


@@ -277,6 +277,7 @@ var xPathBufEqual func(uintptr, uintptr) bool
277	func PathBufEqual(V1Var uintptr, V2Var uintptr) bool {	277		func PathBufEqual(V1Var uintptr, V2Var uintptr) bool {
278		278
279	cret := xPathBufEqual(V1Var, V2Var)	279		cret := xPathBufEqual(V1Var, V2Var)
		280	+
280	return cret	281		return cret
281	}	282		}
282		283

M v4/glib/gpattern.go +3 -0


@@ -147,6 +147,7 @@ func PatternMatch(PspecVar *PatternSpec, StringLengthVar uint, StringVar string,
147	defer core.GFreeNullable(StringReversedVarPtr)	147		defer core.GFreeNullable(StringReversedVarPtr)
148		148
149	cret := xPatternMatch(PspecVar, StringLengthVar, StringVar, StringReversedVarPtr)	149		cret := xPatternMatch(PspecVar, StringLengthVar, StringVar, StringReversedVarPtr)
		150	+
150	return cret	151		return cret
151	}	152		}
152		153

@@ -161,6 +162,7 @@ var xPatternMatchSimple func(string, string) bool
161	func PatternMatchSimple(PatternVar string, StringVar string) bool {	162		func PatternMatchSimple(PatternVar string, StringVar string) bool {
162		163
163	cret := xPatternMatchSimple(PatternVar, StringVar)	164		cret := xPatternMatchSimple(PatternVar, StringVar)
		165	+
164	return cret	166		return cret
165	}	167		}
166		168

@@ -174,6 +176,7 @@ var xPatternMatchString func(*PatternSpec, string) bool
174	func PatternMatchString(PspecVar *PatternSpec, StringVar string) bool {	176		func PatternMatchString(PspecVar *PatternSpec, StringVar string) bool {
175		177
176	cret := xPatternMatchString(PspecVar, StringVar)	178		cret := xPatternMatchString(PspecVar, StringVar)
		179	+
177	return cret	180		return cret
178	}	181		}
179		182

M v4/glib/gpoll.go +1 -0


@@ -58,6 +58,7 @@ var xPoll func(*PollFD, uint, int) int
58	func Poll(FdsVar *PollFD, NfdsVar uint, TimeoutVar int) int {	58		func Poll(FdsVar *PollFD, NfdsVar uint, TimeoutVar int) int {
59		59
60	cret := xPoll(FdsVar, NfdsVar, TimeoutVar)	60		cret := xPoll(FdsVar, NfdsVar, TimeoutVar)
		61	+
61	return cret	62		return cret
62	}	63		}
63		64

M v4/glib/gprimes.go +1 -0


@@ -17,6 +17,7 @@ var xSpacedPrimesClosest func(uint) uint
17	func SpacedPrimesClosest(NumVar uint) uint {	17		func SpacedPrimesClosest(NumVar uint) uint {
18		18
19	cret := xSpacedPrimesClosest(NumVar)	19		cret := xSpacedPrimesClosest(NumVar)
		20	+
20	return cret	21		return cret
21	}	22		}
22		23

M v4/glib/gprintf.go +7 -0


@@ -15,6 +15,7 @@ var xFprintf func(uintptr, string, ...interface{}) int
15	func Fprintf(FileVar uintptr, FormatVar string, varArgs ...interface{}) int {	15		func Fprintf(FileVar uintptr, FormatVar string, varArgs ...interface{}) int {
16		16
17	cret := xFprintf(FileVar, FormatVar, varArgs...)	17		cret := xFprintf(FileVar, FormatVar, varArgs...)
		18	+
18	return cret	19		return cret
19	}	20		}
20		21

@@ -31,6 +32,7 @@ var xPrintf func(string, ...interface{}) int
31	func Printf(FormatVar string, varArgs ...interface{}) int {	32		func Printf(FormatVar string, varArgs ...interface{}) int {
32		33
33	cret := xPrintf(FormatVar, varArgs...)	34		cret := xPrintf(FormatVar, varArgs...)
		35	+
34	return cret	36		return cret
35	}	37		}
36		38

@@ -48,6 +50,7 @@ var xSprintf func(string, string, ...interface{}) int
48	func Sprintf(StringVar string, FormatVar string, varArgs ...interface{}) int {	50		func Sprintf(StringVar string, FormatVar string, varArgs ...interface{}) int {
49		51
50	cret := xSprintf(StringVar, FormatVar, varArgs...)	52		cret := xSprintf(StringVar, FormatVar, varArgs...)
		53	+
51	return cret	54		return cret
52	}	55		}
53		56

@@ -67,6 +70,7 @@ var xVasprintf func(*string, string, []interface{}) int
67	func Vasprintf(StringVar *string, FormatVar string, ArgsVar []interface{}) int {	70		func Vasprintf(StringVar *string, FormatVar string, ArgsVar []interface{}) int {
68		71
69	cret := xVasprintf(StringVar, FormatVar, ArgsVar)	72		cret := xVasprintf(StringVar, FormatVar, ArgsVar)
		73	+
70	return cret	74		return cret
71	}	75		}
72		76

@@ -79,6 +83,7 @@ var xVfprintf func(uintptr, string, []interface{}) int
79	func Vfprintf(FileVar uintptr, FormatVar string, ArgsVar []interface{}) int {	83		func Vfprintf(FileVar uintptr, FormatVar string, ArgsVar []interface{}) int {
80		84
81	cret := xVfprintf(FileVar, FormatVar, ArgsVar)	85		cret := xVfprintf(FileVar, FormatVar, ArgsVar)
		86	+
82	return cret	87		return cret
83	}	88		}
84		89

@@ -91,6 +96,7 @@ var xVprintf func(string, []interface{}) int
91	func Vprintf(FormatVar string, ArgsVar []interface{}) int {	96		func Vprintf(FormatVar string, ArgsVar []interface{}) int {
92		97
93	cret := xVprintf(FormatVar, ArgsVar)	98		cret := xVprintf(FormatVar, ArgsVar)
		99	+
94	return cret	100		return cret
95	}	101		}
96		102

@@ -103,6 +109,7 @@ var xVsprintf func(string, string, []interface{}) int
103	func Vsprintf(StringVar string, FormatVar string, ArgsVar []interface{}) int {	109		func Vsprintf(StringVar string, FormatVar string, ArgsVar []interface{}) int {
104		110
105	cret := xVsprintf(StringVar, FormatVar, ArgsVar)	111		cret := xVsprintf(StringVar, FormatVar, ArgsVar)
		112	+
106	return cret	113		return cret
107	}	114		}
108		115

M v4/glib/gquark.go +6 -0


@@ -50,6 +50,7 @@ func InternStaticString(StringVar *string) string {
50	defer core.GFreeNullable(StringVarPtr)	50		defer core.GFreeNullable(StringVarPtr)
51		51
52	cret := xInternStaticString(StringVarPtr)	52		cret := xInternStaticString(StringVarPtr)
		53	+
53	return cret	54		return cret
54	}	55		}
55		56

@@ -68,6 +69,7 @@ func InternString(StringVar *string) string {
68	defer core.GFreeNullable(StringVarPtr)	69		defer core.GFreeNullable(StringVarPtr)
69		70
70	cret := xInternString(StringVarPtr)	71		cret := xInternString(StringVarPtr)
		72	+
71	return cret	73		return cret
72	}	74		}
73		75

@@ -95,6 +97,7 @@ func QuarkFromStaticString(StringVar *string) Quark {
95	defer core.GFreeNullable(StringVarPtr)	97		defer core.GFreeNullable(StringVarPtr)
96		98
97	cret := xQuarkFromStaticString(StringVarPtr)	99		cret := xQuarkFromStaticString(StringVarPtr)
		100	+
98	return cret	101		return cret
99	}	102		}
100		103

@@ -113,6 +116,7 @@ func QuarkFromString(StringVar *string) Quark {
113	defer core.GFreeNullable(StringVarPtr)	116		defer core.GFreeNullable(StringVarPtr)
114		117
115	cret := xQuarkFromString(StringVarPtr)	118		cret := xQuarkFromString(StringVarPtr)
		119	+
116	return cret	120		return cret
117	}	121		}
118		122

@@ -122,6 +126,7 @@ var xQuarkToString func(Quark) string
122	func QuarkToString(QuarkVar Quark) string {	126		func QuarkToString(QuarkVar Quark) string {
123		127
124	cret := xQuarkToString(QuarkVar)	128		cret := xQuarkToString(QuarkVar)
		129	+
125	return cret	130		return cret
126	}	131		}
127		132

@@ -141,6 +146,7 @@ func QuarkTryString(StringVar *string) Quark {
141	defer core.GFreeNullable(StringVarPtr)	146		defer core.GFreeNullable(StringVarPtr)
142		147
143	cret := xQuarkTryString(StringVarPtr)	148		cret := xQuarkTryString(StringVarPtr)
		149	+
144	return cret	150		return cret
145	}	151		}
146		152

M v4/glib/grand.go +4 -0


@@ -145,6 +145,7 @@ var xRandomDouble func() float64
145	func RandomDouble() float64 {	145		func RandomDouble() float64 {
146		146
147	cret := xRandomDouble()	147		cret := xRandomDouble()
		148	+
148	return cret	149		return cret
149	}	150		}
150		151

@@ -155,6 +156,7 @@ var xRandomDoubleRange func(float64, float64) float64
155	func RandomDoubleRange(BeginVar float64, EndVar float64) float64 {	156		func RandomDoubleRange(BeginVar float64, EndVar float64) float64 {
156		157
157	cret := xRandomDoubleRange(BeginVar, EndVar)	158		cret := xRandomDoubleRange(BeginVar, EndVar)
		159	+
158	return cret	160		return cret
159	}	161		}
160		162

@@ -165,6 +167,7 @@ var xRandomInt func() uint32
165	func RandomInt() uint32 {	167		func RandomInt() uint32 {
166		168
167	cret := xRandomInt()	169		cret := xRandomInt()
		170	+
168	return cret	171		return cret
169	}	172		}
170		173

@@ -175,6 +178,7 @@ var xRandomIntRange func(int32, int32) int32
175	func RandomIntRange(BeginVar int32, EndVar int32) int32 {	178		func RandomIntRange(BeginVar int32, EndVar int32) int32 {
176		179
177	cret := xRandomIntRange(BeginVar, EndVar)	180		cret := xRandomIntRange(BeginVar, EndVar)
		181	+
178	return cret	182		return cret
179	}	183		}
180		184

M v4/glib/grcbox.go +10 -0


@@ -14,6 +14,7 @@ var xAtomicRcBoxAcquire func(uintptr) uintptr
14	func AtomicRcBoxAcquire(MemBlockVar uintptr) uintptr {	14		func AtomicRcBoxAcquire(MemBlockVar uintptr) uintptr {
15		15
16	cret := xAtomicRcBoxAcquire(MemBlockVar)	16		cret := xAtomicRcBoxAcquire(MemBlockVar)
		17	+
17	return cret	18		return cret
18	}	19		}
19		20

@@ -30,6 +31,7 @@ var xAtomicRcBoxAlloc func(uint) uintptr
30	func AtomicRcBoxAlloc(BlockSizeVar uint) uintptr {	31		func AtomicRcBoxAlloc(BlockSizeVar uint) uintptr {
31		32
32	cret := xAtomicRcBoxAlloc(BlockSizeVar)	33		cret := xAtomicRcBoxAlloc(BlockSizeVar)
		34	+
33	return cret	35		return cret
34	}	36		}
35		37

@@ -48,6 +50,7 @@ var xAtomicRcBoxAlloc0 func(uint) uintptr
48	func AtomicRcBoxAlloc0(BlockSizeVar uint) uintptr {	50		func AtomicRcBoxAlloc0(BlockSizeVar uint) uintptr {
49		51
50	cret := xAtomicRcBoxAlloc0(BlockSizeVar)	52		cret := xAtomicRcBoxAlloc0(BlockSizeVar)
		53	+
51	return cret	54		return cret
52	}	55		}
53		56

@@ -59,6 +62,7 @@ var xAtomicRcBoxDup func(uint, uintptr) uintptr
59	func AtomicRcBoxDup(BlockSizeVar uint, MemBlockVar uintptr) uintptr {	62		func AtomicRcBoxDup(BlockSizeVar uint, MemBlockVar uintptr) uintptr {
60		63
61	cret := xAtomicRcBoxDup(BlockSizeVar, MemBlockVar)	64		cret := xAtomicRcBoxDup(BlockSizeVar, MemBlockVar)
		65	+
62	return cret	66		return cret
63	}	67		}
64		68

@@ -68,6 +72,7 @@ var xAtomicRcBoxGetSize func(uintptr) uint
68	func AtomicRcBoxGetSize(MemBlockVar uintptr) uint {	72		func AtomicRcBoxGetSize(MemBlockVar uintptr) uint {
69		73
70	cret := xAtomicRcBoxGetSize(MemBlockVar)	74		cret := xAtomicRcBoxGetSize(MemBlockVar)
		75	+
71	return cret	76		return cret
72	}	77		}
73		78

@@ -122,6 +127,7 @@ var xRcBoxAcquire func(uintptr) uintptr
122	func RcBoxAcquire(MemBlockVar uintptr) uintptr {	127		func RcBoxAcquire(MemBlockVar uintptr) uintptr {
123		128
124	cret := xRcBoxAcquire(MemBlockVar)	129		cret := xRcBoxAcquire(MemBlockVar)
		130	+
125	return cret	131		return cret
126	}	132		}
127		133

@@ -138,6 +144,7 @@ var xRcBoxAlloc func(uint) uintptr
138	func RcBoxAlloc(BlockSizeVar uint) uintptr {	144		func RcBoxAlloc(BlockSizeVar uint) uintptr {
139		145
140	cret := xRcBoxAlloc(BlockSizeVar)	146		cret := xRcBoxAlloc(BlockSizeVar)
		147	+
141	return cret	148		return cret
142	}	149		}
143		150

@@ -156,6 +163,7 @@ var xRcBoxAlloc0 func(uint) uintptr
156	func RcBoxAlloc0(BlockSizeVar uint) uintptr {	163		func RcBoxAlloc0(BlockSizeVar uint) uintptr {
157		164
158	cret := xRcBoxAlloc0(BlockSizeVar)	165		cret := xRcBoxAlloc0(BlockSizeVar)
		166	+
159	return cret	167		return cret
160	}	168		}
161		169

@@ -167,6 +175,7 @@ var xRcBoxDup func(uint, uintptr) uintptr
167	func RcBoxDup(BlockSizeVar uint, MemBlockVar uintptr) uintptr {	175		func RcBoxDup(BlockSizeVar uint, MemBlockVar uintptr) uintptr {
168		176
169	cret := xRcBoxDup(BlockSizeVar, MemBlockVar)	177		cret := xRcBoxDup(BlockSizeVar, MemBlockVar)
		178	+
170	return cret	179		return cret
171	}	180		}
172		181

@@ -176,6 +185,7 @@ var xRcBoxGetSize func(uintptr) uint
176	func RcBoxGetSize(MemBlockVar uintptr) uint {	185		func RcBoxGetSize(MemBlockVar uintptr) uint {
177		186
178	cret := xRcBoxGetSize(MemBlockVar)	187		cret := xRcBoxGetSize(MemBlockVar)
		188	+
179	return cret	189		return cret
180	}	190		}
181		191

M v4/glib/grefcount.go +4 -0


@@ -53,6 +53,7 @@ var xAtomicRefCountCompare func(int, int) bool
53	func AtomicRefCountCompare(ArcVar int, ValVar int) bool {	53		func AtomicRefCountCompare(ArcVar int, ValVar int) bool {
54		54
55	cret := xAtomicRefCountCompare(ArcVar, ValVar)	55		cret := xAtomicRefCountCompare(ArcVar, ValVar)
		56	+
56	return cret	57		return cret
57	}	58		}
58		59

@@ -66,6 +67,7 @@ var xAtomicRefCountDec func(int) bool
66	func AtomicRefCountDec(ArcVar int) bool {	67		func AtomicRefCountDec(ArcVar int) bool {
67		68
68	cret := xAtomicRefCountDec(ArcVar)	69		cret := xAtomicRefCountDec(ArcVar)
		70	+
69	return cret	71		return cret
70	}	72		}
71		73

@@ -93,6 +95,7 @@ var xRefCountCompare func(int, int) bool
93	func RefCountCompare(RcVar int, ValVar int) bool {	95		func RefCountCompare(RcVar int, ValVar int) bool {
94		96
95	cret := xRefCountCompare(RcVar, ValVar)	97		cret := xRefCountCompare(RcVar, ValVar)
		98	+
96	return cret	99		return cret
97	}	100		}
98		101

@@ -106,6 +109,7 @@ var xRefCountDec func(int) bool
106	func RefCountDec(RcVar int) bool {	109		func RefCountDec(RcVar int) bool {
107		110
108	cret := xRefCountDec(RcVar)	111		cret := xRefCountDec(RcVar)
		112	+
109	return cret	113		return cret
110	}	114		}
111		115

M v4/glib/grefstring.go +6 -0


@@ -21,6 +21,7 @@ var xRefStringAcquire func(string) string
21	func RefStringAcquire(StrVar string) string {	21		func RefStringAcquire(StrVar string) string {
22		22
23	cret := xRefStringAcquire(StrVar)	23		cret := xRefStringAcquire(StrVar)
		24	+
24	return cret	25		return cret
25	}	26		}
26		27

@@ -35,6 +36,7 @@ var xRefStringEqual func(string, string) bool
35	func RefStringEqual(Str1Var string, Str2Var string) bool {	36		func RefStringEqual(Str1Var string, Str2Var string) bool {
36		37
37	cret := xRefStringEqual(Str1Var, Str2Var)	38		cret := xRefStringEqual(Str1Var, Str2Var)
		39	+
38	return cret	40		return cret
39	}	41		}
40		42

@@ -44,6 +46,7 @@ var xRefStringLength func(string) uint
44	func RefStringLength(StrVar string) uint {	46		func RefStringLength(StrVar string) uint {
45		47
46	cret := xRefStringLength(StrVar)	48		cret := xRefStringLength(StrVar)
		49	+
47	return cret	50		return cret
48	}	51		}
49		52

@@ -54,6 +57,7 @@ var xRefStringNew func(string) string
54	func RefStringNew(StrVar string) string {	57		func RefStringNew(StrVar string) string {
55		58
56	cret := xRefStringNew(StrVar)	59		cret := xRefStringNew(StrVar)
		60	+
57	return cret	61		return cret
58	}	62		}
59		63

@@ -68,6 +72,7 @@ var xRefStringNewIntern func(string) string
68	func RefStringNewIntern(StrVar string) string {	72		func RefStringNewIntern(StrVar string) string {
69		73
70	cret := xRefStringNewIntern(StrVar)	74		cret := xRefStringNewIntern(StrVar)
		75	+
71	return cret	76		return cret
72	}	77		}
73		78

@@ -81,6 +86,7 @@ var xRefStringNewLen func(string, int) string
81	func RefStringNewLen(StrVar string, LenVar int) string {	86		func RefStringNewLen(StrVar string, LenVar int) string {
82		87
83	cret := xRefStringNewLen(StrVar, LenVar)	88		cret := xRefStringNewLen(StrVar, LenVar)
		89	+
84	return cret	90		return cret
85	}	91		}
86		92

M v4/glib/gregex.go +5 -0


@@ -1504,6 +1504,7 @@ func RegexCheckReplacement(ReplacementVar string, HasReferencesVar *bool) (bool,
1504	var cerr *Error	1504		var cerr *Error
1505		1505
1506	cret := xRegexCheckReplacement(ReplacementVar, HasReferencesVar, &cerr)	1506		cret := xRegexCheckReplacement(ReplacementVar, HasReferencesVar, &cerr)
		1507	+
1507	if cerr == nil {	1508		if cerr == nil {
1508	return cret, nil	1509		return cret, nil
1509	}	1510		}

@@ -1521,6 +1522,7 @@ var xRegexEscapeNul func(string, int) string
1521	func RegexEscapeNul(StringVar string, LengthVar int) string {	1522		func RegexEscapeNul(StringVar string, LengthVar int) string {
1522		1523
1523	cret := xRegexEscapeNul(StringVar, LengthVar)	1524		cret := xRegexEscapeNul(StringVar, LengthVar)
		1525	+
1524	return cret	1526		return cret
1525	}	1527		}
1526		1528

@@ -1536,6 +1538,7 @@ var xRegexEscapeString func(string, int) string
1536	func RegexEscapeString(StringVar string, LengthVar int) string {	1538		func RegexEscapeString(StringVar string, LengthVar int) string {
1537		1539
1538	cret := xRegexEscapeString(StringVar, LengthVar)	1540		cret := xRegexEscapeString(StringVar, LengthVar)
		1541	+
1539	return cret	1542		return cret
1540	}	1543		}
1541		1544

@@ -1554,6 +1557,7 @@ var xRegexMatchSimple func(string, string, RegexCompileFlags, RegexMatchFlags) b
1554	func RegexMatchSimple(PatternVar string, StringVar string, CompileOptionsVar RegexCompileFlags, MatchOptionsVar RegexMatchFlags) bool {	1557		func RegexMatchSimple(PatternVar string, StringVar string, CompileOptionsVar RegexCompileFlags, MatchOptionsVar RegexMatchFlags) bool {
1555		1558
1556	cret := xRegexMatchSimple(PatternVar, StringVar, CompileOptionsVar, MatchOptionsVar)	1559		cret := xRegexMatchSimple(PatternVar, StringVar, CompileOptionsVar, MatchOptionsVar)
		1560	+
1557	return cret	1561		return cret
1558	}	1562		}
1559		1563

@@ -1589,6 +1593,7 @@ var xRegexSplitSimple func(string, string, RegexCompileFlags, RegexMatchFlags) [
1589	func RegexSplitSimple(PatternVar string, StringVar string, CompileOptionsVar RegexCompileFlags, MatchOptionsVar RegexMatchFlags) []string {	1593		func RegexSplitSimple(PatternVar string, StringVar string, CompileOptionsVar RegexCompileFlags, MatchOptionsVar RegexMatchFlags) []string {
1590		1594
1591	cret := xRegexSplitSimple(PatternVar, StringVar, CompileOptionsVar, MatchOptionsVar)	1595		cret := xRegexSplitSimple(PatternVar, StringVar, CompileOptionsVar, MatchOptionsVar)
		1596	+
1592	return cret	1597		return cret
1593	}	1598		}
1594		1599

M v4/glib/gsequence.go +3 -0


@@ -522,6 +522,7 @@ var xSequenceGet func(*SequenceIter) uintptr
522	func SequenceGet(IterVar *SequenceIter) uintptr {	522		func SequenceGet(IterVar *SequenceIter) uintptr {
523		523
524	cret := xSequenceGet(IterVar)	524		cret := xSequenceGet(IterVar)
		525	+
525	return cret	526		return cret
526	}	527		}
527		528

@@ -531,6 +532,7 @@ var xSequenceInsertBefore func(SequenceIter, uintptr) SequenceIter
531	func SequenceInsertBefore(IterVar SequenceIter, DataVar uintptr) SequenceIter {	532		func SequenceInsertBefore(IterVar SequenceIter, DataVar uintptr) SequenceIter {
532		533
533	cret := xSequenceInsertBefore(IterVar, DataVar)	534		cret := xSequenceInsertBefore(IterVar, DataVar)
		535	+
534	return cret	536		return cret
535	}	537		}
536		538

@@ -573,6 +575,7 @@ var xSequenceRangeGetMidpoint func(SequenceIter, SequenceIter) *SequenceIter
573	func SequenceRangeGetMidpoint(BeginVar SequenceIter, EndVar SequenceIter) *SequenceIter {	575		func SequenceRangeGetMidpoint(BeginVar SequenceIter, EndVar SequenceIter) *SequenceIter {
574		576
575	cret := xSequenceRangeGetMidpoint(BeginVar, EndVar)	577		cret := xSequenceRangeGetMidpoint(BeginVar, EndVar)
		578	+
576	return cret	579		return cret
577	}	580		}
578		581

M v4/glib/gshell.go +3 -0


@@ -43,6 +43,7 @@ func ShellParseArgv(CommandLineVar string, ArgcpVar int, ArgvpVar []string) (b
43	var cerr *Error	43		var cerr *Error
44		44
45	cret := xShellParseArgv(CommandLineVar, ArgcpVar, ArgvpVar, &cerr)	45		cret := xShellParseArgv(CommandLineVar, ArgcpVar, ArgvpVar, &cerr)
		46	+
46	if cerr == nil {	47		if cerr == nil {
47	return cret, nil	48		return cret, nil
48	}	49		}

@@ -65,6 +66,7 @@ var xShellQuote func(string) string
65	func ShellQuote(UnquotedStringVar string) string {	66		func ShellQuote(UnquotedStringVar string) string {
66		67
67	cret := xShellQuote(UnquotedStringVar)	68		cret := xShellQuote(UnquotedStringVar)
		69	+
68	return cret	70		return cret
69	}	71		}
70		72

@@ -101,6 +103,7 @@ func ShellUnquote(QuotedStringVar string) (string, error) {
101	var cerr *Error	103		var cerr *Error
102		104
103	cret := xShellUnquote(QuotedStringVar, &cerr)	105		cret := xShellUnquote(QuotedStringVar, &cerr)
		106	+
104	if cerr == nil {	107		if cerr == nil {
105	return cret, nil	108		return cret, nil
106	}	109		}

M v4/glib/gslice.go +5 -0


@@ -34,6 +34,7 @@ var xSliceAlloc func(uint) uintptr
34	func SliceAlloc(BlockSizeVar uint) uintptr {	34		func SliceAlloc(BlockSizeVar uint) uintptr {
35		35
36	cret := xSliceAlloc(BlockSizeVar)	36		cret := xSliceAlloc(BlockSizeVar)
		37	+
37	return cret	38		return cret
38	}	39		}
39		40

@@ -47,6 +48,7 @@ var xSliceAlloc0 func(uint) uintptr
47	func SliceAlloc0(BlockSizeVar uint) uintptr {	48		func SliceAlloc0(BlockSizeVar uint) uintptr {
48		49
49	cret := xSliceAlloc0(BlockSizeVar)	50		cret := xSliceAlloc0(BlockSizeVar)
		51	+
50	return cret	52		return cret
51	}	53		}
52		54

@@ -62,6 +64,7 @@ var xSliceCopy func(uint, uintptr) uintptr
62	func SliceCopy(BlockSizeVar uint, MemBlockVar uintptr) uintptr {	64		func SliceCopy(BlockSizeVar uint, MemBlockVar uintptr) uintptr {
63		65
64	cret := xSliceCopy(BlockSizeVar, MemBlockVar)	66		cret := xSliceCopy(BlockSizeVar, MemBlockVar)
		67	+
65	return cret	68		return cret
66	}	69		}
67		70

@@ -111,6 +114,7 @@ var xSliceGetConfig func(SliceConfig) int64
111	func SliceGetConfig(CkeyVar SliceConfig) int64 {	114		func SliceGetConfig(CkeyVar SliceConfig) int64 {
112		115
113	cret := xSliceGetConfig(CkeyVar)	116		cret := xSliceGetConfig(CkeyVar)
		117	+
114	return cret	118		return cret
115	}	119		}
116		120

@@ -119,6 +123,7 @@ var xSliceGetConfigState func(SliceConfig, int64, uint) int64
119	func SliceGetConfigState(CkeyVar SliceConfig, AddressVar int64, NValuesVar uint) int64 {	123		func SliceGetConfigState(CkeyVar SliceConfig, AddressVar int64, NValuesVar uint) int64 {
120		124
121	cret := xSliceGetConfigState(CkeyVar, AddressVar, NValuesVar)	125		cret := xSliceGetConfigState(CkeyVar, AddressVar, NValuesVar)
		126	+
122	return cret	127		return cret
123	}	128		}
124		129

M v4/glib/gspawn.go +9 -0


@@ -177,6 +177,7 @@ func SpawnAsync(WorkingDirectoryVar *string, ArgvVar []string, EnvpVar []string,
177	defer core.GFreeNullable(WorkingDirectoryVarPtr)	177		defer core.GFreeNullable(WorkingDirectoryVarPtr)
178		178
179	cret := xSpawnAsync(WorkingDirectoryVarPtr, ArgvVar, EnvpVar, FlagsVar, ChildSetupVarRef, UserDataVar, ChildPidVar, &cerr)	179		cret := xSpawnAsync(WorkingDirectoryVarPtr, ArgvVar, EnvpVar, FlagsVar, ChildSetupVarRef, UserDataVar, ChildPidVar, &cerr)
		180	+
180	if cerr == nil {	181		if cerr == nil {
181	return cret, nil	182		return cret, nil
182	}	183		}

@@ -212,6 +213,7 @@ func SpawnAsyncWithFds(WorkingDirectoryVar *string, ArgvVar []string, EnvpVar []
212	defer core.GFreeNullable(WorkingDirectoryVarPtr)	213		defer core.GFreeNullable(WorkingDirectoryVarPtr)
213		214
214	cret := xSpawnAsyncWithFds(WorkingDirectoryVarPtr, ArgvVar, EnvpVar, FlagsVar, ChildSetupVarRef, UserDataVar, ChildPidVar, StdinFdVar, StdoutFdVar, StderrFdVar, &cerr)	215		cret := xSpawnAsyncWithFds(WorkingDirectoryVarPtr, ArgvVar, EnvpVar, FlagsVar, ChildSetupVarRef, UserDataVar, ChildPidVar, StdinFdVar, StdoutFdVar, StderrFdVar, &cerr)
		216	+
215	if cerr == nil {	217		if cerr == nil {
216	return cret, nil	218		return cret, nil
217	}	219		}

@@ -245,6 +247,7 @@ func SpawnAsyncWithPipes(WorkingDirectoryVar *string, ArgvVar []string, EnvpVar
245	defer core.GFreeNullable(WorkingDirectoryVarPtr)	247		defer core.GFreeNullable(WorkingDirectoryVarPtr)
246		248
247	cret := xSpawnAsyncWithPipes(WorkingDirectoryVarPtr, ArgvVar, EnvpVar, FlagsVar, ChildSetupVarRef, UserDataVar, ChildPidVar, StandardInputVar, StandardOutputVar, StandardErrorVar, &cerr)	249		cret := xSpawnAsyncWithPipes(WorkingDirectoryVarPtr, ArgvVar, EnvpVar, FlagsVar, ChildSetupVarRef, UserDataVar, ChildPidVar, StandardInputVar, StandardOutputVar, StandardErrorVar, &cerr)
		250	+
248	if cerr == nil {	251		if cerr == nil {
249	return cret, nil	252		return cret, nil
250	}	253		}

@@ -470,6 +473,7 @@ func SpawnAsyncWithPipesAndFds(WorkingDirectoryVar *string, ArgvVar []string, En
470	defer core.GFreeNullable(WorkingDirectoryVarPtr)	473		defer core.GFreeNullable(WorkingDirectoryVarPtr)
471		474
472	cret := xSpawnAsyncWithPipesAndFds(WorkingDirectoryVarPtr, ArgvVar, EnvpVar, FlagsVar, ChildSetupVarRef, UserDataVar, StdinFdVar, StdoutFdVar, StderrFdVar, SourceFdsVar, TargetFdsVar, NFdsVar, ChildPidOutVar, StdinPipeOutVar, StdoutPipeOutVar, StderrPipeOutVar, &cerr)	475		cret := xSpawnAsyncWithPipesAndFds(WorkingDirectoryVarPtr, ArgvVar, EnvpVar, FlagsVar, ChildSetupVarRef, UserDataVar, StdinFdVar, StdoutFdVar, StderrFdVar, SourceFdsVar, TargetFdsVar, NFdsVar, ChildPidOutVar, StdinPipeOutVar, StdoutPipeOutVar, StderrPipeOutVar, &cerr)
		476	+
473	if cerr == nil {	477		if cerr == nil {
474	return cret, nil	478		return cret, nil
475	}	479		}

@@ -491,6 +495,7 @@ func SpawnCheckExitStatus(WaitStatusVar int) (bool, error) {
491	var cerr *Error	495		var cerr *Error
492		496
493	cret := xSpawnCheckExitStatus(WaitStatusVar, &cerr)	497		cret := xSpawnCheckExitStatus(WaitStatusVar, &cerr)
		498	+
494	if cerr == nil {	499		if cerr == nil {
495	return cret, nil	500		return cret, nil
496	}	501		}

@@ -543,6 +548,7 @@ func SpawnCheckWaitStatus(WaitStatusVar int) (bool, error) {
543	var cerr *Error	548		var cerr *Error
544		549
545	cret := xSpawnCheckWaitStatus(WaitStatusVar, &cerr)	550		cret := xSpawnCheckWaitStatus(WaitStatusVar, &cerr)
		551	+
546	if cerr == nil {	552		if cerr == nil {
547	return cret, nil	553		return cret, nil
548	}	554		}

@@ -578,6 +584,7 @@ func SpawnCommandLineAsync(CommandLineVar string) (bool, error) {
578	var cerr *Error	584		var cerr *Error
579		585
580	cret := xSpawnCommandLineAsync(CommandLineVar, &cerr)	586		cret := xSpawnCommandLineAsync(CommandLineVar, &cerr)
		587	+
581	if cerr == nil {	588		if cerr == nil {
582	return cret, nil	589		return cret, nil
583	}	590		}

@@ -620,6 +627,7 @@ func SpawnCommandLineSync(CommandLineVar string, StandardOutputVar *[]byte, Stan
620	var cerr *Error	627		var cerr *Error
621		628
622	cret := xSpawnCommandLineSync(CommandLineVar, StandardOutputVar, StandardErrorVar, WaitStatusVar, &cerr)	629		cret := xSpawnCommandLineSync(CommandLineVar, StandardOutputVar, StandardErrorVar, WaitStatusVar, &cerr)
		630	+
623	if cerr == nil {	631		if cerr == nil {
624	return cret, nil	632		return cret, nil
625	}	633		}

@@ -674,6 +682,7 @@ func SpawnSync(WorkingDirectoryVar *string, ArgvVar []string, EnvpVar []string,
674	defer core.GFreeNullable(WorkingDirectoryVarPtr)	682		defer core.GFreeNullable(WorkingDirectoryVarPtr)
675		683
676	cret := xSpawnSync(WorkingDirectoryVarPtr, ArgvVar, EnvpVar, FlagsVar, ChildSetupVarRef, UserDataVar, StandardOutputVar, StandardErrorVar, WaitStatusVar, &cerr)	684		cret := xSpawnSync(WorkingDirectoryVarPtr, ArgvVar, EnvpVar, FlagsVar, ChildSetupVarRef, UserDataVar, StandardOutputVar, StandardErrorVar, WaitStatusVar, &cerr)
		685	+
677	if cerr == nil {	686		if cerr == nil {
678	return cret, nil	687		return cret, nil
679	}	688		}

M v4/glib/gstdio.go +17 -0


@@ -38,6 +38,7 @@ var xAccess func(string, int) int
38	func Access(FilenameVar string, ModeVar int) int {	38		func Access(FilenameVar string, ModeVar int) int {
39		39
40	cret := xAccess(FilenameVar, ModeVar)	40		cret := xAccess(FilenameVar, ModeVar)
		41	+
41	return cret	42		return cret
42	}	43		}
43		44

@@ -50,6 +51,7 @@ var xChdir func(string) int
50	func Chdir(PathVar string) int {	51		func Chdir(PathVar string) int {
51		52
52	cret := xChdir(PathVar)	53		cret := xChdir(PathVar)
		54	+
53	return cret	55		return cret
54	}	56		}
55		57

@@ -68,6 +70,7 @@ var xChmod func(string, int) int
68	func Chmod(FilenameVar string, ModeVar int) int {	70		func Chmod(FilenameVar string, ModeVar int) int {
69		71
70	cret := xChmod(FilenameVar, ModeVar)	72		cret := xChmod(FilenameVar, ModeVar)
		73	+
71	return cret	74		return cret
72	}	75		}
73		76

@@ -94,6 +97,7 @@ func Close(FdVar int) (bool, error) {
94	var cerr *Error	97		var cerr *Error
95		98
96	cret := xClose(FdVar, &cerr)	99		cret := xClose(FdVar, &cerr)
		100	+
97	if cerr == nil {	101		if cerr == nil {
98	return cret, nil	102		return cret, nil
99	}	103		}

@@ -125,6 +129,7 @@ var xCreat func(string, int) int
125	func Creat(FilenameVar string, ModeVar int) int {	129		func Creat(FilenameVar string, ModeVar int) int {
126		130
127	cret := xCreat(FilenameVar, ModeVar)	131		cret := xCreat(FilenameVar, ModeVar)
		132	+
128	return cret	133		return cret
129	}	134		}
130		135

@@ -156,6 +161,7 @@ var xFopen func(string, string) uintptr
156	func Fopen(FilenameVar string, ModeVar string) uintptr {	161		func Fopen(FilenameVar string, ModeVar string) uintptr {
157		162
158	cret := xFopen(FilenameVar, ModeVar)	163		cret := xFopen(FilenameVar, ModeVar)
		164	+
159	return cret	165		return cret
160	}	166		}
161		167

@@ -171,6 +177,7 @@ var xFreopen func(string, string, uintptr) uintptr
171	func Freopen(FilenameVar string, ModeVar string, StreamVar uintptr) uintptr {	177		func Freopen(FilenameVar string, ModeVar string, StreamVar uintptr) uintptr {
172		178
173	cret := xFreopen(FilenameVar, ModeVar, StreamVar)	179		cret := xFreopen(FilenameVar, ModeVar, StreamVar)
		180	+
174	return cret	181		return cret
175	}	182		}
176		183

@@ -187,6 +194,7 @@ var xFsync func(int) int
187	func Fsync(FdVar int) int {	194		func Fsync(FdVar int) int {
188		195
189	cret := xFsync(FdVar)	196		cret := xFsync(FdVar)
		197	+
190	return cret	198		return cret
191	}	199		}
192		200

@@ -202,6 +210,7 @@ var xLstat func(string, *StatBuf) int
202	func Lstat(FilenameVar string, BufVar *StatBuf) int {	210		func Lstat(FilenameVar string, BufVar *StatBuf) int {
203		211
204	cret := xLstat(FilenameVar, BufVar)	212		cret := xLstat(FilenameVar, BufVar)
		213	+
205	return cret	214		return cret
206	}	215		}
207		216

@@ -215,6 +224,7 @@ var xMkdir func(string, int) int
215	func Mkdir(FilenameVar string, ModeVar int) int {	224		func Mkdir(FilenameVar string, ModeVar int) int {
216		225
217	cret := xMkdir(FilenameVar, ModeVar)	226		cret := xMkdir(FilenameVar, ModeVar)
		227	+
218	return cret	228		return cret
219	}	229		}
220		230

@@ -241,6 +251,7 @@ var xOpen func(string, int, int) int
241	func Open(FilenameVar string, FlagsVar int, ModeVar int) int {	251		func Open(FilenameVar string, FlagsVar int, ModeVar int) int {
242		252
243	cret := xOpen(FilenameVar, FlagsVar, ModeVar)	253		cret := xOpen(FilenameVar, FlagsVar, ModeVar)
		254	+
244	return cret	255		return cret
245	}	256		}
246		257

@@ -265,6 +276,7 @@ var xRemove func(string) int
265	func Remove(FilenameVar string) int {	276		func Remove(FilenameVar string) int {
266		277
267	cret := xRemove(FilenameVar)	278		cret := xRemove(FilenameVar)
		279	+
268	return cret	280		return cret
269	}	281		}
270		282

@@ -279,6 +291,7 @@ var xRename func(string, string) int
279	func Rename(OldfilenameVar string, NewfilenameVar string) int {	291		func Rename(OldfilenameVar string, NewfilenameVar string) int {
280		292
281	cret := xRename(OldfilenameVar, NewfilenameVar)	293		cret := xRename(OldfilenameVar, NewfilenameVar)
		294	+
282	return cret	295		return cret
283	}	296		}
284		297

@@ -292,6 +305,7 @@ var xRmdir func(string) int
292	func Rmdir(FilenameVar string) int {	305		func Rmdir(FilenameVar string) int {
293		306
294	cret := xRmdir(FilenameVar)	307		cret := xRmdir(FilenameVar)
		308	+
295	return cret	309		return cret
296	}	310		}
297		311

@@ -320,6 +334,7 @@ var xStat func(string, *StatBuf) int
320	func Stat(FilenameVar string, BufVar *StatBuf) int {	334		func Stat(FilenameVar string, BufVar *StatBuf) int {
321		335
322	cret := xStat(FilenameVar, BufVar)	336		cret := xStat(FilenameVar, BufVar)
		337	+
323	return cret	338		return cret
324	}	339		}
325		340

@@ -336,6 +351,7 @@ var xUnlink func(string) int
336	func Unlink(FilenameVar string) int {	351		func Unlink(FilenameVar string) int {
337		352
338	cret := xUnlink(FilenameVar)	353		cret := xUnlink(FilenameVar)
		354	+
339	return cret	355		return cret
340	}	356		}
341		357

@@ -349,6 +365,7 @@ var xUtime func(string, uintptr) int
349	func Utime(FilenameVar string, UtbVar uintptr) int {	365		func Utime(FilenameVar string, UtbVar uintptr) int {
350		366
351	cret := xUtime(FilenameVar, UtbVar)	367		cret := xUtime(FilenameVar, UtbVar)
		368	+
352	return cret	369		return cret
353	}	370		}
354		371

M v4/glib/gstrfuncs.go +57 -0


@@ -74,6 +74,7 @@ var xAsciiDigitValue func(byte) int
74	func AsciiDigitValue(CVar byte) int {	74		func AsciiDigitValue(CVar byte) int {
75		75
76	cret := xAsciiDigitValue(CVar)	76		cret := xAsciiDigitValue(CVar)
		77	+
77	return cret	78		return cret
78	}	79		}
79		80

@@ -91,6 +92,7 @@ var xAsciiDtostr func(string, int, float64) string
91	func AsciiDtostr(BufferVar string, BufLenVar int, DVar float64) string {	92		func AsciiDtostr(BufferVar string, BufLenVar int, DVar float64) string {
92		93
93	cret := xAsciiDtostr(BufferVar, BufLenVar, DVar)	94		cret := xAsciiDtostr(BufferVar, BufLenVar, DVar)
		95	+
94	return cret	96		return cret
95	}	97		}
96		98

@@ -111,6 +113,7 @@ var xAsciiFormatd func(string, int, string, float64) string
111	func AsciiFormatd(BufferVar string, BufLenVar int, FormatVar string, DVar float64) string {	113		func AsciiFormatd(BufferVar string, BufLenVar int, FormatVar string, DVar float64) string {
112		114
113	cret := xAsciiFormatd(BufferVar, BufLenVar, FormatVar, DVar)	115		cret := xAsciiFormatd(BufferVar, BufLenVar, FormatVar, DVar)
		116	+
114	return cret	117		return cret
115	}	118		}
116		119

@@ -134,6 +137,7 @@ var xAsciiStrcasecmp func(string, string) int
134	func AsciiStrcasecmp(S1Var string, S2Var string) int {	137		func AsciiStrcasecmp(S1Var string, S2Var string) int {
135		138
136	cret := xAsciiStrcasecmp(S1Var, S2Var)	139		cret := xAsciiStrcasecmp(S1Var, S2Var)
		140	+
137	return cret	141		return cret
138	}	142		}
139		143

@@ -144,6 +148,7 @@ var xAsciiStrdown func(string, int) string
144	func AsciiStrdown(StrVar string, LenVar int) string {	148		func AsciiStrdown(StrVar string, LenVar int) string {
145		149
146	cret := xAsciiStrdown(StrVar, LenVar)	150		cret := xAsciiStrdown(StrVar, LenVar)
		151	+
147	return cret	152		return cret
148	}	153		}
149		154

@@ -174,6 +179,7 @@ func AsciiStringToSigned(StrVar string, BaseVar uint, MinVar int64, MaxVar int64
174	var cerr *Error	179		var cerr *Error
175		180
176	cret := xAsciiStringToSigned(StrVar, BaseVar, MinVar, MaxVar, OutNumVar, &cerr)	181		cret := xAsciiStringToSigned(StrVar, BaseVar, MinVar, MaxVar, OutNumVar, &cerr)
		182	+
177	if cerr == nil {	183		if cerr == nil {
178	return cret, nil	184		return cret, nil
179	}	185		}

@@ -209,6 +215,7 @@ func AsciiStringToUnsigned(StrVar string, BaseVar uint, MinVar uint64, MaxVar ui
209	var cerr *Error	215		var cerr *Error
210		216
211	cret := xAsciiStringToUnsigned(StrVar, BaseVar, MinVar, MaxVar, OutNumVar, &cerr)	217		cret := xAsciiStringToUnsigned(StrVar, BaseVar, MinVar, MaxVar, OutNumVar, &cerr)
		218	+
212	if cerr == nil {	219		if cerr == nil {
213	return cret, nil	220		return cret, nil
214	}	221		}

@@ -233,6 +240,7 @@ var xAsciiStrncasecmp func(string, string, uint) int
233	func AsciiStrncasecmp(S1Var string, S2Var string, NVar uint) int {	240		func AsciiStrncasecmp(S1Var string, S2Var string, NVar uint) int {
234		241
235	cret := xAsciiStrncasecmp(S1Var, S2Var, NVar)	242		cret := xAsciiStrncasecmp(S1Var, S2Var, NVar)
		243	+
236	return cret	244		return cret
237	}	245		}
238		246

@@ -264,6 +272,7 @@ var xAsciiStrtod func(string, *string) float64
264	func AsciiStrtod(NptrVar string, EndptrVar *string) float64 {	272		func AsciiStrtod(NptrVar string, EndptrVar *string) float64 {
265		273
266	cret := xAsciiStrtod(NptrVar, EndptrVar)	274		cret := xAsciiStrtod(NptrVar, EndptrVar)
		275	+
267	return cret	276		return cret
268	}	277		}
269		278

@@ -290,6 +299,7 @@ var xAsciiStrtoll func(string, *string, uint) int64
290	func AsciiStrtoll(NptrVar string, EndptrVar *string, BaseVar uint) int64 {	299		func AsciiStrtoll(NptrVar string, EndptrVar *string, BaseVar uint) int64 {
291		300
292	cret := xAsciiStrtoll(NptrVar, EndptrVar, BaseVar)	301		cret := xAsciiStrtoll(NptrVar, EndptrVar, BaseVar)
		302	+
293	return cret	303		return cret
294	}	304		}
295		305

@@ -321,6 +331,7 @@ var xAsciiStrtoull func(string, *string, uint) uint64
321	func AsciiStrtoull(NptrVar string, EndptrVar *string, BaseVar uint) uint64 {	331		func AsciiStrtoull(NptrVar string, EndptrVar *string, BaseVar uint) uint64 {
322		332
323	cret := xAsciiStrtoull(NptrVar, EndptrVar, BaseVar)	333		cret := xAsciiStrtoull(NptrVar, EndptrVar, BaseVar)
		334	+
324	return cret	335		return cret
325	}	336		}
326		337

@@ -331,6 +342,7 @@ var xAsciiStrup func(string, int) string
331	func AsciiStrup(StrVar string, LenVar int) string {	342		func AsciiStrup(StrVar string, LenVar int) string {
332		343
333	cret := xAsciiStrup(StrVar, LenVar)	344		cret := xAsciiStrup(StrVar, LenVar)
		345	+
334	return cret	346		return cret
335	}	347		}
336		348

@@ -349,6 +361,7 @@ var xAsciiTolower func(byte) byte
349	func AsciiTolower(CVar byte) byte {	361		func AsciiTolower(CVar byte) byte {
350		362
351	cret := xAsciiTolower(CVar)	363		cret := xAsciiTolower(CVar)
		364	+
352	return cret	365		return cret
353	}	366		}
354		367

@@ -367,6 +380,7 @@ var xAsciiToupper func(byte) byte
367	func AsciiToupper(CVar byte) byte {	380		func AsciiToupper(CVar byte) byte {
368		381
369	cret := xAsciiToupper(CVar)	382		cret := xAsciiToupper(CVar)
		383	+
370	return cret	384		return cret
371	}	385		}
372		386

@@ -384,6 +398,7 @@ var xAsciiXdigitValue func(byte) int
384	func AsciiXdigitValue(CVar byte) int {	398		func AsciiXdigitValue(CVar byte) int {
385		399
386	cret := xAsciiXdigitValue(CVar)	400		cret := xAsciiXdigitValue(CVar)
		401	+
387	return cret	402		return cret
388	}	403		}
389		404

@@ -394,6 +409,7 @@ var xMemdup func(uintptr, uint) uintptr
394	func Memdup(MemVar uintptr, ByteSizeVar uint) uintptr {	409		func Memdup(MemVar uintptr, ByteSizeVar uint) uintptr {
395		410
396	cret := xMemdup(MemVar, ByteSizeVar)	411		cret := xMemdup(MemVar, ByteSizeVar)
		412	+
397	return cret	413		return cret
398	}	414		}
399		415

@@ -407,6 +423,7 @@ var xMemdup2 func(uintptr, uint) uintptr
407	func Memdup2(MemVar uintptr, ByteSizeVar uint) uintptr {	423		func Memdup2(MemVar uintptr, ByteSizeVar uint) uintptr {
408		424
409	cret := xMemdup2(MemVar, ByteSizeVar)	425		cret := xMemdup2(MemVar, ByteSizeVar)
		426	+
410	return cret	427		return cret
411	}	428		}
412		429

@@ -419,6 +436,7 @@ var xStpcpy func(string, string) string
419	func Stpcpy(DestVar string, SrcVar string) string {	436		func Stpcpy(DestVar string, SrcVar string) string {
420		437
421	cret := xStpcpy(DestVar, SrcVar)	438		cret := xStpcpy(DestVar, SrcVar)
		439	+
422	return cret	440		return cret
423	}	441		}
424		442

@@ -428,6 +446,7 @@ var xStrHasPrefix func(string, string) bool
428	func StrHasPrefix(StrVar string, PrefixVar string) bool {	446		func StrHasPrefix(StrVar string, PrefixVar string) bool {
429		447
430	cret := xStrHasPrefix(StrVar, PrefixVar)	448		cret := xStrHasPrefix(StrVar, PrefixVar)
		449	+
431	return cret	450		return cret
432	}	451		}
433		452

@@ -437,6 +456,7 @@ var xStrHasSuffix func(string, string) bool
437	func StrHasSuffix(StrVar string, SuffixVar string) bool {	456		func StrHasSuffix(StrVar string, SuffixVar string) bool {
438		457
439	cret := xStrHasSuffix(StrVar, SuffixVar)	458		cret := xStrHasSuffix(StrVar, SuffixVar)
		459	+
440	return cret	460		return cret
441	}	461		}
442		462

@@ -447,6 +467,7 @@ var xStrIsAscii func(string) bool
447	func StrIsAscii(StrVar string) bool {	467		func StrIsAscii(StrVar string) bool {
448		468
449	cret := xStrIsAscii(StrVar)	469		cret := xStrIsAscii(StrVar)
		470	+
450	return cret	471		return cret
451	}	472		}
452		473

@@ -477,6 +498,7 @@ var xStrMatchString func(string, string, bool) bool
477	func StrMatchString(SearchTermVar string, PotentialHitVar string, AcceptAlternatesVar bool) bool {	498		func StrMatchString(SearchTermVar string, PotentialHitVar string, AcceptAlternatesVar bool) bool {
478		499
479	cret := xStrMatchString(SearchTermVar, PotentialHitVar, AcceptAlternatesVar)	500		cret := xStrMatchString(SearchTermVar, PotentialHitVar, AcceptAlternatesVar)
		501	+
480	return cret	502		return cret
481	}	503		}
482		504

@@ -506,6 +528,7 @@ func StrToAscii(StrVar string, FromLocaleVar *string) string {
506	defer core.GFreeNullable(FromLocaleVarPtr)	528		defer core.GFreeNullable(FromLocaleVarPtr)
507		529
508	cret := xStrToAscii(StrVar, FromLocaleVarPtr)	530		cret := xStrToAscii(StrVar, FromLocaleVarPtr)
		531	+
509	return cret	532		return cret
510	}	533		}
511		534

@@ -532,6 +555,7 @@ func StrTokenizeAndFold(StringVar string, TranslitLocaleVar *string, AsciiAltern
532	defer core.GFreeNullable(TranslitLocaleVarPtr)	555		defer core.GFreeNullable(TranslitLocaleVarPtr)
533		556
534	cret := xStrTokenizeAndFold(StringVar, TranslitLocaleVarPtr, AsciiAlternatesVar)	557		cret := xStrTokenizeAndFold(StringVar, TranslitLocaleVarPtr, AsciiAlternatesVar)
		558	+
535	return cret	559		return cret
536	}	560		}
537		561

@@ -555,6 +579,7 @@ var xStrcanon func(string, string, byte) string
555	func Strcanon(StringVar string, ValidCharsVar string, SubstitutorVar byte) string {	579		func Strcanon(StringVar string, ValidCharsVar string, SubstitutorVar byte) string {
556		580
557	cret := xStrcanon(StringVar, ValidCharsVar, SubstitutorVar)	581		cret := xStrcanon(StringVar, ValidCharsVar, SubstitutorVar)
		582	+
558	return cret	583		return cret
559	}	584		}
560		585

@@ -565,6 +590,7 @@ var xStrcasecmp func(string, string) int
565	func Strcasecmp(S1Var string, S2Var string) int {	590		func Strcasecmp(S1Var string, S2Var string) int {
566		591
567	cret := xStrcasecmp(S1Var, S2Var)	592		cret := xStrcasecmp(S1Var, S2Var)
		593	+
568	return cret	594		return cret
569	}	595		}
570		596

@@ -582,6 +608,7 @@ var xStrchomp func(string) string
582	func Strchomp(StringVar string) string {	608		func Strchomp(StringVar string) string {
583		609
584	cret := xStrchomp(StringVar)	610		cret := xStrchomp(StringVar)
		611	+
585	return cret	612		return cret
586	}	613		}
587		614

@@ -600,6 +627,7 @@ var xStrchug func(string) string
600	func Strchug(StringVar string) string {	627		func Strchug(StringVar string) string {
601		628
602	cret := xStrchug(StringVar)	629		cret := xStrchug(StringVar)
		630	+
603	return cret	631		return cret
604	}	632		}
605		633

@@ -622,6 +650,7 @@ var xStrcompress func(string) string
622	func Strcompress(SourceVar string) string {	650		func Strcompress(SourceVar string) string {
623		651
624	cret := xStrcompress(SourceVar)	652		cret := xStrcompress(SourceVar)
		653	+
625	return cret	654		return cret
626	}	655		}
627		656

@@ -638,6 +667,7 @@ var xStrconcat func(string, ...interface{}) string
638	func Strconcat(String1Var string, varArgs ...interface{}) string {	667		func Strconcat(String1Var string, varArgs ...interface{}) string {
639		668
640	cret := xStrconcat(String1Var, varArgs...)	669		cret := xStrconcat(String1Var, varArgs...)
		670	+
641	return cret	671		return cret
642	}	672		}
643		673

@@ -666,6 +696,7 @@ func Strdelimit(StringVar string, DelimitersVar *string, NewDelimiterVar byte) s
666	defer core.GFreeNullable(DelimitersVarPtr)	696		defer core.GFreeNullable(DelimitersVarPtr)
667		697
668	cret := xStrdelimit(StringVar, DelimitersVarPtr, NewDelimiterVar)	698		cret := xStrdelimit(StringVar, DelimitersVarPtr, NewDelimiterVar)
		699	+
669	return cret	700		return cret
670	}	701		}
671		702

@@ -675,6 +706,7 @@ var xStrdown func(string) string
675	func Strdown(StringVar string) string {	706		func Strdown(StringVar string) string {
676		707
677	cret := xStrdown(StringVar)	708		cret := xStrdown(StringVar)
		709	+
678	return cret	710		return cret
679	}	711		}
680		712

@@ -687,6 +719,7 @@ func Strdup(StrVar *string) string {
687	defer core.GFreeNullable(StrVarPtr)	719		defer core.GFreeNullable(StrVarPtr)
688		720
689	cret := xStrdup(StrVarPtr)	721		cret := xStrdup(StrVarPtr)
		722	+
690	return cret	723		return cret
691	}	724		}
692		725

@@ -702,6 +735,7 @@ var xStrdupPrintf func(string, ...interface{}) string
702	func StrdupPrintf(FormatVar string, varArgs ...interface{}) string {	735		func StrdupPrintf(FormatVar string, varArgs ...interface{}) string {
703		736
704	cret := xStrdupPrintf(FormatVar, varArgs...)	737		cret := xStrdupPrintf(FormatVar, varArgs...)
		738	+
705	return cret	739		return cret
706	}	740		}
707		741

@@ -720,6 +754,7 @@ var xStrdupVprintf func(string, []interface{}) string
720	func StrdupVprintf(FormatVar string, ArgsVar []interface{}) string {	754		func StrdupVprintf(FormatVar string, ArgsVar []interface{}) string {
721		755
722	cret := xStrdupVprintf(FormatVar, ArgsVar)	756		cret := xStrdupVprintf(FormatVar, ArgsVar)
		757	+
723	return cret	758		return cret
724	}	759		}
725		760

@@ -732,6 +767,7 @@ var xStrdupv func([]string) []string
732	func Strdupv(StrArrayVar []string) []string {	767		func Strdupv(StrArrayVar []string) []string {
733		768
734	cret := xStrdupv(StrArrayVar)	769		cret := xStrdupv(StrArrayVar)
		770	+
735	return cret	771		return cret
736	}	772		}
737		773

@@ -761,6 +797,7 @@ var xStrerror func(int) string
761	func Strerror(ErrnumVar int) string {	797		func Strerror(ErrnumVar int) string {
762		798
763	cret := xStrerror(ErrnumVar)	799		cret := xStrerror(ErrnumVar)
		800	+
764	return cret	801		return cret
765	}	802		}
766		803

@@ -791,6 +828,7 @@ func Strescape(SourceVar string, ExceptionsVar *string) string {
791	defer core.GFreeNullable(ExceptionsVarPtr)	828		defer core.GFreeNullable(ExceptionsVarPtr)
792		829
793	cret := xStrescape(SourceVar, ExceptionsVarPtr)	830		cret := xStrescape(SourceVar, ExceptionsVarPtr)
		831	+
794	return cret	832		return cret
795	}	833		}
796		834

@@ -815,6 +853,7 @@ func Strjoin(SeparatorVar *string, varArgs ...interface{}) string {
815	defer core.GFreeNullable(SeparatorVarPtr)	853		defer core.GFreeNullable(SeparatorVarPtr)
816		854
817	cret := xStrjoin(SeparatorVarPtr, varArgs...)	855		cret := xStrjoin(SeparatorVarPtr, varArgs...)
		856	+
818	return cret	857		return cret
819	}	858		}
820		859

@@ -832,6 +871,7 @@ func Strjoinv(SeparatorVar *string, StrArrayVar []string) string {
832	defer core.GFreeNullable(SeparatorVarPtr)	871		defer core.GFreeNullable(SeparatorVarPtr)
833		872
834	cret := xStrjoinv(SeparatorVarPtr, StrArrayVar)	873		cret := xStrjoinv(SeparatorVarPtr, StrArrayVar)
		874	+
835	return cret	875		return cret
836	}	876		}
837		877

@@ -853,6 +893,7 @@ var xStrlcat func(string, string, uint) uint
853	func Strlcat(DestVar string, SrcVar string, DestSizeVar uint) uint {	893		func Strlcat(DestVar string, SrcVar string, DestSizeVar uint) uint {
854		894
855	cret := xStrlcat(DestVar, SrcVar, DestSizeVar)	895		cret := xStrlcat(DestVar, SrcVar, DestSizeVar)
		896	+
856	return cret	897		return cret
857	}	898		}
858		899

@@ -875,6 +916,7 @@ var xStrlcpy func(string, string, uint) uint
875	func Strlcpy(DestVar string, SrcVar string, DestSizeVar uint) uint {	916		func Strlcpy(DestVar string, SrcVar string, DestSizeVar uint) uint {
876		917
877	cret := xStrlcpy(DestVar, SrcVar, DestSizeVar)	918		cret := xStrlcpy(DestVar, SrcVar, DestSizeVar)
		919	+
878	return cret	920		return cret
879	}	921		}
880		922

@@ -887,6 +929,7 @@ var xStrncasecmp func(string, string, uint) int
887	func Strncasecmp(S1Var string, S2Var string, NVar uint) int {	929		func Strncasecmp(S1Var string, S2Var string, NVar uint) int {
888		930
889	cret := xStrncasecmp(S1Var, S2Var, NVar)	931		cret := xStrncasecmp(S1Var, S2Var, NVar)
		932	+
890	return cret	933		return cret
891	}	934		}
892		935

@@ -905,6 +948,7 @@ func Strndup(StrVar *string, NVar uint) string {
905	defer core.GFreeNullable(StrVarPtr)	948		defer core.GFreeNullable(StrVarPtr)
906		949
907	cret := xStrndup(StrVarPtr, NVar)	950		cret := xStrndup(StrVarPtr, NVar)
		951	+
908	return cret	952		return cret
909	}	953		}
910		954

@@ -914,6 +958,7 @@ var xStrnfill func(uint, byte) string
914	func Strnfill(LengthVar uint, FillCharVar byte) string {	958		func Strnfill(LengthVar uint, FillCharVar byte) string {
915		959
916	cret := xStrnfill(LengthVar, FillCharVar)	960		cret := xStrnfill(LengthVar, FillCharVar)
		961	+
917	return cret	962		return cret
918	}	963		}
919		964

@@ -928,6 +973,7 @@ var xStrreverse func(string) string
928	func Strreverse(StringVar string) string {	973		func Strreverse(StringVar string) string {
929		974
930	cret := xStrreverse(StringVar)	975		cret := xStrreverse(StringVar)
		976	+
931	return cret	977		return cret
932	}	978		}
933		979

@@ -941,6 +987,7 @@ var xStrrstr func(string, string) string
941	func Strrstr(HaystackVar string, NeedleVar string) string {	987		func Strrstr(HaystackVar string, NeedleVar string) string {
942		988
943	cret := xStrrstr(HaystackVar, NeedleVar)	989		cret := xStrrstr(HaystackVar, NeedleVar)
		990	+
944	return cret	991		return cret
945	}	992		}
946		993

@@ -955,6 +1002,7 @@ var xStrrstrLen func(string, int, string) string
955	func StrrstrLen(HaystackVar string, HaystackLenVar int, NeedleVar string) string {	1002		func StrrstrLen(HaystackVar string, HaystackLenVar int, NeedleVar string) string {
956		1003
957	cret := xStrrstrLen(HaystackVar, HaystackLenVar, NeedleVar)	1004		cret := xStrrstrLen(HaystackVar, HaystackLenVar, NeedleVar)
		1005	+
958	return cret	1006		return cret
959	}	1007		}
960		1008

@@ -969,6 +1017,7 @@ var xStrsignal func(int) string
969	func Strsignal(SignumVar int) string {	1017		func Strsignal(SignumVar int) string {
970		1018
971	cret := xStrsignal(SignumVar)	1019		cret := xStrsignal(SignumVar)
		1020	+
972	return cret	1021		return cret
973	}	1022		}
974		1023

@@ -990,6 +1039,7 @@ var xStrsplit func(string, string, int) []string
990	func Strsplit(StringVar string, DelimiterVar string, MaxTokensVar int) []string {	1039		func Strsplit(StringVar string, DelimiterVar string, MaxTokensVar int) []string {
991		1040
992	cret := xStrsplit(StringVar, DelimiterVar, MaxTokensVar)	1041		cret := xStrsplit(StringVar, DelimiterVar, MaxTokensVar)
		1042	+
993	return cret	1043		return cret
994	}	1044		}
995		1045

@@ -1018,6 +1068,7 @@ var xStrsplitSet func(string, string, int) []string
1018	func StrsplitSet(StringVar string, DelimitersVar string, MaxTokensVar int) []string {	1068		func StrsplitSet(StringVar string, DelimitersVar string, MaxTokensVar int) []string {
1019		1069
1020	cret := xStrsplitSet(StringVar, DelimitersVar, MaxTokensVar)	1070		cret := xStrsplitSet(StringVar, DelimitersVar, MaxTokensVar)
		1071	+
1021	return cret	1072		return cret
1022	}	1073		}
1023		1074

@@ -1035,6 +1086,7 @@ var xStrstrLen func(string, int, string) string
1035	func StrstrLen(HaystackVar string, HaystackLenVar int, NeedleVar string) string {	1086		func StrstrLen(HaystackVar string, HaystackLenVar int, NeedleVar string) string {
1036		1087
1037	cret := xStrstrLen(HaystackVar, HaystackLenVar, NeedleVar)	1088		cret := xStrstrLen(HaystackVar, HaystackLenVar, NeedleVar)
		1089	+
1038	return cret	1090		return cret
1039	}	1091		}
1040		1092

@@ -1055,6 +1107,7 @@ var xStrtod func(string, *string) float64
1055	func Strtod(NptrVar string, EndptrVar *string) float64 {	1107		func Strtod(NptrVar string, EndptrVar *string) float64 {
1056		1108
1057	cret := xStrtod(NptrVar, EndptrVar)	1109		cret := xStrtod(NptrVar, EndptrVar)
		1110	+
1058	return cret	1111		return cret
1059	}	1112		}
1060		1113

@@ -1064,6 +1117,7 @@ var xStrup func(string) string
1064	func Strup(StringVar string) string {	1117		func Strup(StringVar string) string {
1065		1118
1066	cret := xStrup(StringVar)	1119		cret := xStrup(StringVar)
		1120	+
1067	return cret	1121		return cret
1068	}	1122		}
1069		1123

@@ -1074,6 +1128,7 @@ var xStrvContains func([]string, string) bool
1074	func StrvContains(StrvVar []string, StrVar string) bool {	1128		func StrvContains(StrvVar []string, StrVar string) bool {
1075		1129
1076	cret := xStrvContains(StrvVar, StrVar)	1130		cret := xStrvContains(StrvVar, StrVar)
		1131	+
1077	return cret	1132		return cret
1078	}	1133		}
1079		1134

@@ -1091,6 +1146,7 @@ var xStrvEqual func([]string, []string) bool
1091	func StrvEqual(Strv1Var []string, Strv2Var []string) bool {	1146		func StrvEqual(Strv1Var []string, Strv2Var []string) bool {
1092		1147
1093	cret := xStrvEqual(Strv1Var, Strv2Var)	1148		cret := xStrvEqual(Strv1Var, Strv2Var)
		1149	+
1094	return cret	1150		return cret
1095	}	1151		}
1096		1152

@@ -1100,6 +1156,7 @@ var xStrvLength func([]string) uint
1100	func StrvLength(StrArrayVar []string) uint {	1156		func StrvLength(StrArrayVar []string) uint {
1101		1157
1102	cret := xStrvLength(StrArrayVar)	1158		cret := xStrvLength(StrArrayVar)
		1159	+
1103	return cret	1160		return cret
1104	}	1161		}
1105		1162

M v4/glib/gtestutils.go +22 -0


@@ -410,6 +410,7 @@ func Strcmp0(Str1Var string, Str2Var string) int {
410	defer core.GFreeNullable(Str2VarPtr)	410		defer core.GFreeNullable(Str2VarPtr)
411		411
412	cret := xStrcmp0(Str1VarPtr, Str2VarPtr)	412		cret := xStrcmp0(Str1VarPtr, Str2VarPtr)
		413	+
413	return cret	414		return cret
414	}	415		}
415		416

@@ -659,6 +660,7 @@ var xTestBuildFilename func(TestFileType, string, ...interface{}) string
659	func TestBuildFilename(FileTypeVar TestFileType, FirstPathVar string, varArgs ...interface{}) string {	660		func TestBuildFilename(FileTypeVar TestFileType, FirstPathVar string, varArgs ...interface{}) string {
660		661
661	cret := xTestBuildFilename(FileTypeVar, FirstPathVar, varArgs...)	662		cret := xTestBuildFilename(FileTypeVar, FirstPathVar, varArgs...)
		663	+
662	return cret	664		return cret
663	}	665		}
664		666

@@ -729,6 +731,7 @@ func TestCreateCase(TestNameVar string, DataSizeVar uint, TestDataVar uintptr, D
729	}	731		}
730		732
731	cret := xTestCreateCase(TestNameVar, DataSizeVar, TestDataVar, DataSetupVarRef, DataTestVarRef, DataTeardownVarRef)	733		cret := xTestCreateCase(TestNameVar, DataSizeVar, TestDataVar, DataSetupVarRef, DataTestVarRef, DataTeardownVarRef)
		734	+
732	return cret	735		return cret
733	}	736		}
734		737

@@ -738,6 +741,7 @@ var xTestCreateSuite func(string) *TestSuite
738	func TestCreateSuite(SuiteNameVar string) *TestSuite {	741		func TestCreateSuite(SuiteNameVar string) *TestSuite {
739		742
740	cret := xTestCreateSuite(SuiteNameVar)	743		cret := xTestCreateSuite(SuiteNameVar)
		744	+
741	return cret	745		return cret
742	}	746		}
743		747

@@ -859,6 +863,7 @@ var xTestFailed func() bool
859	func TestFailed() bool {	863		func TestFailed() bool {
860		864
861	cret := xTestFailed()	865		cret := xTestFailed()
		866	+
862	return cret	867		return cret
863	}	868		}
864		869

@@ -872,6 +877,7 @@ var xTestGetDir func(TestFileType) string
872	func TestGetDir(FileTypeVar TestFileType) string {	877		func TestGetDir(FileTypeVar TestFileType) string {
873		878
874	cret := xTestGetDir(FileTypeVar)	879		cret := xTestGetDir(FileTypeVar)
		880	+
875	return cret	881		return cret
876	}	882		}
877		883

@@ -892,6 +898,7 @@ var xTestGetFilename func(TestFileType, string, ...interface{}) string
892	func TestGetFilename(FileTypeVar TestFileType, FirstPathVar string, varArgs ...interface{}) string {	898		func TestGetFilename(FileTypeVar TestFileType, FirstPathVar string, varArgs ...interface{}) string {
893		899
894	cret := xTestGetFilename(FileTypeVar, FirstPathVar, varArgs...)	900		cret := xTestGetFilename(FileTypeVar, FirstPathVar, varArgs...)
		901	+
895	return cret	902		return cret
896	}	903		}
897		904

@@ -908,6 +915,7 @@ var xTestGetPath func() string
908	func TestGetPath() string {	915		func TestGetPath() string {
909		916
910	cret := xTestGetPath()	917		cret := xTestGetPath()
		918	+
911	return cret	919		return cret
912	}	920		}
913		921

@@ -917,6 +925,7 @@ var xTestGetRoot func() *TestSuite
917	func TestGetRoot() *TestSuite {	925		func TestGetRoot() *TestSuite {
918		926
919	cret := xTestGetRoot()	927		cret := xTestGetRoot()
		928	+
920	return cret	929		return cret
921	}	930		}
922		931

@@ -1071,6 +1080,7 @@ var xTestLogTypeName func(TestLogType) string
1071	func TestLogTypeName(LogTypeVar TestLogType) string {	1080		func TestLogTypeName(LogTypeVar TestLogType) string {
1072		1081
1073	cret := xTestLogTypeName(LogTypeVar)	1082		cret := xTestLogTypeName(LogTypeVar)
		1083	+
1074	return cret	1084		return cret
1075	}	1085		}
1076		1086

@@ -1162,6 +1172,7 @@ var xTestRandDouble func() float64
1162	func TestRandDouble() float64 {	1172		func TestRandDouble() float64 {
1163		1173
1164	cret := xTestRandDouble()	1174		cret := xTestRandDouble()
		1175	+
1165	return cret	1176		return cret
1166	}	1177		}
1167		1178

@@ -1173,6 +1184,7 @@ var xTestRandDoubleRange func(float64, float64) float64
1173	func TestRandDoubleRange(RangeStartVar float64, RangeEndVar float64) float64 {	1184		func TestRandDoubleRange(RangeStartVar float64, RangeEndVar float64) float64 {
1174		1185
1175	cret := xTestRandDoubleRange(RangeStartVar, RangeEndVar)	1186		cret := xTestRandDoubleRange(RangeStartVar, RangeEndVar)
		1187	+
1176	return cret	1188		return cret
1177	}	1189		}
1178		1190

@@ -1190,6 +1202,7 @@ var xTestRandInt func() int32
1190	func TestRandInt() int32 {	1202		func TestRandInt() int32 {
1191		1203
1192	cret := xTestRandInt()	1204		cret := xTestRandInt()
		1205	+
1193	return cret	1206		return cret
1194	}	1207		}
1195		1208

@@ -1201,6 +1214,7 @@ var xTestRandIntRange func(int32, int32) int32
1201	func TestRandIntRange(BeginVar int32, EndVar int32) int32 {	1214		func TestRandIntRange(BeginVar int32, EndVar int32) int32 {
1202		1215
1203	cret := xTestRandIntRange(BeginVar, EndVar)	1216		cret := xTestRandIntRange(BeginVar, EndVar)
		1217	+
1204	return cret	1218		return cret
1205	}	1219		}
1206		1220

@@ -1243,6 +1257,7 @@ var xTestRun func() int
1243	func TestRun() int {	1257		func TestRun() int {
1244		1258
1245	cret := xTestRun()	1259		cret := xTestRun()
		1260	+
1246	return cret	1261		return cret
1247	}	1262		}
1248		1263

@@ -1260,6 +1275,7 @@ var xTestRunSuite func(*TestSuite) int
1260	func TestRunSuite(SuiteVar *TestSuite) int {	1275		func TestRunSuite(SuiteVar *TestSuite) int {
1261		1276
1262	cret := xTestRunSuite(SuiteVar)	1277		cret := xTestRunSuite(SuiteVar)
		1278	+
1263	return cret	1279		return cret
1264	}	1280		}
1265		1281

@@ -1323,6 +1339,7 @@ var xTestSubprocess func() bool
1323	func TestSubprocess() bool {	1339		func TestSubprocess() bool {
1324		1340
1325	cret := xTestSubprocess()	1341		cret := xTestSubprocess()
		1342	+
1326	return cret	1343		return cret
1327	}	1344		}
1328		1345

@@ -1365,6 +1382,7 @@ var xTestTimerElapsed func() float64
1365	func TestTimerElapsed() float64 {	1382		func TestTimerElapsed() float64 {
1366		1383
1367	cret := xTestTimerElapsed()	1384		cret := xTestTimerElapsed()
		1385	+
1368	return cret	1386		return cret
1369	}	1387		}
1370		1388

@@ -1374,6 +1392,7 @@ var xTestTimerLast func() float64
1374	func TestTimerLast() float64 {	1392		func TestTimerLast() float64 {
1375		1393
1376	cret := xTestTimerLast()	1394		cret := xTestTimerLast()
		1395	+
1377	return cret	1396		return cret
1378	}	1397		}
1379		1398

@@ -1439,6 +1458,7 @@ var xTestTrapFork func(uint64, TestTrapFlags) bool
1439	func TestTrapFork(UsecTimeoutVar uint64, TestTrapFlagsVar TestTrapFlags) bool {	1458		func TestTrapFork(UsecTimeoutVar uint64, TestTrapFlagsVar TestTrapFlags) bool {
1440		1459
1441	cret := xTestTrapFork(UsecTimeoutVar, TestTrapFlagsVar)	1460		cret := xTestTrapFork(UsecTimeoutVar, TestTrapFlagsVar)
		1461	+
1442	return cret	1462		return cret
1443	}	1463		}
1444		1464

@@ -1448,6 +1468,7 @@ var xTestTrapHasPassed func() bool
1448	func TestTrapHasPassed() bool {	1468		func TestTrapHasPassed() bool {
1449		1469
1450	cret := xTestTrapHasPassed()	1470		cret := xTestTrapHasPassed()
		1471	+
1451	return cret	1472		return cret
1452	}	1473		}
1453		1474

@@ -1457,6 +1478,7 @@ var xTestTrapReachedTimeout func() bool
1457	func TestTrapReachedTimeout() bool {	1478		func TestTrapReachedTimeout() bool {
1458		1479
1459	cret := xTestTrapReachedTimeout()	1480		cret := xTestTrapReachedTimeout()
		1481	+
1460	return cret	1482		return cret
1461	}	1483		}
1462		1484

M v4/glib/gthread.go +11 -0


@@ -2097,6 +2097,7 @@ var xCondNew func() *Cond
2097	func CondNew() *Cond {	2097		func CondNew() *Cond {
2098		2098
2099	cret := xCondNew()	2099		cret := xCondNew()
		2100	+
2100	return cret	2101		return cret
2101	}	2102		}
2102		2103

@@ -2109,6 +2110,7 @@ var xGetNumProcessors func() uint
2109	func GetNumProcessors() uint {	2110		func GetNumProcessors() uint {
2110		2111
2111	cret := xGetNumProcessors()	2112		cret := xGetNumProcessors()
		2113	+
2112	return cret	2114		return cret
2113	}	2115		}
2114		2116

@@ -2118,6 +2120,7 @@ var xMutexNew func() *Mutex
2118	func MutexNew() *Mutex {	2120		func MutexNew() *Mutex {
2119		2121
2120	cret := xMutexNew()	2122		cret := xMutexNew()
		2123	+
2121	return cret	2124		return cret
2122	}	2125		}
2123		2126

@@ -2153,6 +2156,7 @@ var xOnceInitEnter func(uintptr) bool
2153	func OnceInitEnter(LocationVar uintptr) bool {	2156		func OnceInitEnter(LocationVar uintptr) bool {
2154		2157
2155	cret := xOnceInitEnter(LocationVar)	2158		cret := xOnceInitEnter(LocationVar)
		2159	+
2156	return cret	2160		return cret
2157	}	2161		}
2158		2162

@@ -2161,6 +2165,7 @@ var xOnceInitEnterImpl func(uint) bool
2161	func OnceInitEnterImpl(LocationVar uint) bool {	2165		func OnceInitEnterImpl(LocationVar uint) bool {
2162		2166
2163	cret := xOnceInitEnterImpl(LocationVar)	2167		cret := xOnceInitEnterImpl(LocationVar)
		2168	+
2164	return cret	2169		return cret
2165	}	2170		}
2166		2171

@@ -2186,6 +2191,7 @@ var xOnceInitEnterPointer func(uintptr) bool
2186	func OnceInitEnterPointer(LocationVar uintptr) bool {	2191		func OnceInitEnterPointer(LocationVar uintptr) bool {
2187		2192
2188	cret := xOnceInitEnterPointer(LocationVar)	2193		cret := xOnceInitEnterPointer(LocationVar)
		2194	+
2189	return cret	2195		return cret
2190	}	2196		}
2191		2197

@@ -2242,6 +2248,7 @@ func PrivateNew(NotifyVar DestroyNotify) Private {
2242	}	2248		}
2243		2249
2244	cret := xPrivateNew(NotifyVarRef)	2250		cret := xPrivateNew(NotifyVarRef)
		2251	+
2245	return cret	2252		return cret
2246	}	2253		}
2247		2254

@@ -2278,6 +2285,7 @@ func ThreadCreate(FuncVar ThreadFunc, DataVar uintptr, JoinableVar bool) (Thre
2278	}	2285		}
2279		2286
2280	cret := xThreadCreate(FuncVarRef, DataVar, JoinableVar, &cerr)	2287		cret := xThreadCreate(FuncVarRef, DataVar, JoinableVar, &cerr)
		2288	+
2281	if cerr == nil {	2289		if cerr == nil {
2282	return cret, nil	2290		return cret, nil
2283	}	2291		}

@@ -2307,6 +2315,7 @@ func ThreadCreateFull(FuncVar *ThreadFunc, DataVar uintptr, StackSizeVar uint, J
2307	}	2315		}
2308		2316
2309	cret := xThreadCreateFull(FuncVarRef, DataVar, StackSizeVar, JoinableVar, BoundVar, PriorityVar, &cerr)	2317		cret := xThreadCreateFull(FuncVarRef, DataVar, StackSizeVar, JoinableVar, BoundVar, PriorityVar, &cerr)
		2318	+
2310	if cerr == nil {	2319		if cerr == nil {
2311	return cret, nil	2320		return cret, nil
2312	}	2321		}

@@ -2375,6 +2384,7 @@ var xThreadGetInitialized func() bool
2375	func ThreadGetInitialized() bool {	2384		func ThreadGetInitialized() bool {
2376		2385
2377	cret := xThreadGetInitialized()	2386		cret := xThreadGetInitialized()
		2387	+
2378	return cret	2388		return cret
2379	}	2389		}
2380		2390

@@ -2430,6 +2440,7 @@ var xThreadSelf func() *Thread
2430	func ThreadSelf() *Thread {	2440		func ThreadSelf() *Thread {
2431		2441
2432	cret := xThreadSelf()	2442		cret := xThreadSelf()
		2443	+
2433	return cret	2444		return cret
2434	}	2445		}
2435		2446

M v4/glib/gthreadpool.go +3 -0


@@ -211,6 +211,7 @@ var xThreadPoolGetMaxIdleTime func() uint
211	func ThreadPoolGetMaxIdleTime() uint {	211		func ThreadPoolGetMaxIdleTime() uint {
212		212
213	cret := xThreadPoolGetMaxIdleTime()	213		cret := xThreadPoolGetMaxIdleTime()
		214	+
214	return cret	215		return cret
215	}	216		}
216		217

@@ -220,6 +221,7 @@ var xThreadPoolGetMaxUnusedThreads func() int
220	func ThreadPoolGetMaxUnusedThreads() int {	221		func ThreadPoolGetMaxUnusedThreads() int {
221		222
222	cret := xThreadPoolGetMaxUnusedThreads()	223		cret := xThreadPoolGetMaxUnusedThreads()
		224	+
223	return cret	225		return cret
224	}	226		}
225		227

@@ -229,6 +231,7 @@ var xThreadPoolGetNumUnusedThreads func() uint
229	func ThreadPoolGetNumUnusedThreads() uint {	231		func ThreadPoolGetNumUnusedThreads() uint {
230		232
231	cret := xThreadPoolGetNumUnusedThreads()	233		cret := xThreadPoolGetNumUnusedThreads()
		234	+
232	return cret	235		return cret
233	}	236		}
234		237

M v4/glib/gtimer.go +1 -0


@@ -126,6 +126,7 @@ var xTimeValFromIso8601 func(string, *TimeVal) bool
126	func TimeValFromIso8601(IsoDateVar string, TimeVar *TimeVal) bool {	126		func TimeValFromIso8601(IsoDateVar string, TimeVar *TimeVal) bool {
127		127
128	cret := xTimeValFromIso8601(IsoDateVar, TimeVar)	128		cret := xTimeValFromIso8601(IsoDateVar, TimeVar)
		129	+
129	return cret	130		return cret
130	}	131		}
131		132

M v4/glib/gtrashstack.go +3 -0


@@ -41,6 +41,7 @@ var xTrashStackHeight func(**TrashStack) uint
41	func TrashStackHeight(StackPVar **TrashStack) uint {	41		func TrashStackHeight(StackPVar **TrashStack) uint {
42		42
43	cret := xTrashStackHeight(StackPVar)	43		cret := xTrashStackHeight(StackPVar)
		44	+
44	return cret	45		return cret
45	}	46		}
46		47

@@ -51,6 +52,7 @@ var xTrashStackPeek func(**TrashStack) uintptr
51	func TrashStackPeek(StackPVar **TrashStack) uintptr {	52		func TrashStackPeek(StackPVar **TrashStack) uintptr {
52		53
53	cret := xTrashStackPeek(StackPVar)	54		cret := xTrashStackPeek(StackPVar)
		55	+
54	return cret	56		return cret
55	}	57		}
56		58

@@ -60,6 +62,7 @@ var xTrashStackPop func(**TrashStack) uintptr
60	func TrashStackPop(StackPVar **TrashStack) uintptr {	62		func TrashStackPop(StackPVar **TrashStack) uintptr {
61		63
62	cret := xTrashStackPop(StackPVar)	64		cret := xTrashStackPop(StackPVar)
		65	+
63	return cret	66		return cret
64	}	67		}
65		68

M v4/glib/gunicode.go +66 -0


@@ -622,6 +622,7 @@ func Ucs4ToUtf16(StrVar []uint32, LenVar int, ItemsReadVar *int, ItemsWrittenVar
622	var cerr *Error	622		var cerr *Error
623		623
624	cret := xUcs4ToUtf16(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)	624		cret := xUcs4ToUtf16(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)
		625	+
625	if cerr == nil {	626		if cerr == nil {
626	return cret, nil	627		return cret, nil
627	}	628		}

@@ -639,6 +640,7 @@ func Ucs4ToUtf8(StrVar []uint32, LenVar int, ItemsReadVar *int, ItemsWrittenVar
639	var cerr *Error	640		var cerr *Error
640		641
641	cret := xUcs4ToUtf8(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)	642		cret := xUcs4ToUtf8(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)
		643	+
642	if cerr == nil {	644		if cerr == nil {
643	return cret, nil	645		return cret, nil
644	}	646		}

@@ -657,6 +659,7 @@ var xUnicharBreakType func(uint32) UnicodeBreakType
657	func UnicharBreakType(CVar uint32) UnicodeBreakType {	659		func UnicharBreakType(CVar uint32) UnicodeBreakType {
658		660
659	cret := xUnicharBreakType(CVar)	661		cret := xUnicharBreakType(CVar)
		662	+
660	return cret	663		return cret
661	}	664		}
662		665

@@ -666,6 +669,7 @@ var xUnicharCombiningClass func(uint32) int
666	func UnicharCombiningClass(UcVar uint32) int {	669		func UnicharCombiningClass(UcVar uint32) int {
667		670
668	cret := xUnicharCombiningClass(UcVar)	671		cret := xUnicharCombiningClass(UcVar)
		672	+
669	return cret	673		return cret
670	}	674		}
671		675

@@ -690,6 +694,7 @@ var xUnicharCompose func(uint32, uint32, *uint32) bool
690	func UnicharCompose(AVar uint32, BVar uint32, ChVar *uint32) bool {	694		func UnicharCompose(AVar uint32, BVar uint32, ChVar *uint32) bool {
691		695
692	cret := xUnicharCompose(AVar, BVar, ChVar)	696		cret := xUnicharCompose(AVar, BVar, ChVar)
		697	+
693	return cret	698		return cret
694	}	699		}
695		700

@@ -721,6 +726,7 @@ var xUnicharDecompose func(uint32, uint32, uint32) bool
721	func UnicharDecompose(ChVar uint32, AVar uint32, BVar uint32) bool {	726		func UnicharDecompose(ChVar uint32, AVar uint32, BVar uint32) bool {
722		727
723	cret := xUnicharDecompose(ChVar, AVar, BVar)	728		cret := xUnicharDecompose(ChVar, AVar, BVar)
		729	+
724	return cret	730		return cret
725	}	731		}
726		732

@@ -731,6 +737,7 @@ var xUnicharDigitValue func(uint32) int
731	func UnicharDigitValue(CVar uint32) int {	737		func UnicharDigitValue(CVar uint32) int {
732		738
733	cret := xUnicharDigitValue(CVar)	739		cret := xUnicharDigitValue(CVar)
		740	+
734	return cret	741		return cret
735	}	742		}
736		743

@@ -758,6 +765,7 @@ var xUnicharFullyDecompose func(uint32, bool, *uint32, uint) uint
758	func UnicharFullyDecompose(ChVar uint32, CompatVar bool, ResultVar *uint32, ResultLenVar uint) uint {	765		func UnicharFullyDecompose(ChVar uint32, CompatVar bool, ResultVar *uint32, ResultLenVar uint) uint {
759		766
760	cret := xUnicharFullyDecompose(ChVar, CompatVar, ResultVar, ResultLenVar)	767		cret := xUnicharFullyDecompose(ChVar, CompatVar, ResultVar, ResultLenVar)
		768	+
761	return cret	769		return cret
762	}	770		}
763		771

@@ -775,6 +783,7 @@ var xUnicharGetMirrorChar func(uint32, *uint32) bool
775	func UnicharGetMirrorChar(ChVar uint32, MirroredChVar *uint32) bool {	783		func UnicharGetMirrorChar(ChVar uint32, MirroredChVar *uint32) bool {
776		784
777	cret := xUnicharGetMirrorChar(ChVar, MirroredChVar)	785		cret := xUnicharGetMirrorChar(ChVar, MirroredChVar)
		786	+
778	return cret	787		return cret
779	}	788		}
780		789

@@ -790,6 +799,7 @@ var xUnicharGetScript func(uint32) UnicodeScript
790	func UnicharGetScript(ChVar uint32) UnicodeScript {	799		func UnicharGetScript(ChVar uint32) UnicodeScript {
791		800
792	cret := xUnicharGetScript(ChVar)	801		cret := xUnicharGetScript(ChVar)
		802	+
793	return cret	803		return cret
794	}	804		}
795		805

@@ -801,6 +811,7 @@ var xUnicharIsalnum func(uint32) bool
801	func UnicharIsalnum(CVar uint32) bool {	811		func UnicharIsalnum(CVar uint32) bool {
802		812
803	cret := xUnicharIsalnum(CVar)	813		cret := xUnicharIsalnum(CVar)
		814	+
804	return cret	815		return cret
805	}	816		}
806		817

@@ -812,6 +823,7 @@ var xUnicharIsalpha func(uint32) bool
812	func UnicharIsalpha(CVar uint32) bool {	823		func UnicharIsalpha(CVar uint32) bool {
813		824
814	cret := xUnicharIsalpha(CVar)	825		cret := xUnicharIsalpha(CVar)
		826	+
815	return cret	827		return cret
816	}	828		}
817		829

@@ -823,6 +835,7 @@ var xUnicharIscntrl func(uint32) bool
823	func UnicharIscntrl(CVar uint32) bool {	835		func UnicharIscntrl(CVar uint32) bool {
824		836
825	cret := xUnicharIscntrl(CVar)	837		cret := xUnicharIscntrl(CVar)
		838	+
826	return cret	839		return cret
827	}	840		}
828		841

@@ -833,6 +846,7 @@ var xUnicharIsdefined func(uint32) bool
833	func UnicharIsdefined(CVar uint32) bool {	846		func UnicharIsdefined(CVar uint32) bool {
834		847
835	cret := xUnicharIsdefined(CVar)	848		cret := xUnicharIsdefined(CVar)
		849	+
836	return cret	850		return cret
837	}	851		}
838		852

@@ -844,6 +858,7 @@ var xUnicharIsdigit func(uint32) bool
844	func UnicharIsdigit(CVar uint32) bool {	858		func UnicharIsdigit(CVar uint32) bool {
845		859
846	cret := xUnicharIsdigit(CVar)	860		cret := xUnicharIsdigit(CVar)
		861	+
847	return cret	862		return cret
848	}	863		}
849		864

@@ -857,6 +872,7 @@ var xUnicharIsgraph func(uint32) bool
857	func UnicharIsgraph(CVar uint32) bool {	872		func UnicharIsgraph(CVar uint32) bool {
858		873
859	cret := xUnicharIsgraph(CVar)	874		cret := xUnicharIsgraph(CVar)
		875	+
860	return cret	876		return cret
861	}	877		}
862		878

@@ -868,6 +884,7 @@ var xUnicharIslower func(uint32) bool
868	func UnicharIslower(CVar uint32) bool {	884		func UnicharIslower(CVar uint32) bool {
869		885
870	cret := xUnicharIslower(CVar)	886		cret := xUnicharIslower(CVar)
		887	+
871	return cret	888		return cret
872	}	889		}
873		890

@@ -885,6 +902,7 @@ var xUnicharIsmark func(uint32) bool
885	func UnicharIsmark(CVar uint32) bool {	902		func UnicharIsmark(CVar uint32) bool {
886		903
887	cret := xUnicharIsmark(CVar)	904		cret := xUnicharIsmark(CVar)
		905	+
888	return cret	906		return cret
889	}	907		}
890		908

@@ -897,6 +915,7 @@ var xUnicharIsprint func(uint32) bool
897	func UnicharIsprint(CVar uint32) bool {	915		func UnicharIsprint(CVar uint32) bool {
898		916
899	cret := xUnicharIsprint(CVar)	917		cret := xUnicharIsprint(CVar)
		918	+
900	return cret	919		return cret
901	}	920		}
902		921

@@ -908,6 +927,7 @@ var xUnicharIspunct func(uint32) bool
908	func UnicharIspunct(CVar uint32) bool {	927		func UnicharIspunct(CVar uint32) bool {
909		928
910	cret := xUnicharIspunct(CVar)	929		cret := xUnicharIspunct(CVar)
		930	+
911	return cret	931		return cret
912	}	932		}
913		933

@@ -923,6 +943,7 @@ var xUnicharIsspace func(uint32) bool
923	func UnicharIsspace(CVar uint32) bool {	943		func UnicharIsspace(CVar uint32) bool {
924		944
925	cret := xUnicharIsspace(CVar)	945		cret := xUnicharIsspace(CVar)
		946	+
926	return cret	947		return cret
927	}	948		}
928		949

@@ -937,6 +958,7 @@ var xUnicharIstitle func(uint32) bool
937	func UnicharIstitle(CVar uint32) bool {	958		func UnicharIstitle(CVar uint32) bool {
938		959
939	cret := xUnicharIstitle(CVar)	960		cret := xUnicharIstitle(CVar)
		961	+
940	return cret	962		return cret
941	}	963		}
942		964

@@ -946,6 +968,7 @@ var xUnicharIsupper func(uint32) bool
946	func UnicharIsupper(CVar uint32) bool {	968		func UnicharIsupper(CVar uint32) bool {
947		969
948	cret := xUnicharIsupper(CVar)	970		cret := xUnicharIsupper(CVar)
		971	+
949	return cret	972		return cret
950	}	973		}
951		974

@@ -956,6 +979,7 @@ var xUnicharIswide func(uint32) bool
956	func UnicharIswide(CVar uint32) bool {	979		func UnicharIswide(CVar uint32) bool {
957		980
958	cret := xUnicharIswide(CVar)	981		cret := xUnicharIswide(CVar)
		982	+
959	return cret	983		return cret
960	}	984		}
961		985

@@ -974,6 +998,7 @@ var xUnicharIswideCjk func(uint32) bool
974	func UnicharIswideCjk(CVar uint32) bool {	998		func UnicharIswideCjk(CVar uint32) bool {
975		999
976	cret := xUnicharIswideCjk(CVar)	1000		cret := xUnicharIswideCjk(CVar)
		1001	+
977	return cret	1002		return cret
978	}	1003		}
979		1004

@@ -983,6 +1008,7 @@ var xUnicharIsxdigit func(uint32) bool
983	func UnicharIsxdigit(CVar uint32) bool {	1008		func UnicharIsxdigit(CVar uint32) bool {
984		1009
985	cret := xUnicharIsxdigit(CVar)	1010		cret := xUnicharIsxdigit(CVar)
		1011	+
986	return cret	1012		return cret
987	}	1013		}
988		1014

@@ -1000,6 +1026,7 @@ var xUnicharIszerowidth func(uint32) bool
1000	func UnicharIszerowidth(CVar uint32) bool {	1026		func UnicharIszerowidth(CVar uint32) bool {
1001		1027
1002	cret := xUnicharIszerowidth(CVar)	1028		cret := xUnicharIszerowidth(CVar)
		1029	+
1003	return cret	1030		return cret
1004	}	1031		}
1005		1032

@@ -1009,6 +1036,7 @@ var xUnicharToUtf8 func(uint32, *string) int
1009	func UnicharToUtf8(CVar uint32, OutbufVar *string) int {	1036		func UnicharToUtf8(CVar uint32, OutbufVar *string) int {
1010		1037
1011	cret := xUnicharToUtf8(CVar, OutbufVar)	1038		cret := xUnicharToUtf8(CVar, OutbufVar)
		1039	+
1012	return cret	1040		return cret
1013	}	1041		}
1014		1042

@@ -1018,6 +1046,7 @@ var xUnicharTolower func(uint32) uint32
1018	func UnicharTolower(CVar uint32) uint32 {	1046		func UnicharTolower(CVar uint32) uint32 {
1019		1047
1020	cret := xUnicharTolower(CVar)	1048		cret := xUnicharTolower(CVar)
		1049	+
1021	return cret	1050		return cret
1022	}	1051		}
1023		1052

@@ -1027,6 +1056,7 @@ var xUnicharTotitle func(uint32) uint32
1027	func UnicharTotitle(CVar uint32) uint32 {	1056		func UnicharTotitle(CVar uint32) uint32 {
1028		1057
1029	cret := xUnicharTotitle(CVar)	1058		cret := xUnicharTotitle(CVar)
		1059	+
1030	return cret	1060		return cret
1031	}	1061		}
1032		1062

@@ -1036,6 +1066,7 @@ var xUnicharToupper func(uint32) uint32
1036	func UnicharToupper(CVar uint32) uint32 {	1066		func UnicharToupper(CVar uint32) uint32 {
1037		1067
1038	cret := xUnicharToupper(CVar)	1068		cret := xUnicharToupper(CVar)
		1069	+
1039	return cret	1070		return cret
1040	}	1071		}
1041		1072

@@ -1045,6 +1076,7 @@ var xUnicharType func(uint32) UnicodeType
1045	func UnicharType(CVar uint32) UnicodeType {	1076		func UnicharType(CVar uint32) UnicodeType {
1046		1077
1047	cret := xUnicharType(CVar)	1078		cret := xUnicharType(CVar)
		1079	+
1048	return cret	1080		return cret
1049	}	1081		}
1050		1082

@@ -1057,6 +1089,7 @@ var xUnicharValidate func(uint32) bool
1057	func UnicharValidate(ChVar uint32) bool {	1089		func UnicharValidate(ChVar uint32) bool {
1058		1090
1059	cret := xUnicharValidate(ChVar)	1091		cret := xUnicharValidate(ChVar)
		1092	+
1060	return cret	1093		return cret
1061	}	1094		}
1062		1095

@@ -1067,6 +1100,7 @@ var xUnicharXdigitValue func(uint32) int
1067	func UnicharXdigitValue(CVar uint32) int {	1100		func UnicharXdigitValue(CVar uint32) int {
1068		1101
1069	cret := xUnicharXdigitValue(CVar)	1102		cret := xUnicharXdigitValue(CVar)
		1103	+
1070	return cret	1104		return cret
1071	}	1105		}
1072		1106

@@ -1076,6 +1110,7 @@ var xUnicodeCanonicalDecomposition func(uint32, uint) uint32
1076	func UnicodeCanonicalDecomposition(ChVar uint32, ResultLenVar uint) uint32 {	1110		func UnicodeCanonicalDecomposition(ChVar uint32, ResultLenVar uint) uint32 {
1077		1111
1078	cret := xUnicodeCanonicalDecomposition(ChVar, ResultLenVar)	1112		cret := xUnicodeCanonicalDecomposition(ChVar, ResultLenVar)
		1113	+
1079	return cret	1114		return cret
1080	}	1115		}
1081		1116

@@ -1105,6 +1140,7 @@ var xUnicodeScriptFromIso15924 func(uint32) UnicodeScript
1105	func UnicodeScriptFromIso15924(Iso15924Var uint32) UnicodeScript {	1140		func UnicodeScriptFromIso15924(Iso15924Var uint32) UnicodeScript {
1106		1141
1107	cret := xUnicodeScriptFromIso15924(Iso15924Var)	1142		cret := xUnicodeScriptFromIso15924(Iso15924Var)
		1143	+
1108	return cret	1144		return cret
1109	}	1145		}
1110		1146

@@ -1122,6 +1158,7 @@ var xUnicodeScriptToIso15924 func(UnicodeScript) uint32
1122	func UnicodeScriptToIso15924(ScriptVar UnicodeScript) uint32 {	1158		func UnicodeScriptToIso15924(ScriptVar UnicodeScript) uint32 {
1123		1159
1124	cret := xUnicodeScriptToIso15924(ScriptVar)	1160		cret := xUnicodeScriptToIso15924(ScriptVar)
		1161	+
1125	return cret	1162		return cret
1126	}	1163		}
1127		1164

@@ -1134,6 +1171,7 @@ func Utf16ToUcs4(StrVar []uint16, LenVar int, ItemsReadVar *int, ItemsWrittenVar
1134	var cerr *Error	1171		var cerr *Error
1135		1172
1136	cret := xUtf16ToUcs4(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)	1173		cret := xUtf16ToUcs4(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)
		1174	+
1137	if cerr == nil {	1175		if cerr == nil {
1138	return cret, nil	1176		return cret, nil
1139	}	1177		}

@@ -1161,6 +1199,7 @@ func Utf16ToUtf8(StrVar []uint16, LenVar int, ItemsReadVar *int, ItemsWrittenVar
1161	var cerr *Error	1199		var cerr *Error
1162		1200
1163	cret := xUtf16ToUtf8(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)	1201		cret := xUtf16ToUtf8(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)
		1202	+
1164	if cerr == nil {	1203		if cerr == nil {
1165	return cret, nil	1204		return cret, nil
1166	}	1205		}

@@ -1184,6 +1223,7 @@ var xUtf8Casefold func(string, int) string
1184	func Utf8Casefold(StrVar string, LenVar int) string {	1223		func Utf8Casefold(StrVar string, LenVar int) string {
1185		1224
1186	cret := xUtf8Casefold(StrVar, LenVar)	1225		cret := xUtf8Casefold(StrVar, LenVar)
		1226	+
1187	return cret	1227		return cret
1188	}	1228		}
1189		1229

@@ -1202,6 +1242,7 @@ var xUtf8Collate func(string, string) int
1202	func Utf8Collate(Str1Var string, Str2Var string) int {	1242		func Utf8Collate(Str1Var string, Str2Var string) int {
1203		1243
1204	cret := xUtf8Collate(Str1Var, Str2Var)	1244		cret := xUtf8Collate(Str1Var, Str2Var)
		1245	+
1205	return cret	1246		return cret
1206	}	1247		}
1207		1248

@@ -1223,6 +1264,7 @@ var xUtf8CollateKey func(string, int) string
1223	func Utf8CollateKey(StrVar string, LenVar int) string {	1264		func Utf8CollateKey(StrVar string, LenVar int) string {
1224		1265
1225	cret := xUtf8CollateKey(StrVar, LenVar)	1266		cret := xUtf8CollateKey(StrVar, LenVar)
		1267	+
1226	return cret	1268		return cret
1227	}	1269		}
1228		1270

@@ -1246,6 +1288,7 @@ var xUtf8CollateKeyForFilename func(string, int) string
1246	func Utf8CollateKeyForFilename(StrVar string, LenVar int) string {	1288		func Utf8CollateKeyForFilename(StrVar string, LenVar int) string {
1247		1289
1248	cret := xUtf8CollateKeyForFilename(StrVar, LenVar)	1290		cret := xUtf8CollateKeyForFilename(StrVar, LenVar)
		1291	+
1249	return cret	1292		return cret
1250	}	1293		}
1251		1294

@@ -1267,6 +1310,7 @@ func Utf8FindNextChar(PVar string, EndVar *string) string {
1267	defer core.GFreeNullable(EndVarPtr)	1310		defer core.GFreeNullable(EndVarPtr)
1268		1311
1269	cret := xUtf8FindNextChar(PVar, EndVarPtr)	1312		cret := xUtf8FindNextChar(PVar, EndVarPtr)
		1313	+
1270	return cret	1314		return cret
1271	}	1315		}
1272		1316

@@ -1282,6 +1326,7 @@ var xUtf8FindPrevChar func(string, string) string
1282	func Utf8FindPrevChar(StrVar string, PVar string) string {	1326		func Utf8FindPrevChar(StrVar string, PVar string) string {
1283		1327
1284	cret := xUtf8FindPrevChar(StrVar, PVar)	1328		cret := xUtf8FindPrevChar(StrVar, PVar)
		1329	+
1285	return cret	1330		return cret
1286	}	1331		}
1287		1332

@@ -1296,6 +1341,7 @@ var xUtf8GetChar func(string) uint32
1296	func Utf8GetChar(PVar string) uint32 {	1341		func Utf8GetChar(PVar string) uint32 {
1297		1342
1298	cret := xUtf8GetChar(PVar)	1343		cret := xUtf8GetChar(PVar)
		1344	+
1299	return cret	1345		return cret
1300	}	1346		}
1301		1347

@@ -1313,6 +1359,7 @@ var xUtf8GetCharValidated func(string, int) uint32
1313	func Utf8GetCharValidated(PVar string, MaxLenVar int) uint32 {	1359		func Utf8GetCharValidated(PVar string, MaxLenVar int) uint32 {
1314		1360
1315	cret := xUtf8GetCharValidated(PVar, MaxLenVar)	1361		cret := xUtf8GetCharValidated(PVar, MaxLenVar)
		1362	+
1316	return cret	1363		return cret
1317	}	1364		}
1318		1365

@@ -1330,6 +1377,7 @@ var xUtf8MakeValid func(string, int) string
1330	func Utf8MakeValid(StrVar string, LenVar int) string {	1377		func Utf8MakeValid(StrVar string, LenVar int) string {
1331		1378
1332	cret := xUtf8MakeValid(StrVar, LenVar)	1379		cret := xUtf8MakeValid(StrVar, LenVar)
		1380	+
1333	return cret	1381		return cret
1334	}	1382		}
1335		1383

@@ -1363,6 +1411,7 @@ var xUtf8Normalize func(string, int, NormalizeMode) string
1363	func Utf8Normalize(StrVar string, LenVar int, ModeVar NormalizeMode) string {	1411		func Utf8Normalize(StrVar string, LenVar int, ModeVar NormalizeMode) string {
1364		1412
1365	cret := xUtf8Normalize(StrVar, LenVar, ModeVar)	1413		cret := xUtf8Normalize(StrVar, LenVar, ModeVar)
		1414	+
1366	return cret	1415		return cret
1367	}	1416		}
1368		1417

@@ -1384,6 +1433,7 @@ var xUtf8OffsetToPointer func(string, int) string
1384	func Utf8OffsetToPointer(StrVar string, OffsetVar int) string {	1433		func Utf8OffsetToPointer(StrVar string, OffsetVar int) string {
1385		1434
1386	cret := xUtf8OffsetToPointer(StrVar, OffsetVar)	1435		cret := xUtf8OffsetToPointer(StrVar, OffsetVar)
		1436	+
1387	return cret	1437		return cret
1388	}	1438		}
1389		1439

@@ -1397,6 +1447,7 @@ var xUtf8PointerToOffset func(string, string) int
1397	func Utf8PointerToOffset(StrVar string, PosVar string) int {	1447		func Utf8PointerToOffset(StrVar string, PosVar string) int {
1398		1448
1399	cret := xUtf8PointerToOffset(StrVar, PosVar)	1449		cret := xUtf8PointerToOffset(StrVar, PosVar)
		1450	+
1400	return cret	1451		return cret
1401	}	1452		}
1402		1453

@@ -1412,6 +1463,7 @@ var xUtf8PrevChar func(string) string
1412	func Utf8PrevChar(PVar string) string {	1463		func Utf8PrevChar(PVar string) string {
1413		1464
1414	cret := xUtf8PrevChar(PVar)	1465		cret := xUtf8PrevChar(PVar)
		1466	+
1415	return cret	1467		return cret
1416	}	1468		}
1417		1469

@@ -1424,6 +1476,7 @@ var xUtf8Strchr func(string, int, uint32) string
1424	func Utf8Strchr(PVar string, LenVar int, CVar uint32) string {	1476		func Utf8Strchr(PVar string, LenVar int, CVar uint32) string {
1425		1477
1426	cret := xUtf8Strchr(PVar, LenVar, CVar)	1478		cret := xUtf8Strchr(PVar, LenVar, CVar)
		1479	+
1427	return cret	1480		return cret
1428	}	1481		}
1429		1482

@@ -1436,6 +1489,7 @@ var xUtf8Strdown func(string, int) string
1436	func Utf8Strdown(StrVar string, LenVar int) string {	1489		func Utf8Strdown(StrVar string, LenVar int) string {
1437		1490
1438	cret := xUtf8Strdown(StrVar, LenVar)	1491		cret := xUtf8Strdown(StrVar, LenVar)
		1492	+
1439	return cret	1493		return cret
1440	}	1494		}
1441		1495

@@ -1447,6 +1501,7 @@ var xUtf8Strlen func(string, int) int
1447	func Utf8Strlen(PVar string, MaxVar int) int {	1501		func Utf8Strlen(PVar string, MaxVar int) int {
1448		1502
1449	cret := xUtf8Strlen(PVar, MaxVar)	1503		cret := xUtf8Strlen(PVar, MaxVar)
		1504	+
1450	return cret	1505		return cret
1451	}	1506		}
1452		1507

@@ -1464,6 +1519,7 @@ var xUtf8Strncpy func(string, string, uint) string
1464	func Utf8Strncpy(DestVar string, SrcVar string, NVar uint) string {	1519		func Utf8Strncpy(DestVar string, SrcVar string, NVar uint) string {
1465		1520
1466	cret := xUtf8Strncpy(DestVar, SrcVar, NVar)	1521		cret := xUtf8Strncpy(DestVar, SrcVar, NVar)
		1522	+
1467	return cret	1523		return cret
1468	}	1524		}
1469		1525

@@ -1476,6 +1532,7 @@ var xUtf8Strrchr func(string, int, uint32) string
1476	func Utf8Strrchr(PVar string, LenVar int, CVar uint32) string {	1532		func Utf8Strrchr(PVar string, LenVar int, CVar uint32) string {
1477		1533
1478	cret := xUtf8Strrchr(PVar, LenVar, CVar)	1534		cret := xUtf8Strrchr(PVar, LenVar, CVar)
		1535	+
1479	return cret	1536		return cret
1480	}	1537		}
1481		1538

@@ -1498,6 +1555,7 @@ var xUtf8Strreverse func(string, int) string
1498	func Utf8Strreverse(StrVar string, LenVar int) string {	1555		func Utf8Strreverse(StrVar string, LenVar int) string {
1499		1556
1500	cret := xUtf8Strreverse(StrVar, LenVar)	1557		cret := xUtf8Strreverse(StrVar, LenVar)
		1558	+
1501	return cret	1559		return cret
1502	}	1560		}
1503		1561

@@ -1511,6 +1569,7 @@ var xUtf8Strup func(string, int) string
1511	func Utf8Strup(StrVar string, LenVar int) string {	1569		func Utf8Strup(StrVar string, LenVar int) string {
1512		1570
1513	cret := xUtf8Strup(StrVar, LenVar)	1571		cret := xUtf8Strup(StrVar, LenVar)
		1572	+
1514	return cret	1573		return cret
1515	}	1574		}
1516		1575

@@ -1524,6 +1583,7 @@ var xUtf8Substring func(string, int, int) string
1524	func Utf8Substring(StrVar string, StartPosVar int, EndPosVar int) string {	1583		func Utf8Substring(StrVar string, StartPosVar int, EndPosVar int) string {
1525		1584
1526	cret := xUtf8Substring(StrVar, StartPosVar, EndPosVar)	1585		cret := xUtf8Substring(StrVar, StartPosVar, EndPosVar)
		1586	+
1527	return cret	1587		return cret
1528	}	1588		}
1529		1589

@@ -1537,6 +1597,7 @@ func Utf8ToUcs4(StrVar string, LenVar int, ItemsReadVar int, ItemsWrittenVar i
1537	var cerr *Error	1597		var cerr *Error
1538		1598
1539	cret := xUtf8ToUcs4(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)	1599		cret := xUtf8ToUcs4(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)
		1600	+
1540	if cerr == nil {	1601		if cerr == nil {
1541	return cret, nil	1602		return cret, nil
1542	}	1603		}

@@ -1555,6 +1616,7 @@ var xUtf8ToUcs4Fast func(string, int, *int) uint32
1555	func Utf8ToUcs4Fast(StrVar string, LenVar int, ItemsWrittenVar *int) uint32 {	1616		func Utf8ToUcs4Fast(StrVar string, LenVar int, ItemsWrittenVar *int) uint32 {
1556		1617
1557	cret := xUtf8ToUcs4Fast(StrVar, LenVar, ItemsWrittenVar)	1618		cret := xUtf8ToUcs4Fast(StrVar, LenVar, ItemsWrittenVar)
		1619	+
1558	return cret	1620		return cret
1559	}	1621		}
1560		1622

@@ -1567,6 +1629,7 @@ func Utf8ToUtf16(StrVar string, LenVar int, ItemsReadVar int, ItemsWrittenVar
1567	var cerr *Error	1629		var cerr *Error
1568		1630
1569	cret := xUtf8ToUtf16(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)	1631		cret := xUtf8ToUtf16(StrVar, LenVar, ItemsReadVar, ItemsWrittenVar, &cerr)
		1632	+
1570	if cerr == nil {	1633		if cerr == nil {
1571	return cret, nil	1634		return cret, nil
1572	}	1635		}

@@ -1584,6 +1647,7 @@ var xUtf8TruncateMiddle func(string, uint) string
1584	func Utf8TruncateMiddle(StringVar string, TruncateLengthVar uint) string {	1647		func Utf8TruncateMiddle(StringVar string, TruncateLengthVar uint) string {
1585		1648
1586	cret := xUtf8TruncateMiddle(StringVar, TruncateLengthVar)	1649		cret := xUtf8TruncateMiddle(StringVar, TruncateLengthVar)
		1650	+
1587	return cret	1651		return cret
1588	}	1652		}
1589		1653

@@ -1609,6 +1673,7 @@ var xUtf8Validate func([]byte, int, *[]byte) bool
1609	func Utf8Validate(StrVar []byte, MaxLenVar int, EndVar *[]byte) bool {	1673		func Utf8Validate(StrVar []byte, MaxLenVar int, EndVar *[]byte) bool {
1610		1674
1611	cret := xUtf8Validate(StrVar, MaxLenVar, EndVar)	1675		cret := xUtf8Validate(StrVar, MaxLenVar, EndVar)
		1676	+
1612	return cret	1677		return cret
1613	}	1678		}
1614		1679

@@ -1621,6 +1686,7 @@ var xUtf8ValidateLen func([]byte, uint, *[]byte) bool
1621	func Utf8ValidateLen(StrVar []byte, MaxLenVar uint, EndVar *[]byte) bool {	1686		func Utf8ValidateLen(StrVar []byte, MaxLenVar uint, EndVar *[]byte) bool {
1622		1687
1623	cret := xUtf8ValidateLen(StrVar, MaxLenVar, EndVar)	1688		cret := xUtf8ValidateLen(StrVar, MaxLenVar, EndVar)
		1689	+
1624	return cret	1690		return cret
1625	}	1691		}
1626		1692

M v4/glib/guri.go +18 -0


@@ -619,6 +619,7 @@ func UriBuild(FlagsVar UriFlags, SchemeVar string, UserinfoVar *string, HostVar
619	defer core.GFreeNullable(FragmentVarPtr)	619		defer core.GFreeNullable(FragmentVarPtr)
620		620
621	cret := xUriBuild(FlagsVar, SchemeVar, UserinfoVarPtr, HostVarPtr, PortVar, PathVar, QueryVarPtr, FragmentVarPtr)	621		cret := xUriBuild(FlagsVar, SchemeVar, UserinfoVarPtr, HostVarPtr, PortVar, PathVar, QueryVarPtr, FragmentVarPtr)
		622	+
622	return cret	623		return cret
623	}	624		}
624		625

@@ -653,6 +654,7 @@ func UriBuildWithUser(FlagsVar UriFlags, SchemeVar string, UserVar *string, Pass
653	defer core.GFreeNullable(FragmentVarPtr)	654		defer core.GFreeNullable(FragmentVarPtr)
654		655
655	cret := xUriBuildWithUser(FlagsVar, SchemeVar, UserVarPtr, PasswordVarPtr, AuthParamsVarPtr, HostVarPtr, PortVar, PathVar, QueryVarPtr, FragmentVarPtr)	656		cret := xUriBuildWithUser(FlagsVar, SchemeVar, UserVarPtr, PasswordVarPtr, AuthParamsVarPtr, HostVarPtr, PortVar, PathVar, QueryVarPtr, FragmentVarPtr)
		657	+
656	return cret	658		return cret
657	}	659		}
658		660

@@ -675,6 +677,7 @@ func UriEscapeBytes(UnescapedVar []byte, LengthVar uint, ReservedCharsAllowedVar
675	defer core.GFreeNullable(ReservedCharsAllowedVarPtr)	677		defer core.GFreeNullable(ReservedCharsAllowedVarPtr)
676		678
677	cret := xUriEscapeBytes(UnescapedVar, LengthVar, ReservedCharsAllowedVarPtr)	679		cret := xUriEscapeBytes(UnescapedVar, LengthVar, ReservedCharsAllowedVarPtr)
		680	+
678	return cret	681		return cret
679	}	682		}
680		683

@@ -694,6 +697,7 @@ func UriEscapeString(UnescapedVar string, ReservedCharsAllowedVar *string, Allow
694	defer core.GFreeNullable(ReservedCharsAllowedVarPtr)	697		defer core.GFreeNullable(ReservedCharsAllowedVarPtr)
695		698
696	cret := xUriEscapeString(UnescapedVar, ReservedCharsAllowedVarPtr, AllowUtf8Var)	699		cret := xUriEscapeString(UnescapedVar, ReservedCharsAllowedVarPtr, AllowUtf8Var)
		700	+
697	return cret	701		return cret
698	}	702		}
699		703

@@ -711,6 +715,7 @@ func UriIsValid(UriStringVar string, FlagsVar UriFlags) (bool, error) {
711	var cerr *Error	715		var cerr *Error
712		716
713	cret := xUriIsValid(UriStringVar, FlagsVar, &cerr)	717		cret := xUriIsValid(UriStringVar, FlagsVar, &cerr)
		718	+
714	if cerr == nil {	719		if cerr == nil {
715	return cret, nil	720		return cret, nil
716	}	721		}

@@ -752,6 +757,7 @@ func UriJoin(FlagsVar UriFlags, SchemeVar string, UserinfoVar string, HostVar
752	defer core.GFreeNullable(FragmentVarPtr)	757		defer core.GFreeNullable(FragmentVarPtr)
753		758
754	cret := xUriJoin(FlagsVar, SchemeVarPtr, UserinfoVarPtr, HostVarPtr, PortVar, PathVar, QueryVarPtr, FragmentVarPtr)	759		cret := xUriJoin(FlagsVar, SchemeVarPtr, UserinfoVarPtr, HostVarPtr, PortVar, PathVar, QueryVarPtr, FragmentVarPtr)
		760	+
755	return cret	761		return cret
756	}	762		}
757		763

@@ -790,6 +796,7 @@ func UriJoinWithUser(FlagsVar UriFlags, SchemeVar string, UserVar string, Pass
790	defer core.GFreeNullable(FragmentVarPtr)	796		defer core.GFreeNullable(FragmentVarPtr)
791		797
792	cret := xUriJoinWithUser(FlagsVar, SchemeVarPtr, UserVarPtr, PasswordVarPtr, AuthParamsVarPtr, HostVarPtr, PortVar, PathVar, QueryVarPtr, FragmentVarPtr)	798		cret := xUriJoinWithUser(FlagsVar, SchemeVarPtr, UserVarPtr, PasswordVarPtr, AuthParamsVarPtr, HostVarPtr, PortVar, PathVar, QueryVarPtr, FragmentVarPtr)
		799	+
793	return cret	800		return cret
794	}	801		}
795		802

@@ -802,6 +809,7 @@ func UriParse(UriStringVar string, FlagsVar UriFlags) (*Uri, error) {
802	var cerr *Error	809		var cerr *Error
803		810
804	cret := xUriParse(UriStringVar, FlagsVar, &cerr)	811		cret := xUriParse(UriStringVar, FlagsVar, &cerr)
		812	+
805	if cerr == nil {	813		if cerr == nil {
806	return cret, nil	814		return cret, nil
807	}	815		}

@@ -839,6 +847,7 @@ func UriParseParams(ParamsVar string, LengthVar int, SeparatorsVar string, Flags
839	var cerr *Error	847		var cerr *Error
840		848
841	cret := xUriParseParams(ParamsVar, LengthVar, SeparatorsVar, FlagsVar, &cerr)	849		cret := xUriParseParams(ParamsVar, LengthVar, SeparatorsVar, FlagsVar, &cerr)
		850	+
842	if cerr == nil {	851		if cerr == nil {
843	return cret, nil	852		return cret, nil
844	}	853		}

@@ -858,6 +867,7 @@ var xUriParseScheme func(string) string
858	func UriParseScheme(UriVar string) string {	867		func UriParseScheme(UriVar string) string {
859		868
860	cret := xUriParseScheme(UriVar)	869		cret := xUriParseScheme(UriVar)
		870	+
861	return cret	871		return cret
862	}	872		}
863		873

@@ -876,6 +886,7 @@ var xUriPeekScheme func(string) string
876	func UriPeekScheme(UriVar string) string {	886		func UriPeekScheme(UriVar string) string {
877		887
878	cret := xUriPeekScheme(UriVar)	888		cret := xUriPeekScheme(UriVar)
		889	+
879	return cret	890		return cret
880	}	891		}
881		892

@@ -895,6 +906,7 @@ func UriResolveRelative(BaseUriStringVar *string, UriRefVar string, FlagsVar Uri
895	defer core.GFreeNullable(BaseUriStringVarPtr)	906		defer core.GFreeNullable(BaseUriStringVarPtr)
896		907
897	cret := xUriResolveRelative(BaseUriStringVarPtr, UriRefVar, FlagsVar, &cerr)	908		cret := xUriResolveRelative(BaseUriStringVarPtr, UriRefVar, FlagsVar, &cerr)
		909	+
898	if cerr == nil {	910		if cerr == nil {
899	return cret, nil	911		return cret, nil
900	}	912		}

@@ -924,6 +936,7 @@ func UriSplit(UriRefVar string, FlagsVar UriFlags, SchemeVar *string, UserinfoVa
924	var cerr *Error	936		var cerr *Error
925		937
926	cret := xUriSplit(UriRefVar, FlagsVar, SchemeVar, UserinfoVar, HostVar, PortVar, PathVar, QueryVar, FragmentVar, &cerr)	938		cret := xUriSplit(UriRefVar, FlagsVar, SchemeVar, UserinfoVar, HostVar, PortVar, PathVar, QueryVar, FragmentVar, &cerr)
		939	+
927	if cerr == nil {	940		if cerr == nil {
928	return cret, nil	941		return cret, nil
929	}	942		}

@@ -943,6 +956,7 @@ func UriSplitNetwork(UriStringVar string, FlagsVar UriFlags, SchemeVar *string,
943	var cerr *Error	956		var cerr *Error
944		957
945	cret := xUriSplitNetwork(UriStringVar, FlagsVar, SchemeVar, HostVar, PortVar, &cerr)	958		cret := xUriSplitNetwork(UriStringVar, FlagsVar, SchemeVar, HostVar, PortVar, &cerr)
		959	+
946	if cerr == nil {	960		if cerr == nil {
947	return cret, nil	961		return cret, nil
948	}	962		}

@@ -967,6 +981,7 @@ func UriSplitWithUser(UriRefVar string, FlagsVar UriFlags, SchemeVar *string, Us
967	var cerr *Error	981		var cerr *Error
968		982
969	cret := xUriSplitWithUser(UriRefVar, FlagsVar, SchemeVar, UserVar, PasswordVar, AuthParamsVar, HostVar, PortVar, PathVar, QueryVar, FragmentVar, &cerr)	983		cret := xUriSplitWithUser(UriRefVar, FlagsVar, SchemeVar, UserVar, PasswordVar, AuthParamsVar, HostVar, PortVar, PathVar, QueryVar, FragmentVar, &cerr)
		984	+
970	if cerr == nil {	985		if cerr == nil {
971	return cret, nil	986		return cret, nil
972	}	987		}

@@ -993,6 +1008,7 @@ func UriUnescapeBytes(EscapedStringVar string, LengthVar int, IllegalCharactersV
993	defer core.GFreeNullable(IllegalCharactersVarPtr)	1008		defer core.GFreeNullable(IllegalCharactersVarPtr)
994		1009
995	cret := xUriUnescapeBytes(EscapedStringVar, LengthVar, IllegalCharactersVarPtr, &cerr)	1010		cret := xUriUnescapeBytes(EscapedStringVar, LengthVar, IllegalCharactersVarPtr, &cerr)
		1011	+
996	if cerr == nil {	1012		if cerr == nil {
997	return cret, nil	1013		return cret, nil
998	}	1014		}

@@ -1024,6 +1040,7 @@ func UriUnescapeSegment(EscapedStringVar string, EscapedStringEndVar string, I
1024	defer core.GFreeNullable(IllegalCharactersVarPtr)	1040		defer core.GFreeNullable(IllegalCharactersVarPtr)
1025		1041
1026	cret := xUriUnescapeSegment(EscapedStringVarPtr, EscapedStringEndVarPtr, IllegalCharactersVarPtr)	1042		cret := xUriUnescapeSegment(EscapedStringVarPtr, EscapedStringEndVarPtr, IllegalCharactersVarPtr)
		1043	+
1027	return cret	1044		return cret
1028	}	1045		}
1029		1046

@@ -1042,6 +1059,7 @@ func UriUnescapeString(EscapedStringVar string, IllegalCharactersVar *string) st
1042	defer core.GFreeNullable(IllegalCharactersVarPtr)	1059		defer core.GFreeNullable(IllegalCharactersVarPtr)
1043		1060
1044	cret := xUriUnescapeString(EscapedStringVar, IllegalCharactersVarPtr)	1061		cret := xUriUnescapeString(EscapedStringVar, IllegalCharactersVarPtr)
		1062	+
1045	return cret	1063		return cret
1046	}	1064		}
1047		1065

M v4/glib/gutils.go +26 -0


@@ -149,6 +149,7 @@ var xBitNthLsf func(uint, int) int
149	func BitNthLsf(MaskVar uint, NthBitVar int) int {	149		func BitNthLsf(MaskVar uint, NthBitVar int) int {
150		150
151	cret := xBitNthLsf(MaskVar, NthBitVar)	151		cret := xBitNthLsf(MaskVar, NthBitVar)
		152	+
152	return cret	153		return cret
153	}	154		}
154		155

@@ -162,6 +163,7 @@ var xBitNthMsf func(uint, int) int
162	func BitNthMsf(MaskVar uint, NthBitVar int) int {	163		func BitNthMsf(MaskVar uint, NthBitVar int) int {
163		164
164	cret := xBitNthMsf(MaskVar, NthBitVar)	165		cret := xBitNthMsf(MaskVar, NthBitVar)
		166	+
165	return cret	167		return cret
166	}	168		}
167		169

@@ -172,6 +174,7 @@ var xBitStorage func(uint) uint
172	func BitStorage(NumberVar uint) uint {	174		func BitStorage(NumberVar uint) uint {
173		175
174	cret := xBitStorage(NumberVar)	176		cret := xBitStorage(NumberVar)
		177	+
175	return cret	178		return cret
176	}	179		}
177		180

@@ -197,6 +200,7 @@ var xFindProgramInPath func(string) string
197	func FindProgramInPath(ProgramVar string) string {	200		func FindProgramInPath(ProgramVar string) string {
198		201
199	cret := xFindProgramInPath(ProgramVar)	202		cret := xFindProgramInPath(ProgramVar)
		203	+
200	return cret	204		return cret
201	}	205		}
202		206

@@ -218,6 +222,7 @@ var xFormatSize func(uint64) string
218	func FormatSize(SizeVar uint64) string {	222		func FormatSize(SizeVar uint64) string {
219		223
220	cret := xFormatSize(SizeVar)	224		cret := xFormatSize(SizeVar)
		225	+
221	return cret	226		return cret
222	}	227		}
223		228

@@ -235,6 +240,7 @@ var xFormatSizeForDisplay func(int64) string
235	func FormatSizeForDisplay(SizeVar int64) string {	240		func FormatSizeForDisplay(SizeVar int64) string {
236		241
237	cret := xFormatSizeForDisplay(SizeVar)	242		cret := xFormatSizeForDisplay(SizeVar)
		243	+
238	return cret	244		return cret
239	}	245		}
240		246

@@ -247,6 +253,7 @@ var xFormatSizeFull func(uint64, FormatSizeFlags) string
247	func FormatSizeFull(SizeVar uint64, FlagsVar FormatSizeFlags) string {	253		func FormatSizeFull(SizeVar uint64, FlagsVar FormatSizeFlags) string {
248		254
249	cret := xFormatSizeFull(SizeVar, FlagsVar)	255		cret := xFormatSizeFull(SizeVar, FlagsVar)
		256	+
250	return cret	257		return cret
251	}	258		}
252		259

@@ -262,6 +269,7 @@ var xGetApplicationName func() string
262	func GetApplicationName() string {	269		func GetApplicationName() string {
263		270
264	cret := xGetApplicationName()	271		cret := xGetApplicationName()
		272	+
265	return cret	273		return cret
266	}	274		}
267		275

@@ -290,6 +298,7 @@ var xGetHomeDir func() string
290	func GetHomeDir() string {	298		func GetHomeDir() string {
291		299
292	cret := xGetHomeDir()	300		cret := xGetHomeDir()
		301	+
293	return cret	302		return cret
294	}	303		}
295		304

@@ -312,6 +321,7 @@ var xGetHostName func() string
312	func GetHostName() string {	321		func GetHostName() string {
313		322
314	cret := xGetHostName()	323		cret := xGetHostName()
		324	+
315	return cret	325		return cret
316	}	326		}
317		327

@@ -328,6 +338,7 @@ var xGetOsInfo func(string) string
328	func GetOsInfo(KeyNameVar string) string {	338		func GetOsInfo(KeyNameVar string) string {
329		339
330	cret := xGetOsInfo(KeyNameVar)	340		cret := xGetOsInfo(KeyNameVar)
		341	+
331	return cret	342		return cret
332	}	343		}
333		344

@@ -344,6 +355,7 @@ var xGetPrgname func() string
344	func GetPrgname() string {	355		func GetPrgname() string {
345		356
346	cret := xGetPrgname()	357		cret := xGetPrgname()
		358	+
347	return cret	359		return cret
348	}	360		}
349		361

@@ -357,6 +369,7 @@ var xGetRealName func() string
357	func GetRealName() string {	369		func GetRealName() string {
358		370
359	cret := xGetRealName()	371		cret := xGetRealName()
		372	+
360	return cret	373		return cret
361	}	374		}
362		375

@@ -385,6 +398,7 @@ var xGetSystemConfigDirs func() []string
385	func GetSystemConfigDirs() []string {	398		func GetSystemConfigDirs() []string {
386		399
387	cret := xGetSystemConfigDirs()	400		cret := xGetSystemConfigDirs()
		401	+
388	return cret	402		return cret
389	}	403		}
390		404

@@ -427,6 +441,7 @@ var xGetSystemDataDirs func() []string
427	func GetSystemDataDirs() []string {	441		func GetSystemDataDirs() []string {
428		442
429	cret := xGetSystemDataDirs()	443		cret := xGetSystemDataDirs()
		444	+
430	return cret	445		return cret
431	}	446		}
432		447

@@ -449,6 +464,7 @@ var xGetTmpDir func() string
449	func GetTmpDir() string {	464		func GetTmpDir() string {
450		465
451	cret := xGetTmpDir()	466		cret := xGetTmpDir()
		467	+
452	return cret	468		return cret
453	}	469		}
454		470

@@ -473,6 +489,7 @@ var xGetUserCacheDir func() string
473	func GetUserCacheDir() string {	489		func GetUserCacheDir() string {
474		490
475	cret := xGetUserCacheDir()	491		cret := xGetUserCacheDir()
		492	+
476	return cret	493		return cret
477	}	494		}
478		495

@@ -498,6 +515,7 @@ var xGetUserConfigDir func() string
498	func GetUserConfigDir() string {	515		func GetUserConfigDir() string {
499		516
500	cret := xGetUserConfigDir()	517		cret := xGetUserConfigDir()
		518	+
501	return cret	519		return cret
502	}	520		}
503		521

@@ -523,6 +541,7 @@ var xGetUserDataDir func() string
523	func GetUserDataDir() string {	541		func GetUserDataDir() string {
524		542
525	cret := xGetUserDataDir()	543		cret := xGetUserDataDir()
		544	+
526	return cret	545		return cret
527	}	546		}
528		547

@@ -535,6 +554,7 @@ var xGetUserName func() string
535	func GetUserName() string {	554		func GetUserName() string {
536		555
537	cret := xGetUserName()	556		cret := xGetUserName()
		557	+
538	return cret	558		return cret
539	}	559		}
540		560

@@ -556,6 +576,7 @@ var xGetUserRuntimeDir func() string
556	func GetUserRuntimeDir() string {	576		func GetUserRuntimeDir() string {
557		577
558	cret := xGetUserRuntimeDir()	578		cret := xGetUserRuntimeDir()
		579	+
559	return cret	580		return cret
560	}	581		}
561		582

@@ -574,6 +595,7 @@ var xGetUserSpecialDir func(UserDirectory) string
574	func GetUserSpecialDir(DirectoryVar UserDirectory) string {	595		func GetUserSpecialDir(DirectoryVar UserDirectory) string {
575		596
576	cret := xGetUserSpecialDir(DirectoryVar)	597		cret := xGetUserSpecialDir(DirectoryVar)
		598	+
577	return cret	599		return cret
578	}	600		}
579		601

@@ -599,6 +621,7 @@ var xGetUserStateDir func() string
599	func GetUserStateDir() string {	621		func GetUserStateDir() string {
600		622
601	cret := xGetUserStateDir()	623		cret := xGetUserStateDir()
		624	+
602	return cret	625		return cret
603	}	626		}
604		627

@@ -631,6 +654,7 @@ func ParseDebugString(StringVar *string, KeysVar []DebugKey, NkeysVar uint) uint
631	defer core.GFreeNullable(StringVarPtr)	654		defer core.GFreeNullable(StringVarPtr)
632		655
633	cret := xParseDebugString(StringVarPtr, KeysVar, NkeysVar)	656		cret := xParseDebugString(StringVarPtr, KeysVar, NkeysVar)
		657	+
634	return cret	658		return cret
635	}	659		}
636		660

@@ -714,6 +738,7 @@ var xSnprintf func(string, uint, string, ...interface{}) int
714	func Snprintf(StringVar string, NVar uint, FormatVar string, varArgs ...interface{}) int {	738		func Snprintf(StringVar string, NVar uint, FormatVar string, varArgs ...interface{}) int {
715		739
716	cret := xSnprintf(StringVar, NVar, FormatVar, varArgs...)	740		cret := xSnprintf(StringVar, NVar, FormatVar, varArgs...)
		741	+
717	return cret	742		return cret
718	}	743		}
719		744

@@ -739,6 +764,7 @@ var xVsnprintf func(string, uint, string, []interface{}) int
739	func Vsnprintf(StringVar string, NVar uint, FormatVar string, ArgsVar []interface{}) int {	764		func Vsnprintf(StringVar string, NVar uint, FormatVar string, ArgsVar []interface{}) int {
740		765
741	cret := xVsnprintf(StringVar, NVar, FormatVar, ArgsVar)	766		cret := xVsnprintf(StringVar, NVar, FormatVar, ArgsVar)
		767	+
742	return cret	768		return cret
743	}	769		}
744		770

M v4/glib/guuid.go +2 -0


@@ -19,6 +19,7 @@ var xUuidStringIsValid func(string) bool
19	func UuidStringIsValid(StrVar string) bool {	19		func UuidStringIsValid(StrVar string) bool {
20		20
21	cret := xUuidStringIsValid(StrVar)	21		cret := xUuidStringIsValid(StrVar)
		22	+
22	return cret	23		return cret
23	}	24		}
24		25

@@ -30,6 +31,7 @@ var xUuidStringRandom func() string
30	func UuidStringRandom() string {	31		func UuidStringRandom() string {
31		32
32	cret := xUuidStringRandom()	33		cret := xUuidStringRandom()
		34	+
33	return cret	35		return cret
34	}	36		}
35		37

M v4/glib/gvariant-parser.go +1 -0


@@ -12,6 +12,7 @@ var xVariantParserGetErrorQuark func() Quark
12	func VariantParserGetErrorQuark() Quark {	12		func VariantParserGetErrorQuark() Quark {
13		13
14	cret := xVariantParserGetErrorQuark()	14		cret := xVariantParserGetErrorQuark()
		15	+
15	return cret	16		return cret
16	}	17		}
17		18

M v4/glib/gvariant.go +4 -0


@@ -2735,6 +2735,7 @@ var xVariantIsObjectPath func(string) bool
2735	func VariantIsObjectPath(StringVar string) bool {	2735		func VariantIsObjectPath(StringVar string) bool {
2736		2736
2737	cret := xVariantIsObjectPath(StringVar)	2737		cret := xVariantIsObjectPath(StringVar)
		2738	+
2738	return cret	2739		return cret
2739	}	2740		}
2740		2741

@@ -2749,6 +2750,7 @@ var xVariantIsSignature func(string) bool
2749	func VariantIsSignature(StringVar string) bool {	2750		func VariantIsSignature(StringVar string) bool {
2750		2751
2751	cret := xVariantIsSignature(StringVar)	2752		cret := xVariantIsSignature(StringVar)
		2753	+
2752	return cret	2754		return cret
2753	}	2755		}
2754		2756

@@ -2800,6 +2802,7 @@ func VariantParse(TypeVar VariantType, TextVar string, LimitVar string, Endptr
2800	defer core.GFreeNullable(EndptrVarPtr)	2802		defer core.GFreeNullable(EndptrVarPtr)
2801		2803
2802	cret := xVariantParse(TypeVar, TextVar, LimitVarPtr, EndptrVarPtr, &cerr)	2804		cret := xVariantParse(TypeVar, TextVar, LimitVarPtr, EndptrVarPtr, &cerr)
		2805	+
2803	if cerr == nil {	2806		if cerr == nil {
2804	return cret, nil	2807		return cret, nil
2805	}	2808		}

@@ -2845,6 +2848,7 @@ var xVariantParseErrorPrintContext func(*Error, string) string
2845	func VariantParseErrorPrintContext(ErrorVar *Error, SourceStrVar string) string {	2848		func VariantParseErrorPrintContext(ErrorVar *Error, SourceStrVar string) string {
2846		2849
2847	cret := xVariantParseErrorPrintContext(ErrorVar, SourceStrVar)	2850		cret := xVariantParseErrorPrintContext(ErrorVar, SourceStrVar)
		2851	+
2848	return cret	2852		return cret
2849	}	2853		}
2850		2854

M v4/glib/gvarianttype.go +4 -0


@@ -601,6 +601,7 @@ var xVariantTypeChecked func(string) *VariantType
601	func VariantTypeChecked(TypeStringVar string) *VariantType {	601		func VariantTypeChecked(TypeStringVar string) *VariantType {
602		602
603	cret := xVariantTypeChecked(TypeStringVar)	603		cret := xVariantTypeChecked(TypeStringVar)
		604	+
604	return cret	605		return cret
605	}	606		}
606		607

@@ -609,6 +610,7 @@ var xVariantTypeStringGetDepth func(string) uint
609	func VariantTypeStringGetDepth(TypeStringVar string) uint {	610		func VariantTypeStringGetDepth(TypeStringVar string) uint {
610		611
611	cret := xVariantTypeStringGetDepth(TypeStringVar)	612		cret := xVariantTypeStringGetDepth(TypeStringVar)
		613	+
612	return cret	614		return cret
613	}	615		}
614		616

@@ -622,6 +624,7 @@ var xVariantTypeStringIsValid func(string) bool
622	func VariantTypeStringIsValid(TypeStringVar string) bool {	624		func VariantTypeStringIsValid(TypeStringVar string) bool {
623		625
624	cret := xVariantTypeStringIsValid(TypeStringVar)	626		cret := xVariantTypeStringIsValid(TypeStringVar)
		627	+
625	return cret	628		return cret
626	}	629		}
627		630

@@ -647,6 +650,7 @@ func VariantTypeStringScan(StringVar string, LimitVar string, EndptrVar string
647	defer core.GFreeNullable(LimitVarPtr)	650		defer core.GFreeNullable(LimitVarPtr)
648		651
649	cret := xVariantTypeStringScan(StringVar, LimitVarPtr, EndptrVar)	652		cret := xVariantTypeStringScan(StringVar, LimitVarPtr, EndptrVar)
		653	+
650	return cret	654		return cret
651	}	655		}
652		656

M v4/glib/gversion.go +1 -0


@@ -26,6 +26,7 @@ var xCheckVersion func(uint, uint, uint) string
26	func CheckVersion(RequiredMajorVar uint, RequiredMinorVar uint, RequiredMicroVar uint) string {	26		func CheckVersion(RequiredMajorVar uint, RequiredMinorVar uint, RequiredMicroVar uint) string {
27		27
28	cret := xCheckVersion(RequiredMajorVar, RequiredMinorVar, RequiredMicroVar)	28		cret := xCheckVersion(RequiredMajorVar, RequiredMinorVar, RequiredMicroVar)
		29	+
29	return cret	30		return cret
30	}	31		}
31		32

M v4/glib/main.go +16 -0


@@ -11,6 +11,7 @@ var xBookmarkFileErrorQuark func() Quark
11	func BookmarkFileErrorQuark() Quark {	11		func BookmarkFileErrorQuark() Quark {
12		12
13	cret := xBookmarkFileErrorQuark()	13		cret := xBookmarkFileErrorQuark()
		14	+
14	return cret	15		return cret
15	}	16		}
16		17

@@ -19,6 +20,7 @@ var xConvertErrorQuark func() Quark
19	func ConvertErrorQuark() Quark {	20		func ConvertErrorQuark() Quark {
20		21
21	cret := xConvertErrorQuark()	22		cret := xConvertErrorQuark()
		23	+
22	return cret	24		return cret
23	}	25		}
24		26

@@ -27,6 +29,7 @@ var xFileErrorQuark func() Quark
27	func FileErrorQuark() Quark {	29		func FileErrorQuark() Quark {
28		30
29	cret := xFileErrorQuark()	31		cret := xFileErrorQuark()
		32	+
30	return cret	33		return cret
31	}	34		}
32		35

@@ -35,6 +38,7 @@ var xIoChannelErrorQuark func() Quark
35	func IoChannelErrorQuark() Quark {	38		func IoChannelErrorQuark() Quark {
36		39
37	cret := xIoChannelErrorQuark()	40		cret := xIoChannelErrorQuark()
		41	+
38	return cret	42		return cret
39	}	43		}
40		44

@@ -43,6 +47,7 @@ var xKeyFileErrorQuark func() Quark
43	func KeyFileErrorQuark() Quark {	47		func KeyFileErrorQuark() Quark {
44		48
45	cret := xKeyFileErrorQuark()	49		cret := xKeyFileErrorQuark()
		50	+
46	return cret	51		return cret
47	}	52		}
48		53

@@ -51,6 +56,7 @@ var xMarkupErrorQuark func() Quark
51	func MarkupErrorQuark() Quark {	56		func MarkupErrorQuark() Quark {
52		57
53	cret := xMarkupErrorQuark()	58		cret := xMarkupErrorQuark()
		59	+
54	return cret	60		return cret
55	}	61		}
56		62

@@ -59,6 +65,7 @@ var xNumberParserErrorQuark func() Quark
59	func NumberParserErrorQuark() Quark {	65		func NumberParserErrorQuark() Quark {
60		66
61	cret := xNumberParserErrorQuark()	67		cret := xNumberParserErrorQuark()
		68	+
62	return cret	69		return cret
63	}	70		}
64		71

@@ -67,6 +74,7 @@ var xOptionErrorQuark func() Quark
67	func OptionErrorQuark() Quark {	74		func OptionErrorQuark() Quark {
68		75
69	cret := xOptionErrorQuark()	76		cret := xOptionErrorQuark()
		77	+
70	return cret	78		return cret
71	}	79		}
72		80

@@ -75,6 +83,7 @@ var xRegexErrorQuark func() Quark
75	func RegexErrorQuark() Quark {	83		func RegexErrorQuark() Quark {
76		84
77	cret := xRegexErrorQuark()	85		cret := xRegexErrorQuark()
		86	+
78	return cret	87		return cret
79	}	88		}
80		89

@@ -83,6 +92,7 @@ var xShellErrorQuark func() Quark
83	func ShellErrorQuark() Quark {	92		func ShellErrorQuark() Quark {
84		93
85	cret := xShellErrorQuark()	94		cret := xShellErrorQuark()
		95	+
86	return cret	96		return cret
87	}	97		}
88		98

@@ -91,6 +101,7 @@ var xSpawnErrorQuark func() Quark
91	func SpawnErrorQuark() Quark {	101		func SpawnErrorQuark() Quark {
92		102
93	cret := xSpawnErrorQuark()	103		cret := xSpawnErrorQuark()
		104	+
94	return cret	105		return cret
95	}	106		}
96		107

@@ -99,6 +110,7 @@ var xSpawnExitErrorQuark func() Quark
99	func SpawnExitErrorQuark() Quark {	110		func SpawnExitErrorQuark() Quark {
100		111
101	cret := xSpawnExitErrorQuark()	112		cret := xSpawnExitErrorQuark()
		113	+
102	return cret	114		return cret
103	}	115		}
104		116

@@ -107,6 +119,7 @@ var xThreadErrorQuark func() Quark
107	func ThreadErrorQuark() Quark {	119		func ThreadErrorQuark() Quark {
108		120
109	cret := xThreadErrorQuark()	121		cret := xThreadErrorQuark()
		122	+
110	return cret	123		return cret
111	}	124		}
112		125

@@ -115,6 +128,7 @@ var xUnixErrorQuark func() Quark
115	func UnixErrorQuark() Quark {	128		func UnixErrorQuark() Quark {
116		129
117	cret := xUnixErrorQuark()	130		cret := xUnixErrorQuark()
		131	+
118	return cret	132		return cret
119	}	133		}
120		134

@@ -123,6 +137,7 @@ var xUriErrorQuark func() Quark
123	func UriErrorQuark() Quark {	137		func UriErrorQuark() Quark {
124		138
125	cret := xUriErrorQuark()	139		cret := xUriErrorQuark()
		140	+
126	return cret	141		return cret
127	}	142		}
128		143

@@ -131,6 +146,7 @@ var xVariantParseErrorQuark func() Quark
131	func VariantParseErrorQuark() Quark {	146		func VariantParseErrorQuark() Quark {
132		147
133	cret := xVariantParseErrorQuark()	148		cret := xVariantParseErrorQuark()
		149	+
134	return cret	150		return cret
135	}	151		}
136		152

M v4/glib/more.go +150 -0


@@ -187,6 +187,152 @@ func RemoveCallbackBySource(sourceID uint) {
187	callbacks.Unlock()	187		callbacks.Unlock()
188	}	188		}
189		189
		190	+	// ---------------------------------------------------------------------------
		191	+	// Source callback trampoline
		192	+	//
		193	+	// GLib source functions (IdleAdd, TimeoutAdd, etc.) previously allocated a new
		194	+	// purego callback slot for every invocation. purego has a hard limit of 2000
		195	+	// slots, so long-running programs that schedule many one-shot idle/timeout
		196	+	// callbacks would exhaust the pool and panic.
		197	+	//
		198	+	// The trampoline uses a single purego callback that dispatches through a
		199	+	// Go-side map keyed by an opaque ID passed as GLib's user_data pointer.
		200	+	// This means all IdleAdd/TimeoutAdd calls share ONE purego slot regardless
		201	+	// of how many are outstanding.
		202	+	// ---------------------------------------------------------------------------
		203	+
		204	+	// sourceEntry holds a registered GLib source callback.
		205	+	type sourceEntry struct {
		206	+	fn SourceFunc
		207	+	once bool // if true, automatically remove after first call (SourceOnceFunc semantics)
		208	+	}
		209	+
		210	+	var sourceTrampolines = struct {
		211	+	sync.Mutex
		212	+	nextID uintptr
		213	+	funcs map[uintptr]*sourceEntry
		214	+	sourceToDataID map[uint]uintptr // GLib source ID → trampoline data ID
		215	+	}{
		216	+	funcs: make(map[uintptr]*sourceEntry),
		217	+	sourceToDataID: make(map[uint]uintptr),
		218	+	}
		219	+
		220	+	// sourceTrampolineCb is the single purego callback shared by all source functions.
		221	+	// GLib calls it with the user_data we provided (our map key).
		222	+	var sourceTrampolineCb uintptr
		223	+
		224	+	// sourceTrampolineOnceCb is the single purego callback for SourceOnceFunc sources
		225	+	// (IdleAddOnce, TimeoutAddOnce). These have signature func(uintptr) with no return.
		226	+	var sourceTrampolineOnceCb uintptr
		227	+
		228	+	func initSourceTrampoline() {
		229	+	fn := func(id uintptr) uintptr {
		230	+	sourceTrampolines.Lock()
		231	+	entry, ok := sourceTrampolines.funcs[id]
		232	+	if !ok {
		233	+	sourceTrampolines.Unlock()
		234	+	return 0 // SOURCE_REMOVE — entry already cleaned up (e.g. by SourceRemove)
		235	+	}
		236	+	cb := entry.fn
		237	+	sourceTrampolines.Unlock()
		238	+
		239	+	result := cb(0)
		240	+
		241	+	if !result {
		242	+	sourceTrampolines.Lock()
		243	+	delete(sourceTrampolines.funcs, id)
		244	+	// Also clean up the reverse mapping (source ID → data ID).
		245	+	for sid, did := range sourceTrampolines.sourceToDataID {
		246	+	if did == id {
		247	+	delete(sourceTrampolines.sourceToDataID, sid)
		248	+	break
		249	+	}
		250	+	}
		251	+	sourceTrampolines.Unlock()
		252	+	}
		253	+	if result {
		254	+	return 1
		255	+	}
		256	+	return 0
		257	+	}
		258	+	sourceTrampolineCb = purego.NewCallback(fn)
		259	+
		260	+	onceFn := func(id uintptr) {
		261	+	sourceTrampolines.Lock()
		262	+	entry, ok := sourceTrampolines.funcs[id]
		263	+	if !ok {
		264	+	sourceTrampolines.Unlock()
		265	+	return
		266	+	}
		267	+	cb := entry.fn
		268	+	delete(sourceTrampolines.funcs, id)
		269	+	// Also clean up the reverse mapping.
		270	+	for sid, did := range sourceTrampolines.sourceToDataID {
		271	+	if did == id {
		272	+	delete(sourceTrampolines.sourceToDataID, sid)
		273	+	break
		274	+	}
		275	+	}
		276	+	sourceTrampolines.Unlock()
		277	+
		278	+	cb(0)
		279	+	}
		280	+	sourceTrampolineOnceCb = purego.NewCallback(onceFn)
		281	+	}
		282	+
		283	+	// registerSourceFunc stores a SourceFunc in the trampoline map and returns
		284	+	// the trampoline callback pointer and the user_data key.
		285	+	func registerSourceFunc(fn *SourceFunc, once bool) (trampolineCb uintptr, userData uintptr) {
		286	+	if fn == nil {
		287	+	return 0, 0
		288	+	}
		289	+	sourceTrampolines.Lock()
		290	+	sourceTrampolines.nextID++
		291	+	id := sourceTrampolines.nextID
		292	+	sourceTrampolines.funcs[id] = &sourceEntry{fn: *fn, once: once}
		293	+	sourceTrampolines.Unlock()
		294	+	if once {
		295	+	return sourceTrampolineOnceCb, id
		296	+	}
		297	+	return sourceTrampolineCb, id
		298	+	}
		299	+
		300	+	// registerSourceOnceFunc stores a SourceOnceFunc in the trampoline map and
		301	+	// returns the trampoline callback pointer and the user_data key.
		302	+	func registerSourceOnceFunc(fn *SourceOnceFunc) (trampolineCb uintptr, userData uintptr) {
		303	+	if fn == nil {
		304	+	return 0, 0
		305	+	}
		306	+	// Wrap SourceOnceFunc as SourceFunc so the entry type is uniform.
		307	+	wrapped := SourceFunc(func(data uintptr) bool {
		308	+	(*fn)(data)
		309	+	return false
		310	+	})
		311	+	return registerSourceFunc(&wrapped, true)
		312	+	}
		313	+
		314	+	// saveSourceTrampolineMapping records the GLib source ID → trampoline data ID
		315	+	// mapping so that SourceRemove can clean up the trampoline entry.
		316	+	func saveSourceTrampolineMapping(sourceID uint, dataID uintptr) {
		317	+	if sourceID == 0 {
		318	+	return
		319	+	}
		320	+	sourceTrampolines.Lock()
		321	+	sourceTrampolines.sourceToDataID[sourceID] = dataID
		322	+	sourceTrampolines.Unlock()
		323	+	}
		324	+
		325	+	// removeSourceTrampolineBySourceID cleans up trampoline state when a GLib
		326	+	// source is removed via SourceRemove (before the callback fires).
		327	+	func removeSourceTrampolineBySourceID(sourceID uint) {
		328	+	sourceTrampolines.Lock()
		329	+	if dataID, ok := sourceTrampolines.sourceToDataID[sourceID]; ok {
		330	+	delete(sourceTrampolines.sourceToDataID, sourceID)
		331	+	delete(sourceTrampolines.funcs, dataID)
		332	+	}
		333	+	sourceTrampolines.Unlock()
		334	+	}
		335	+
190	// UnrefCallbackValue unreferences the provided callback by reflect.value to free a purego slot	336		// UnrefCallbackValue unreferences the provided callback by reflect.value to free a purego slot
191	//	337		//
192	// NOTE: Windows does not support unreferencing callbacks, so on that platform this operation is	338		// NOTE: Windows does not support unreferencing callbacks, so on that platform this operation is

@@ -211,6 +357,10 @@ func NewCallbackNullable(fn interface{}) uintptr {
211	return NewCallback(fn)	357		return NewCallback(fn)
212	}	358		}
213		359
		360	+	func init() {
		361	+	initSourceTrampoline()
		362	+	}
		363	+
214	func (e *Error) Error() string {	364		func (e *Error) Error() string {
215	return fmt.Sprintf("Gtk reported an error with message: '%s', domain: '%v' and code: '%v'", e.MessageGo(), e.Domain, e.Code)	365		return fmt.Sprintf("Gtk reported an error with message: '%s', domain: '%v' and code: '%v'", e.MessageGo(), e.Domain, e.Code)
216	}	366		}