libc

package module
v0.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 17, 2023 License: BSD-3-Clause Imports: 55 Imported by: 5

README

libc

Package libc provides C-runtime services. Work in progress.

This package is a continuation of the Crt package in modernc.org/crt/v3.

Installation

$ go get [-u] modernc.org/libc

Documentation: godoc.org/modernc.org/libc

Building with make requires the following Go packages

  • github.com/golang/lint/golint
  • github.com/mdempsky/maligned
  • github.com/mdempsky/unconvert
  • honnef.co/go/tools/cmd/unused
  • honnef.co/go/tools/cmd/gosimple
  • github.com/client9/misspell/cmd/misspell

Documentation

Overview

Package libc provides run time support for ccgo generated programs and implements selected parts of the C standard library.

Index

Constants

View Source 
const (
	DT_EXITING  = 0
	DT_JOINABLE = 1
	DT_DETACHED = 2
)

Variables

View Source 
var (
	Covered  = map[uintptr]struct{}{}
	CoveredC = map[string]struct{}{}
)
View Source 
var (
	Windows_Tick   int64 = 10000000
	SecToUnixEpoch int64 = 11644473600
)
View Source 
var CAPI = map[string]struct{}{}/* 704 elements not displayed */
View Source 
var EBADF = errors.New("EBADF")
View Source 
var X__imp__environ = EnvironP()

Keep these outside of the var block otherwise go generate will miss them.

View Source 
var X__imp__wenviron = uintptr(unsafe.Pointer(&wenviron))
View Source 
var X_imp___environ = EnvironP()
View Source 
var X_iob [stdio.X_IOB_ENTRIES]stdio.FILE
View Source 
var Xenviron uintptr

Keep these outside of the var block otherwise go generate will miss them.

View Source 
var Xstderr = newFile(nil, unistd.STDERR_FILENO)
View Source 
var Xstdin = newFile(nil, unistd.STDIN_FILENO)
View Source 
var Xstdout = newFile(nil, unistd.STDOUT_FILENO)
View Source 
var Xtimezone long // extern long timezone;

Functions

func AssignAddComplex128 

func AssignAddComplex128(p *complex128, v complex128) complex128

func AssignAddComplex64 

func AssignAddComplex64(p *complex64, v complex64) complex64

func AssignAddFloat32 

func AssignAddFloat32(p *float32, v float32) float32

func AssignAddFloat64 

func AssignAddFloat64(p *float64, v float64) float64

func AssignAddInt16 

func AssignAddInt16(p *int16, v int16) int16

func AssignAddInt32 

func AssignAddInt32(p *int32, v int32) int32

func AssignAddInt64 

func AssignAddInt64(p *int64, v int64) int64

func AssignAddInt8 

func AssignAddInt8(p *int8, v int8) int8

func AssignAddPtrComplex128 

func AssignAddPtrComplex128(p uintptr, v complex128) complex128

func AssignAddPtrComplex64 

func AssignAddPtrComplex64(p uintptr, v complex64) complex64

func AssignAddPtrFloat32 

func AssignAddPtrFloat32(p uintptr, v float32) float32

func AssignAddPtrFloat64 

func AssignAddPtrFloat64(p uintptr, v float64) float64

func AssignAddPtrInt16 

func AssignAddPtrInt16(p uintptr, v int16) int16

func AssignAddPtrInt32 

func AssignAddPtrInt32(p uintptr, v int32) int32

func AssignAddPtrInt64 

func AssignAddPtrInt64(p uintptr, v int64) int64

func AssignAddPtrInt8 

func AssignAddPtrInt8(p uintptr, v int8) int8

func AssignAddPtrUint16 

func AssignAddPtrUint16(p uintptr, v uint16) uint16

func AssignAddPtrUint32 

func AssignAddPtrUint32(p uintptr, v uint32) uint32

func AssignAddPtrUint64 

func AssignAddPtrUint64(p uintptr, v uint64) uint64

func AssignAddPtrUint8 

func AssignAddPtrUint8(p uintptr, v uint8) uint8

func AssignAddPtrUintptr 

func AssignAddPtrUintptr(p uintptr, v uintptr) uintptr

func AssignAddUint16 

func AssignAddUint16(p *uint16, v uint16) uint16

func AssignAddUint32 

func AssignAddUint32(p *uint32, v uint32) uint32

func AssignAddUint64 

func AssignAddUint64(p *uint64, v uint64) uint64

func AssignAddUint8 

func AssignAddUint8(p *uint8, v uint8) uint8

func AssignAddUintptr 

func AssignAddUintptr(p *uintptr, v uintptr) uintptr

func AssignAndInt16 

func AssignAndInt16(p *int16, v int16) int16

func AssignAndInt32 

func AssignAndInt32(p *int32, v int32) int32

func AssignAndInt64 

func AssignAndInt64(p *int64, v int64) int64

func AssignAndInt8 

func AssignAndInt8(p *int8, v int8) int8

func AssignAndPtrInt16 

func AssignAndPtrInt16(p uintptr, v int16) int16

func AssignAndPtrInt32 

func AssignAndPtrInt32(p uintptr, v int32) int32

func AssignAndPtrInt64 

func AssignAndPtrInt64(p uintptr, v int64) int64

func AssignAndPtrInt8 

func AssignAndPtrInt8(p uintptr, v int8) int8

func AssignAndPtrUint16 

func AssignAndPtrUint16(p uintptr, v uint16) uint16

func AssignAndPtrUint32 

func AssignAndPtrUint32(p uintptr, v uint32) uint32

func AssignAndPtrUint64 

func AssignAndPtrUint64(p uintptr, v uint64) uint64

func AssignAndPtrUint8 

func AssignAndPtrUint8(p uintptr, v uint8) uint8

func AssignAndPtrUintptr 

func AssignAndPtrUintptr(p uintptr, v uintptr) uintptr

func AssignAndUint16 

func AssignAndUint16(p *uint16, v uint16) uint16

func AssignAndUint32 

func AssignAndUint32(p *uint32, v uint32) uint32

func AssignAndUint64 

func AssignAndUint64(p *uint64, v uint64) uint64

func AssignAndUint8 

func AssignAndUint8(p *uint8, v uint8) uint8

func AssignAndUintptr 

func AssignAndUintptr(p *uintptr, v uintptr) uintptr

func AssignBitFieldPtr16Int16 

func AssignBitFieldPtr16Int16(p uintptr, v int16, w, off int, mask uint16) int16

func AssignBitFieldPtr16Int32 

func AssignBitFieldPtr16Int32(p uintptr, v int32, w, off int, mask uint16) int32

func AssignBitFieldPtr16Int64 

func AssignBitFieldPtr16Int64(p uintptr, v int64, w, off int, mask uint16) int64

func AssignBitFieldPtr16Int8 

func AssignBitFieldPtr16Int8(p uintptr, v int8, w, off int, mask uint16) int8

func AssignBitFieldPtr16Uint16 

func AssignBitFieldPtr16Uint16(p uintptr, v uint16, w, off int, mask uint16) uint16

func AssignBitFieldPtr16Uint32 

func AssignBitFieldPtr16Uint32(p uintptr, v uint32, w, off int, mask uint16) uint32

func AssignBitFieldPtr16Uint64 

func AssignBitFieldPtr16Uint64(p uintptr, v uint64, w, off int, mask uint16) uint64

func AssignBitFieldPtr16Uint8 

func AssignBitFieldPtr16Uint8(p uintptr, v uint8, w, off int, mask uint16) uint8

func AssignBitFieldPtr32Int16 

func AssignBitFieldPtr32Int16(p uintptr, v int16, w, off int, mask uint32) int16

func AssignBitFieldPtr32Int32 

func AssignBitFieldPtr32Int32(p uintptr, v int32, w, off int, mask uint32) int32

func AssignBitFieldPtr32Int64 

func AssignBitFieldPtr32Int64(p uintptr, v int64, w, off int, mask uint32) int64

func AssignBitFieldPtr32Int8 

func AssignBitFieldPtr32Int8(p uintptr, v int8, w, off int, mask uint32) int8

func AssignBitFieldPtr32Uint16 

func AssignBitFieldPtr32Uint16(p uintptr, v uint16, w, off int, mask uint32) uint16

func AssignBitFieldPtr32Uint32 

func AssignBitFieldPtr32Uint32(p uintptr, v uint32, w, off int, mask uint32) uint32

func AssignBitFieldPtr32Uint64 

func AssignBitFieldPtr32Uint64(p uintptr, v uint64, w, off int, mask uint32) uint64

func AssignBitFieldPtr32Uint8 

func AssignBitFieldPtr32Uint8(p uintptr, v uint8, w, off int, mask uint32) uint8

func AssignBitFieldPtr64Int16 

func AssignBitFieldPtr64Int16(p uintptr, v int16, w, off int, mask uint64) int16

func AssignBitFieldPtr64Int32 

func AssignBitFieldPtr64Int32(p uintptr, v int32, w, off int, mask uint64) int32

func AssignBitFieldPtr64Int64 

func AssignBitFieldPtr64Int64(p uintptr, v int64, w, off int, mask uint64) int64

func AssignBitFieldPtr64Int8 

func AssignBitFieldPtr64Int8(p uintptr, v int8, w, off int, mask uint64) int8

func AssignBitFieldPtr64Uint16 

func AssignBitFieldPtr64Uint16(p uintptr, v uint16, w, off int, mask uint64) uint16

func AssignBitFieldPtr64Uint32 

func AssignBitFieldPtr64Uint32(p uintptr, v uint32, w, off int, mask uint64) uint32

func AssignBitFieldPtr64Uint64 

func AssignBitFieldPtr64Uint64(p uintptr, v uint64, w, off int, mask uint64) uint64

func AssignBitFieldPtr64Uint8 

func AssignBitFieldPtr64Uint8(p uintptr, v uint8, w, off int, mask uint64) uint8

func AssignBitFieldPtr8Int16 

func AssignBitFieldPtr8Int16(p uintptr, v int16, w, off int, mask uint8) int16

func AssignBitFieldPtr8Int32 

func AssignBitFieldPtr8Int32(p uintptr, v int32, w, off int, mask uint8) int32

func AssignBitFieldPtr8Int64 

func AssignBitFieldPtr8Int64(p uintptr, v int64, w, off int, mask uint8) int64

func AssignBitFieldPtr8Int8 

func AssignBitFieldPtr8Int8(p uintptr, v int8, w, off int, mask uint8) int8

func AssignBitFieldPtr8Uint16 

func AssignBitFieldPtr8Uint16(p uintptr, v uint16, w, off int, mask uint8) uint16

func AssignBitFieldPtr8Uint32 

func AssignBitFieldPtr8Uint32(p uintptr, v uint32, w, off int, mask uint8) uint32

func AssignBitFieldPtr8Uint64 

func AssignBitFieldPtr8Uint64(p uintptr, v uint64, w, off int, mask uint8) uint64

func AssignBitFieldPtr8Uint8 

func AssignBitFieldPtr8Uint8(p uintptr, v uint8, w, off int, mask uint8) uint8

func AssignComplex128 

func AssignComplex128(p *complex128, v complex128) complex128

func AssignComplex64 

func AssignComplex64(p *complex64, v complex64) complex64

func AssignDivComplex128 

func AssignDivComplex128(p *complex128, v complex128) complex128

func AssignDivComplex64 

func AssignDivComplex64(p *complex64, v complex64) complex64

func AssignDivFloat32 

func AssignDivFloat32(p *float32, v float32) float32

func AssignDivFloat64 

func AssignDivFloat64(p *float64, v float64) float64

func AssignDivInt16 

func AssignDivInt16(p *int16, v int16) int16

func AssignDivInt32 

func AssignDivInt32(p *int32, v int32) int32

func AssignDivInt64 

func AssignDivInt64(p *int64, v int64) int64

func AssignDivInt8 

func AssignDivInt8(p *int8, v int8) int8

func AssignDivPtrComplex128 

func AssignDivPtrComplex128(p uintptr, v complex128) complex128

func AssignDivPtrComplex64 

func AssignDivPtrComplex64(p uintptr, v complex64) complex64

func AssignDivPtrFloat32 

func AssignDivPtrFloat32(p uintptr, v float32) float32

func AssignDivPtrFloat64 

func AssignDivPtrFloat64(p uintptr, v float64) float64

func AssignDivPtrInt16 

func AssignDivPtrInt16(p uintptr, v int16) int16

func AssignDivPtrInt32 

func AssignDivPtrInt32(p uintptr, v int32) int32

func AssignDivPtrInt64 

func AssignDivPtrInt64(p uintptr, v int64) int64

func AssignDivPtrInt8 

func AssignDivPtrInt8(p uintptr, v int8) int8

func AssignDivPtrUint16 

func AssignDivPtrUint16(p uintptr, v uint16) uint16

func AssignDivPtrUint32 

func AssignDivPtrUint32(p uintptr, v uint32) uint32

func AssignDivPtrUint64 

func AssignDivPtrUint64(p uintptr, v uint64) uint64

func AssignDivPtrUint8 

func AssignDivPtrUint8(p uintptr, v uint8) uint8

func AssignDivPtrUintptr 

func AssignDivPtrUintptr(p uintptr, v uintptr) uintptr

func AssignDivUint16 

func AssignDivUint16(p *uint16, v uint16) uint16

func AssignDivUint32 

func AssignDivUint32(p *uint32, v uint32) uint32

func AssignDivUint64 

func AssignDivUint64(p *uint64, v uint64) uint64

func AssignDivUint8 

func AssignDivUint8(p *uint8, v uint8) uint8

func AssignDivUintptr 

func AssignDivUintptr(p *uintptr, v uintptr) uintptr

func AssignFloat32 

func AssignFloat32(p *float32, v float32) float32

func AssignFloat64 

func AssignFloat64(p *float64, v float64) float64

func AssignInt16 

func AssignInt16(p *int16, v int16) int16

func AssignInt32 

func AssignInt32(p *int32, v int32) int32

func AssignInt64 

func AssignInt64(p *int64, v int64) int64

func AssignInt8 

func AssignInt8(p *int8, v int8) int8

func AssignMulComplex128 

func AssignMulComplex128(p *complex128, v complex128) complex128

func AssignMulComplex64 

func AssignMulComplex64(p *complex64, v complex64) complex64

func AssignMulFloat32 

func AssignMulFloat32(p *float32, v float32) float32

func AssignMulFloat64 

func AssignMulFloat64(p *float64, v float64) float64

func AssignMulInt16 

func AssignMulInt16(p *int16, v int16) int16

func AssignMulInt32 

func AssignMulInt32(p *int32, v int32) int32

func AssignMulInt64 

func AssignMulInt64(p *int64, v int64) int64

func AssignMulInt8 

func AssignMulInt8(p *int8, v int8) int8

func AssignMulPtrComplex128 

func AssignMulPtrComplex128(p uintptr, v complex128) complex128

func AssignMulPtrComplex64 

func AssignMulPtrComplex64(p uintptr, v complex64) complex64

func AssignMulPtrFloat32 

func AssignMulPtrFloat32(p uintptr, v float32) float32

func AssignMulPtrFloat64 

func AssignMulPtrFloat64(p uintptr, v float64) float64

func AssignMulPtrInt16 

func AssignMulPtrInt16(p uintptr, v int16) int16

func AssignMulPtrInt32 

func AssignMulPtrInt32(p uintptr, v int32) int32

func AssignMulPtrInt64 

func AssignMulPtrInt64(p uintptr, v int64) int64

func AssignMulPtrInt8 

func AssignMulPtrInt8(p uintptr, v int8) int8

func AssignMulPtrUint16 

func AssignMulPtrUint16(p uintptr, v uint16) uint16

func AssignMulPtrUint32 

func AssignMulPtrUint32(p uintptr, v uint32) uint32

func AssignMulPtrUint64 

func AssignMulPtrUint64(p uintptr, v uint64) uint64

func AssignMulPtrUint8 

func AssignMulPtrUint8(p uintptr, v uint8) uint8

func AssignMulPtrUintptr 

func AssignMulPtrUintptr(p uintptr, v uintptr) uintptr

func AssignMulUint16 

func AssignMulUint16(p *uint16, v uint16) uint16

func AssignMulUint32 

func AssignMulUint32(p *uint32, v uint32) uint32

func AssignMulUint64 

func AssignMulUint64(p *uint64, v uint64) uint64

func AssignMulUint8 

func AssignMulUint8(p *uint8, v uint8) uint8

func AssignMulUintptr 

func AssignMulUintptr(p *uintptr, v uintptr) uintptr

func AssignOrInt16 

func AssignOrInt16(p *int16, v int16) int16

func AssignOrInt32 

func AssignOrInt32(p *int32, v int32) int32

func AssignOrInt64 

func AssignOrInt64(p *int64, v int64) int64

func AssignOrInt8 

func AssignOrInt8(p *int8, v int8) int8

func AssignOrPtrInt16 

func AssignOrPtrInt16(p uintptr, v int16) int16

func AssignOrPtrInt32 

func AssignOrPtrInt32(p uintptr, v int32) int32

func AssignOrPtrInt64 

func AssignOrPtrInt64(p uintptr, v int64) int64

func AssignOrPtrInt8 

func AssignOrPtrInt8(p uintptr, v int8) int8

func AssignOrPtrUint16 

func AssignOrPtrUint16(p uintptr, v uint16) uint16

func AssignOrPtrUint32 

func AssignOrPtrUint32(p uintptr, v uint32) uint32

func AssignOrPtrUint64 

func AssignOrPtrUint64(p uintptr, v uint64) uint64

func AssignOrPtrUint8 

func AssignOrPtrUint8(p uintptr, v uint8) uint8

func AssignOrPtrUintptr 

func AssignOrPtrUintptr(p uintptr, v uintptr) uintptr

func AssignOrUint16 

func AssignOrUint16(p *uint16, v uint16) uint16

func AssignOrUint32 

func AssignOrUint32(p *uint32, v uint32) uint32

func AssignOrUint64 

func AssignOrUint64(p *uint64, v uint64) uint64

func AssignOrUint8 

func AssignOrUint8(p *uint8, v uint8) uint8

func AssignOrUintptr 

func AssignOrUintptr(p *uintptr, v uintptr) uintptr

func AssignPtrComplex128 

func AssignPtrComplex128(p uintptr, v complex128) complex128

func AssignPtrComplex64 

func AssignPtrComplex64(p uintptr, v complex64) complex64

func AssignPtrFloat32 

func AssignPtrFloat32(p uintptr, v float32) float32

func AssignPtrFloat64 

func AssignPtrFloat64(p uintptr, v float64) float64

func AssignPtrInt16 

func AssignPtrInt16(p uintptr, v int16) int16

func AssignPtrInt32 

func AssignPtrInt32(p uintptr, v int32) int32

func AssignPtrInt64 

func AssignPtrInt64(p uintptr, v int64) int64

func AssignPtrInt8 

func AssignPtrInt8(p uintptr, v int8) int8

func AssignPtrUint16 

func AssignPtrUint16(p uintptr, v uint16) uint16

func AssignPtrUint32 

func AssignPtrUint32(p uintptr, v uint32) uint32

func AssignPtrUint64 

func AssignPtrUint64(p uintptr, v uint64) uint64

func AssignPtrUint8 

func AssignPtrUint8(p uintptr, v uint8) uint8

func AssignPtrUintptr 

func AssignPtrUintptr(p uintptr, v uintptr) uintptr

func AssignRemInt16 

func AssignRemInt16(p *int16, v int16) int16

func AssignRemInt32 

func AssignRemInt32(p *int32, v int32) int32

func AssignRemInt64 

func AssignRemInt64(p *int64, v int64) int64

func AssignRemInt8 

func AssignRemInt8(p *int8, v int8) int8

func AssignRemPtrInt16 

func AssignRemPtrInt16(p uintptr, v int16) int16

func AssignRemPtrInt32 

func AssignRemPtrInt32(p uintptr, v int32) int32

func AssignRemPtrInt64 

func AssignRemPtrInt64(p uintptr, v int64) int64

func AssignRemPtrInt8 

func AssignRemPtrInt8(p uintptr, v int8) int8

func AssignRemPtrUint16 

func AssignRemPtrUint16(p uintptr, v uint16) uint16

func AssignRemPtrUint32 

func AssignRemPtrUint32(p uintptr, v uint32) uint32

func AssignRemPtrUint64 

func AssignRemPtrUint64(p uintptr, v uint64) uint64

func AssignRemPtrUint8 

func AssignRemPtrUint8(p uintptr, v uint8) uint8

func AssignRemPtrUintptr 

func AssignRemPtrUintptr(p uintptr, v uintptr) uintptr

func AssignRemUint16 

func AssignRemUint16(p *uint16, v uint16) uint16

func AssignRemUint32 

func AssignRemUint32(p *uint32, v uint32) uint32

func AssignRemUint64 

func AssignRemUint64(p *uint64, v uint64) uint64

func AssignRemUint8 

func AssignRemUint8(p *uint8, v uint8) uint8

func AssignRemUintptr 

func AssignRemUintptr(p *uintptr, v uintptr) uintptr

func AssignShlInt16 

func AssignShlInt16(p *int16, v int) int16

func AssignShlInt32 

func AssignShlInt32(p *int32, v int) int32

func AssignShlInt64 

func AssignShlInt64(p *int64, v int) int64

func AssignShlInt8 

func AssignShlInt8(p *int8, v int) int8

func AssignShlPtrInt16 

func AssignShlPtrInt16(p uintptr, v int) int16

func AssignShlPtrInt32 

func AssignShlPtrInt32(p uintptr, v int) int32

func AssignShlPtrInt64 

func AssignShlPtrInt64(p uintptr, v int) int64

func AssignShlPtrInt8 

func AssignShlPtrInt8(p uintptr, v int) int8

func AssignShlPtrUint16 

func AssignShlPtrUint16(p uintptr, v int) uint16

func AssignShlPtrUint32 

func AssignShlPtrUint32(p uintptr, v int) uint32

func AssignShlPtrUint64 

func AssignShlPtrUint64(p uintptr, v int) uint64

func AssignShlPtrUint8 

func AssignShlPtrUint8(p uintptr, v int) uint8

func AssignShlPtrUintptr 

func AssignShlPtrUintptr(p uintptr, v int) uintptr

func AssignShlUint16 

func AssignShlUint16(p *uint16, v int) uint16

func AssignShlUint32 

func AssignShlUint32(p *uint32, v int) uint32

func AssignShlUint64 

func AssignShlUint64(p *uint64, v int) uint64

func AssignShlUint8 

func AssignShlUint8(p *uint8, v int) uint8

func AssignShlUintptr 

func AssignShlUintptr(p *uintptr, v int) uintptr

func AssignShrInt16 

func AssignShrInt16(p *int16, v int) int16

func AssignShrInt32 

func AssignShrInt32(p *int32, v int) int32

func AssignShrInt64 

func AssignShrInt64(p *int64, v int) int64

func AssignShrInt8 

func AssignShrInt8(p *int8, v int) int8

func AssignShrPtrInt16 

func AssignShrPtrInt16(p uintptr, v int) int16

func AssignShrPtrInt32 

func AssignShrPtrInt32(p uintptr, v int) int32

func AssignShrPtrInt64 

func AssignShrPtrInt64(p uintptr, v int) int64

func AssignShrPtrInt8 

func AssignShrPtrInt8(p uintptr, v int) int8

func AssignShrPtrUint16 

func AssignShrPtrUint16(p uintptr, v int) uint16

func AssignShrPtrUint32 

func AssignShrPtrUint32(p uintptr, v int) uint32

func AssignShrPtrUint64 

func AssignShrPtrUint64(p uintptr, v int) uint64

func AssignShrPtrUint8 

func AssignShrPtrUint8(p uintptr, v int) uint8

func AssignShrPtrUintptr 

func AssignShrPtrUintptr(p uintptr, v int) uintptr

func AssignShrUint16 

func AssignShrUint16(p *uint16, v int) uint16

func AssignShrUint32 

func AssignShrUint32(p *uint32, v int) uint32

func AssignShrUint64 

func AssignShrUint64(p *uint64, v int) uint64

func AssignShrUint8 

func AssignShrUint8(p *uint8, v int) uint8

func AssignShrUintptr 

func AssignShrUintptr(p *uintptr, v int) uintptr

func AssignSubComplex128 

func AssignSubComplex128(p *complex128, v complex128) complex128

func AssignSubComplex64 

func AssignSubComplex64(p *complex64, v complex64) complex64

func AssignSubFloat32 

func AssignSubFloat32(p *float32, v float32) float32

func AssignSubFloat64 

func AssignSubFloat64(p *float64, v float64) float64

func AssignSubInt16 

func AssignSubInt16(p *int16, v int16) int16

func AssignSubInt32 

func AssignSubInt32(p *int32, v int32) int32

func AssignSubInt64 

func AssignSubInt64(p *int64, v int64) int64

func AssignSubInt8 

func AssignSubInt8(p *int8, v int8) int8

func AssignSubPtrComplex128 

func AssignSubPtrComplex128(p uintptr, v complex128) complex128

func AssignSubPtrComplex64 

func AssignSubPtrComplex64(p uintptr, v complex64) complex64

func AssignSubPtrFloat32 

func AssignSubPtrFloat32(p uintptr, v float32) float32

func AssignSubPtrFloat64 

func AssignSubPtrFloat64(p uintptr, v float64) float64

func AssignSubPtrInt16 

func AssignSubPtrInt16(p uintptr, v int16) int16

func AssignSubPtrInt32 

func AssignSubPtrInt32(p uintptr, v int32) int32

func AssignSubPtrInt64 

func AssignSubPtrInt64(p uintptr, v int64) int64

func AssignSubPtrInt8 

func AssignSubPtrInt8(p uintptr, v int8) int8

func AssignSubPtrUint16 

func AssignSubPtrUint16(p uintptr, v uint16) uint16

func AssignSubPtrUint32 

func AssignSubPtrUint32(p uintptr, v uint32) uint32

func AssignSubPtrUint64 

func AssignSubPtrUint64(p uintptr, v uint64) uint64

func AssignSubPtrUint8 

func AssignSubPtrUint8(p uintptr, v uint8) uint8

func AssignSubPtrUintptr 

func AssignSubPtrUintptr(p uintptr, v uintptr) uintptr

func AssignSubUint16 

func AssignSubUint16(p *uint16, v uint16) uint16

func AssignSubUint32 

func AssignSubUint32(p *uint32, v uint32) uint32

func AssignSubUint64 

func AssignSubUint64(p *uint64, v uint64) uint64

func AssignSubUint8 

func AssignSubUint8(p *uint8, v uint8) uint8

func AssignSubUintptr 

func AssignSubUintptr(p *uintptr, v uintptr) uintptr

func AssignUint16 

func AssignUint16(p *uint16, v uint16) uint16

func AssignUint32 

func AssignUint32(p *uint32, v uint32) uint32

func AssignUint64 

func AssignUint64(p *uint64, v uint64) uint64

func AssignUint8 

func AssignUint8(p *uint8, v uint8) uint8

func AssignUintptr 

func AssignUintptr(p *uintptr, v uintptr) uintptr

func AssignXorInt16 

func AssignXorInt16(p *int16, v int16) int16

func AssignXorInt32 

func AssignXorInt32(p *int32, v int32) int32

func AssignXorInt64 

func AssignXorInt64(p *int64, v int64) int64

func AssignXorInt8 

func AssignXorInt8(p *int8, v int8) int8

func AssignXorPtrInt16 

func AssignXorPtrInt16(p uintptr, v int16) int16

func AssignXorPtrInt32 

func AssignXorPtrInt32(p uintptr, v int32) int32

func AssignXorPtrInt64 

func AssignXorPtrInt64(p uintptr, v int64) int64

func AssignXorPtrInt8 

func AssignXorPtrInt8(p uintptr, v int8) int8

func AssignXorPtrUint16 

func AssignXorPtrUint16(p uintptr, v uint16) uint16

func AssignXorPtrUint32 

func AssignXorPtrUint32(p uintptr, v uint32) uint32

func AssignXorPtrUint64 

func AssignXorPtrUint64(p uintptr, v uint64) uint64

func AssignXorPtrUint8 

func AssignXorPtrUint8(p uintptr, v uint8) uint8

func AssignXorPtrUintptr 

func AssignXorPtrUintptr(p uintptr, v uintptr) uintptr

func AssignXorUint16 

func AssignXorUint16(p *uint16, v uint16) uint16

func AssignXorUint32 

func AssignXorUint32(p *uint32, v uint32) uint32

func AssignXorUint64 

func AssignXorUint64(p *uint64, v uint64) uint64

func AssignXorUint8 

func AssignXorUint8(p *uint8, v uint8) uint8

func AssignXorUintptr 

func AssignXorUintptr(p *uintptr, v uintptr) uintptr

func AtExit 

func AtExit(f func())

AtExit will attempt to run f at process exit. The execution cannot be guaranteed, neither its ordering with respect to any other handlers registered by AtExit.

func AtomicAddFloat32 

func AtomicAddFloat32(addr *float32, delta float32) (new float32)

func AtomicAddFloat64 

func AtomicAddFloat64(addr *float64, delta float64) (new float64)

func AtomicAddInt32 

func AtomicAddInt32(addr *int32, delta int32) (new int32)

func AtomicAddInt64 

func AtomicAddInt64(addr *int64, delta int64) (new int64)

func AtomicAddUint32 

func AtomicAddUint32(addr *uint32, delta uint32) (new uint32)

func AtomicAddUint64 

func AtomicAddUint64(addr *uint64, delta uint64) (new uint64)

func AtomicAddUintptr 

func AtomicAddUintptr(addr *uintptr, delta uintptr) (new uintptr)

func AtomicLoadFloat32 

func AtomicLoadFloat32(addr *float32) (val float32)

func AtomicLoadFloat64 

func AtomicLoadFloat64(addr *float64) (val float64)

func AtomicLoadInt32 

func AtomicLoadInt32(addr *int32) (val int32)

func AtomicLoadInt64 

func AtomicLoadInt64(addr *int64) (val int64)

func AtomicLoadNInt32 

func AtomicLoadNInt32(ptr uintptr, memorder int32) int32

func AtomicLoadNInt64 

func AtomicLoadNInt64(ptr uintptr, memorder int32) int64

func AtomicLoadNUint16 

func AtomicLoadNUint16(ptr uintptr, memorder int32) uint16

func AtomicLoadNUint32 

func AtomicLoadNUint32(ptr uintptr, memorder int32) uint32

func AtomicLoadNUint64 

func AtomicLoadNUint64(ptr uintptr, memorder int32) uint64

func AtomicLoadNUintptr 

func AtomicLoadNUintptr(ptr uintptr, memorder int32) uintptr

func AtomicLoadPFloat32 

func AtomicLoadPFloat32(addr uintptr) (val float32)

func AtomicLoadPFloat64 

func AtomicLoadPFloat64(addr uintptr) (val float64)

func AtomicLoadPInt32 

func AtomicLoadPInt32(addr uintptr) (val int32)

func AtomicLoadPInt64 

func AtomicLoadPInt64(addr uintptr) (val int64)

func AtomicLoadPUint32 

func AtomicLoadPUint32(addr uintptr) (val uint32)

func AtomicLoadPUint64 

func AtomicLoadPUint64(addr uintptr) (val uint64)

func AtomicLoadPUintptr 

func AtomicLoadPUintptr(addr uintptr) (val uintptr)

func AtomicLoadUint32 

func AtomicLoadUint32(addr *uint32) (val uint32)

func AtomicLoadUint64 

func AtomicLoadUint64(addr *uint64) (val uint64)

func AtomicLoadUintptr 

func AtomicLoadUintptr(addr *uintptr) (val uintptr)

func AtomicStoreFloat32 

func AtomicStoreFloat32(addr *float32, val float32)

func AtomicStoreFloat64 

func AtomicStoreFloat64(addr *float64, val float64)

func AtomicStoreInt32 

func AtomicStoreInt32(addr *int32, val int32)

func AtomicStoreInt64 

func AtomicStoreInt64(addr *int64, val int64)

func AtomicStoreNInt32 

func AtomicStoreNInt32(ptr uintptr, val int32, memorder int32)

func AtomicStoreNInt64 

func AtomicStoreNInt64(ptr uintptr, val int64, memorder int32)

func AtomicStoreNUint16 

func AtomicStoreNUint16(ptr uintptr, val uint16, memorder int32)

func AtomicStoreNUint32 

func AtomicStoreNUint32(ptr uintptr, val uint32, memorder int32)

func AtomicStoreNUint64 

func AtomicStoreNUint64(ptr uintptr, val uint64, memorder int32)

func AtomicStoreNUintptr 

func AtomicStoreNUintptr(ptr uintptr, val uintptr, memorder int32)

func AtomicStorePFloat32 

func AtomicStorePFloat32(addr uintptr, val float32)

func AtomicStorePFloat64 

func AtomicStorePFloat64(addr uintptr, val float64)

func AtomicStorePInt32 

func AtomicStorePInt32(addr uintptr, val int32)

func AtomicStorePInt64 

func AtomicStorePInt64(addr uintptr, val int64)

func AtomicStorePUint32 

func AtomicStorePUint32(addr uintptr, val uint32)

func AtomicStorePUint64 

func AtomicStorePUint64(addr uintptr, val uint64)

func AtomicStorePUintptr 

func AtomicStorePUintptr(addr uintptr, val uintptr)

func AtomicStoreUint32 

func AtomicStoreUint32(addr *uint32, val uint32)

func AtomicStoreUint64 

func AtomicStoreUint64(addr *uint64, val uint64)

func AtomicStoreUintptr 

func AtomicStoreUintptr(addr *uintptr, val uintptr)

func Bool32 

func Bool32(b bool) int32

func Bool64 

func Bool64(b bool) int64

func BoolInt16 

func BoolInt16(b bool) int16

func BoolInt32 

func BoolInt32(b bool) int32

func BoolInt64 

func BoolInt64(b bool) int64

func BoolInt8 

func BoolInt8(b bool) int8

func BoolUint16 

func BoolUint16(b bool) uint16

func BoolUint32 

func BoolUint32(b bool) uint32

func BoolUint64 

func BoolUint64(b bool) uint64

func BoolUint8 

func BoolUint8(b bool) uint8

func BoolUintptr 

func BoolUintptr(b bool) uintptr

func CString 

func CString(s string) (uintptr, error)

func Complex128 

func Complex128(n complex128) complex128

func Complex128FromComplex128 

func Complex128FromComplex128(n complex128) complex128

func Complex128FromComplex64 

func Complex128FromComplex64(n complex64) complex128

func Complex128FromFloat32 

func Complex128FromFloat32(n float32) complex128

func Complex128FromFloat64 

func Complex128FromFloat64(n float64) complex128

func Complex128FromInt16 

func Complex128FromInt16(n int16) complex128

func Complex128FromInt32 

func Complex128FromInt32(n int32) complex128

func Complex128FromInt64 

func Complex128FromInt64(n int64) complex128

func Complex128FromInt8 

func Complex128FromInt8(n int8) complex128

func Complex128FromUint16 

func Complex128FromUint16(n uint16) complex128

func Complex128FromUint32 

func Complex128FromUint32(n uint32) complex128

func Complex128FromUint64 

func Complex128FromUint64(n uint64) complex128

func Complex128FromUint8 

func Complex128FromUint8(n uint8) complex128

func Complex128FromUintptr 

func Complex128FromUintptr(n uintptr) complex128

func Complex64 

func Complex64(n complex64) complex64

func Complex64FromComplex128 

func Complex64FromComplex128(n complex128) complex64

func Complex64FromComplex64 

func Complex64FromComplex64(n complex64) complex64

func Complex64FromFloat32 

func Complex64FromFloat32(n float32) complex64

func Complex64FromFloat64 

func Complex64FromFloat64(n float64) complex64

func Complex64FromInt16 

func Complex64FromInt16(n int16) complex64

func Complex64FromInt32 

func Complex64FromInt32(n int32) complex64

func Complex64FromInt64 

func Complex64FromInt64(n int64) complex64

func Complex64FromInt8 

func Complex64FromInt8(n int8) complex64

func Complex64FromUint16 

func Complex64FromUint16(n uint16) complex64

func Complex64FromUint32 

func Complex64FromUint32(n uint32) complex64

func Complex64FromUint64 

func Complex64FromUint64(n uint64) complex64

func Complex64FromUint8 

func Complex64FromUint8(n uint8) complex64

func Complex64FromUintptr 

func Complex64FromUintptr(n uintptr) complex64

func Cover 

func Cover()

func CoverC 

func CoverC(s string)

func CoverCReport 

func CoverCReport(w io.Writer) error

func CoverReport 

func CoverReport(w io.Writer) error

func CplInt16 

func CplInt16(n int16) int16

func CplInt32 

func CplInt32(n int32) int32

func CplInt64 

func CplInt64(n int64) int64

func CplInt8 

func CplInt8(n int8) int8

func CplUint16 

func CplUint16(n uint16) uint16

func CplUint32 

func CplUint32(n uint32) uint32

func CplUint64 

func CplUint64(n uint64) uint64

func CplUint8 

func CplUint8(n uint8) uint8

func CplUintptr 

func CplUintptr(n uintptr) uintptr

func Dmesg 

func Dmesg(s string, args ...interface{})

func Environ 

func Environ() uintptr

func EnvironP 

func EnvironP() uintptr

func Float32 

func Float32(n float32) float32

func Float32FromComplex128 

func Float32FromComplex128(n complex128) float32

func Float32FromComplex64 

func Float32FromComplex64(n complex64) float32

func Float32FromFloat32 

func Float32FromFloat32(n float32) float32

func Float32FromFloat64 

func Float32FromFloat64(n float64) float32

func Float32FromInt16 

func Float32FromInt16(n int16) float32

func Float32FromInt32 

func Float32FromInt32(n int32) float32

func Float32FromInt64 

func Float32FromInt64(n int64) float32

func Float32FromInt8 

func Float32FromInt8(n int8) float32

func Float32FromUint16 

func Float32FromUint16(n uint16) float32

func Float32FromUint32 

func Float32FromUint32(n uint32) float32

func Float32FromUint64 

func Float32FromUint64(n uint64) float32

func Float32FromUint8 

func Float32FromUint8(n uint8) float32

func Float32FromUintptr 

func Float32FromUintptr(n uintptr) float32

func Float64 

func Float64(n float64) float64

func Float64FromComplex128 

func Float64FromComplex128(n complex128) float64

func Float64FromComplex64 

func Float64FromComplex64(n complex64) float64

func Float64FromFloat32 

func Float64FromFloat32(n float32) float64

func Float64FromFloat64 

func Float64FromFloat64(n float64) float64

func Float64FromInt16 

func Float64FromInt16(n int16) float64

func Float64FromInt32 

func Float64FromInt32(n int32) float64

func Float64FromInt64 

func Float64FromInt64(n int64) float64

func Float64FromInt8 

func Float64FromInt8(n int8) float64

func Float64FromUint16 

func Float64FromUint16(n uint16) float64

func Float64FromUint32 

func Float64FromUint32(n uint32) float64

func Float64FromUint64 

func Float64FromUint64(n uint64) float64

func Float64FromUint8 

func Float64FromUint8(n uint8) float64

func Float64FromUintptr 

func Float64FromUintptr(n uintptr) float64

func GetEnviron 

func GetEnviron() (r []string)

func GoBytes 

func GoBytes(s uintptr, len int) []byte

GoBytes returns a byte slice from a C char* having length len bytes.

func GoString 

func GoString(s uintptr) string

func Int16 

func Int16(n int16) int16

func Int16FromComplex128 

func Int16FromComplex128(n complex128) int16

func Int16FromComplex64 

func Int16FromComplex64(n complex64) int16

func Int16FromFloat32 

func Int16FromFloat32(n float32) int16

func Int16FromFloat64 

func Int16FromFloat64(n float64) int16

func Int16FromInt16 

func Int16FromInt16(n int16) int16

func Int16FromInt32 

func Int16FromInt32(n int32) int16

func Int16FromInt64 

func Int16FromInt64(n int64) int16

func Int16FromInt8 

func Int16FromInt8(n int8) int16

func Int16FromUint16 

func Int16FromUint16(n uint16) int16

func Int16FromUint32 

func Int16FromUint32(n uint32) int16

func Int16FromUint64 

func Int16FromUint64(n uint64) int16

func Int16FromUint8 

func Int16FromUint8(n uint8) int16

func Int16FromUintptr 

func Int16FromUintptr(n uintptr) int16

func Int32 

func Int32(n int32) int32

func Int32FromComplex128 

func Int32FromComplex128(n complex128) int32

func Int32FromComplex64 

func Int32FromComplex64(n complex64) int32

func Int32FromFloat32 

func Int32FromFloat32(n float32) int32

func Int32FromFloat64 

func Int32FromFloat64(n float64) int32

func Int32FromInt16 

func Int32FromInt16(n int16) int32

func Int32FromInt32 

func Int32FromInt32(n int32) int32

func Int32FromInt64 

func Int32FromInt64(n int64) int32

func Int32FromInt8 

func Int32FromInt8(n int8) int32

func Int32FromUint16 

func Int32FromUint16(n uint16) int32

func Int32FromUint32 

func Int32FromUint32(n uint32) int32

func Int32FromUint64 

func Int32FromUint64(n uint64) int32

func Int32FromUint8 

func Int32FromUint8(n uint8) int32

func Int32FromUintptr 

func Int32FromUintptr(n uintptr) int32

func Int64 

func Int64(n int64) int64

func Int64FromComplex128 

func Int64FromComplex128(n complex128) int64

func Int64FromComplex64 

func Int64FromComplex64(n complex64) int64

func Int64FromFloat32 

func Int64FromFloat32(n float32) int64

func Int64FromFloat64 

func Int64FromFloat64(n float64) int64

func Int64FromInt16 

func Int64FromInt16(n int16) int64

func Int64FromInt32 

func Int64FromInt32(n int32) int64

func Int64FromInt64 

func Int64FromInt64(n int64) int64

func Int64FromInt8 

func Int64FromInt8(n int8) int64

func Int64FromUint16 

func Int64FromUint16(n uint16) int64

func Int64FromUint32 

func Int64FromUint32(n uint32) int64

func Int64FromUint64 

func Int64FromUint64(n uint64) int64

func Int64FromUint8 

func Int64FromUint8(n uint8) int64

func Int64FromUintptr 

func Int64FromUintptr(n uintptr) int64

func Int8 

func Int8(n int8) int8

func Int8FromComplex128 

func Int8FromComplex128(n complex128) int8

func Int8FromComplex64 

func Int8FromComplex64(n complex64) int8

func Int8FromFloat32 

func Int8FromFloat32(n float32) int8

func Int8FromFloat64 

func Int8FromFloat64(n float64) int8

func Int8FromInt16 

func Int8FromInt16(n int16) int8

func Int8FromInt32 

func Int8FromInt32(n int32) int8

func Int8FromInt64 

func Int8FromInt64(n int64) int8

func Int8FromInt8 

func Int8FromInt8(n int8) int8

func Int8FromUint16 

func Int8FromUint16(n uint16) int8

func Int8FromUint32 

func Int8FromUint32(n uint32) int8

func Int8FromUint64 

func Int8FromUint64(n uint64) int8

func Int8FromUint8 

func Int8FromUint8(n uint8) int8

func Int8FromUintptr 

func Int8FromUintptr(n uintptr) int8

func MemAuditReport 

func MemAuditReport() error

MemAuditReport locks the memory allocator, reports memory leaks, if any. Finally it disables memory auditing and unlocks the memory allocator.

This memory auditing functionality has to be enabled using the libc.memgrind build tag.

It is intended only for debug/test builds. It slows down memory allocation routines and it has additional memory costs.

func MemAuditStart 

func MemAuditStart()

MemAuditStart locks the memory allocator, initializes and enables memory auditing. Finaly it unlocks the memory allocator.

Some memory handling errors, like double free or freeing of unallocated memory, will panic when memory auditing is enabled.

This memory auditing functionality has to be enabled using the libc.memgrind build tag.

It is intended only for debug/test builds. It slows down memory allocation routines and it has additional memory costs.

func NegInt16 

func NegInt16(n int16) int16

func NegInt32 

func NegInt32(n int32) int32

func NegInt64 

func NegInt64(n int64) int64

func NegInt8 

func NegInt8(n int8) int8

func NegUint16 

func NegUint16(n uint16) uint16

func NegUint32 

func NegUint32(n uint32) uint32

func NegUint64 

func NegUint64(n uint64) uint64

func NegUint8 

func NegUint8(n uint8) uint8

func NegUintptr 

func NegUintptr(n uintptr) uintptr

func NewVaList 

func NewVaList(args ...interface{}) (va_list uintptr)

NewVaList is like VaList but automatically allocates the correct amount of memory for all of the items in args.

The va_list return value is used to pass the constructed var args to var args accepting functions. The caller of NewVaList is responsible for freeing the va_list.

func NewVaListN 

func NewVaListN(n int) (va_list uintptr)

NewVaListN returns a newly allocated va_list for n items. The caller of NewVaListN is responsible for freeing the va_list.

func PostDecAtomicInt32 

func PostDecAtomicInt32(p *int32, d int32) int32

func PostDecAtomicInt64 

func PostDecAtomicInt64(p *int64, d int64) int64

func PostDecAtomicUint32 

func PostDecAtomicUint32(p *uint32, d uint32) uint32

func PostDecAtomicUint64 

func PostDecAtomicUint64(p *uint64, d uint64) uint64

func PostDecAtomicUintptr 

func PostDecAtomicUintptr(p *uintptr, d uintptr) uintptr

func PostDecBitFieldPtr16Int16 

func PostDecBitFieldPtr16Int16(p uintptr, d int16, w, off int, mask uint16) (r int16)

func PostDecBitFieldPtr16Int32 

func PostDecBitFieldPtr16Int32(p uintptr, d int32, w, off int, mask uint16) (r int32)

func PostDecBitFieldPtr16Int64 

func PostDecBitFieldPtr16Int64(p uintptr, d int64, w, off int, mask uint16) (r int64)

func PostDecBitFieldPtr16Int8 

func PostDecBitFieldPtr16Int8(p uintptr, d int8, w, off int, mask uint16) (r int8)

func PostDecBitFieldPtr16Uint16 

func PostDecBitFieldPtr16Uint16(p uintptr, d uint16, w, off int, mask uint16) (r uint16)

func PostDecBitFieldPtr16Uint32 

func PostDecBitFieldPtr16Uint32(p uintptr, d uint32, w, off int, mask uint16) (r uint32)

func PostDecBitFieldPtr16Uint64 

func PostDecBitFieldPtr16Uint64(p uintptr, d uint64, w, off int, mask uint16) (r uint64)

func PostDecBitFieldPtr16Uint8 

func PostDecBitFieldPtr16Uint8(p uintptr, d uint8, w, off int, mask uint16) (r uint8)

func PostDecBitFieldPtr32Int16 

func PostDecBitFieldPtr32Int16(p uintptr, d int16, w, off int, mask uint32) (r int16)

func PostDecBitFieldPtr32Int32 

func PostDecBitFieldPtr32Int32(p uintptr, d int32, w, off int, mask uint32) (r int32)

func PostDecBitFieldPtr32Int64 

func PostDecBitFieldPtr32Int64(p uintptr, d int64, w, off int, mask uint32) (r int64)

func PostDecBitFieldPtr32Int8 

func PostDecBitFieldPtr32Int8(p uintptr, d int8, w, off int, mask uint32) (r int8)

func PostDecBitFieldPtr32Uint16 

func PostDecBitFieldPtr32Uint16(p uintptr, d uint16, w, off int, mask uint32) (r uint16)

func PostDecBitFieldPtr32Uint32 

func PostDecBitFieldPtr32Uint32(p uintptr, d uint32, w, off int, mask uint32) (r uint32)

func PostDecBitFieldPtr32Uint64 

func PostDecBitFieldPtr32Uint64(p uintptr, d uint64, w, off int, mask uint32) (r uint64)

func PostDecBitFieldPtr32Uint8 

func PostDecBitFieldPtr32Uint8(p uintptr, d uint8, w, off int, mask uint32) (r uint8)

func PostDecBitFieldPtr64Int16 

func PostDecBitFieldPtr64Int16(p uintptr, d int16, w, off int, mask uint64) (r int16)

func PostDecBitFieldPtr64Int32 

func PostDecBitFieldPtr64Int32(p uintptr, d int32, w, off int, mask uint64) (r int32)

func PostDecBitFieldPtr64Int64 

func PostDecBitFieldPtr64Int64(p uintptr, d int64, w, off int, mask uint64) (r int64)

func PostDecBitFieldPtr64Int8 

func PostDecBitFieldPtr64Int8(p uintptr, d int8, w, off int, mask uint64) (r int8)

func PostDecBitFieldPtr64Uint16 

func PostDecBitFieldPtr64Uint16(p uintptr, d uint16, w, off int, mask uint64) (r uint16)

func PostDecBitFieldPtr64Uint32 

func PostDecBitFieldPtr64Uint32(p uintptr, d uint32, w, off int, mask uint64) (r uint32)

func PostDecBitFieldPtr64Uint64 

func PostDecBitFieldPtr64Uint64(p uintptr, d uint64, w, off int, mask uint64) (r uint64)

func PostDecBitFieldPtr64Uint8 

func PostDecBitFieldPtr64Uint8(p uintptr, d uint8, w, off int, mask uint64) (r uint8)

func PostDecBitFieldPtr8Int16 

func PostDecBitFieldPtr8Int16(p uintptr, d int16, w, off int, mask uint8) (r int16)

func PostDecBitFieldPtr8Int32 

func PostDecBitFieldPtr8Int32(p uintptr, d int32, w, off int, mask uint8) (r int32)

func PostDecBitFieldPtr8Int64 

func PostDecBitFieldPtr8Int64(p uintptr, d int64, w, off int, mask uint8) (r int64)

func PostDecBitFieldPtr8Int8 

func PostDecBitFieldPtr8Int8(p uintptr, d int8, w, off int, mask uint8) (r int8)

func PostDecBitFieldPtr8Uint16 

func PostDecBitFieldPtr8Uint16(p uintptr, d uint16, w, off int, mask uint8) (r uint16)

func PostDecBitFieldPtr8Uint32 

func PostDecBitFieldPtr8Uint32(p uintptr, d uint32, w, off int, mask uint8) (r uint32)

func PostDecBitFieldPtr8Uint64 

func PostDecBitFieldPtr8Uint64(p uintptr, d uint64, w, off int, mask uint8) (r uint64)

func PostDecBitFieldPtr8Uint8 

func PostDecBitFieldPtr8Uint8(p uintptr, d uint8, w, off int, mask uint8) (r uint8)

func PostDecComplex128 

func PostDecComplex128(p *complex128, d complex128) complex128

func PostDecComplex64 

func PostDecComplex64(p *complex64, d complex64) complex64

func PostDecFloat32 

func PostDecFloat32(p *float32, d float32) float32

func PostDecFloat64 

func PostDecFloat64(p *float64, d float64) float64

func PostDecInt16 

func PostDecInt16(p *int16, d int16) int16

func PostDecInt32 

func PostDecInt32(p *int32, d int32) int32

func PostDecInt64 

func PostDecInt64(p *int64, d int64) int64

func PostDecInt8 

func PostDecInt8(p *int8, d int8) int8

func PostDecUint16 

func PostDecUint16(p *uint16, d uint16) uint16

func PostDecUint32 

func PostDecUint32(p *uint32, d uint32) uint32

func PostDecUint64 

func PostDecUint64(p *uint64, d uint64) uint64

func PostDecUint8 

func PostDecUint8(p *uint8, d uint8) uint8

func PostDecUintptr 

func PostDecUintptr(p *uintptr, d uintptr) uintptr

func PostIncAtomicInt32 

func PostIncAtomicInt32(p *int32, d int32) int32

func PostIncAtomicInt64 

func PostIncAtomicInt64(p *int64, d int64) int64

func PostIncAtomicUint32 

func PostIncAtomicUint32(p *uint32, d uint32) uint32

func PostIncAtomicUint64 

func PostIncAtomicUint64(p *uint64, d uint64) uint64

func PostIncAtomicUintptr 

func PostIncAtomicUintptr(p *uintptr, d uintptr) uintptr

func PostIncBitFieldPtr16Int16 

func PostIncBitFieldPtr16Int16(p uintptr, d int16, w, off int, mask uint16) (r int16)

func PostIncBitFieldPtr16Int32 

func PostIncBitFieldPtr16Int32(p uintptr, d int32, w, off int, mask uint16) (r int32)

func PostIncBitFieldPtr16Int64 

func PostIncBitFieldPtr16Int64(p uintptr, d int64, w, off int, mask uint16) (r int64)

func PostIncBitFieldPtr16Int8 

func PostIncBitFieldPtr16Int8(p uintptr, d int8, w, off int, mask uint16) (r int8)

func PostIncBitFieldPtr16Uint16 

func PostIncBitFieldPtr16Uint16(p uintptr, d uint16, w, off int, mask uint16) (r uint16)

func PostIncBitFieldPtr16Uint32 

func PostIncBitFieldPtr16Uint32(p uintptr, d uint32, w, off int, mask uint16) (r uint32)

func PostIncBitFieldPtr16Uint64 

func PostIncBitFieldPtr16Uint64(p uintptr, d uint64, w, off int, mask uint16) (r uint64)

func PostIncBitFieldPtr16Uint8 

func PostIncBitFieldPtr16Uint8(p uintptr, d uint8, w, off int, mask uint16) (r uint8)

func PostIncBitFieldPtr32Int16 

func PostIncBitFieldPtr32Int16(p uintptr, d int16, w, off int, mask uint32) (r int16)

func PostIncBitFieldPtr32Int32 

func PostIncBitFieldPtr32Int32(p uintptr, d int32, w, off int, mask uint32) (r int32)

func PostIncBitFieldPtr32Int64 

func PostIncBitFieldPtr32Int64(p uintptr, d int64, w, off int, mask uint32) (r int64)

func PostIncBitFieldPtr32Int8 

func PostIncBitFieldPtr32Int8(p uintptr, d int8, w, off int, mask uint32) (r int8)

func PostIncBitFieldPtr32Uint16 

func PostIncBitFieldPtr32Uint16(p uintptr, d uint16, w, off int, mask uint32) (r uint16)

func PostIncBitFieldPtr32Uint32 

func PostIncBitFieldPtr32Uint32(p uintptr, d uint32, w, off int, mask uint32) (r uint32)

func PostIncBitFieldPtr32Uint64 

func PostIncBitFieldPtr32Uint64(p uintptr, d uint64, w, off int, mask uint32) (r uint64)

func PostIncBitFieldPtr32Uint8 

func PostIncBitFieldPtr32Uint8(p uintptr, d uint8, w, off int, mask uint32) (r uint8)

func PostIncBitFieldPtr64Int16 

func PostIncBitFieldPtr64Int16(p uintptr, d int16, w, off int, mask uint64) (r int16)

func PostIncBitFieldPtr64Int32 

func PostIncBitFieldPtr64Int32(p uintptr, d int32, w, off int, mask uint64) (r int32)

func PostIncBitFieldPtr64Int64 

func PostIncBitFieldPtr64Int64(p uintptr, d int64, w, off int, mask uint64) (r int64)

func PostIncBitFieldPtr64Int8 

func PostIncBitFieldPtr64Int8(p uintptr, d int8, w, off int, mask uint64) (r int8)

func PostIncBitFieldPtr64Uint16 

func PostIncBitFieldPtr64Uint16(p uintptr, d uint16, w, off int, mask uint64) (r uint16)

func PostIncBitFieldPtr64Uint32 

func PostIncBitFieldPtr64Uint32(p uintptr, d uint32, w, off int, mask uint64) (r uint32)

func PostIncBitFieldPtr64Uint64 

func PostIncBitFieldPtr64Uint64(p uintptr, d uint64, w, off int, mask uint64) (r uint64)

func PostIncBitFieldPtr64Uint8 

func PostIncBitFieldPtr64Uint8(p uintptr, d uint8, w, off int, mask uint64) (r uint8)

func PostIncBitFieldPtr8Int16 

func PostIncBitFieldPtr8Int16(p uintptr, d int16, w, off int, mask uint8) (r int16)

func PostIncBitFieldPtr8Int32 

func PostIncBitFieldPtr8Int32(p uintptr, d int32, w, off int, mask uint8) (r int32)

func PostIncBitFieldPtr8Int64 

func PostIncBitFieldPtr8Int64(p uintptr, d int64, w, off int, mask uint8) (r int64)

func PostIncBitFieldPtr8Int8 

func PostIncBitFieldPtr8Int8(p uintptr, d int8, w, off int, mask uint8) (r int8)

func PostIncBitFieldPtr8Uint16 

func PostIncBitFieldPtr8Uint16(p uintptr, d uint16, w, off int, mask uint8) (r uint16)

func PostIncBitFieldPtr8Uint32 

func PostIncBitFieldPtr8Uint32(p uintptr, d uint32, w, off int, mask uint8) (r uint32)

func PostIncBitFieldPtr8Uint64 

func PostIncBitFieldPtr8Uint64(p uintptr, d uint64, w, off int, mask uint8) (r uint64)

func PostIncBitFieldPtr8Uint8 

func PostIncBitFieldPtr8Uint8(p uintptr, d uint8, w, off int, mask uint8) (r uint8)

func PostIncComplex128 

func PostIncComplex128(p *complex128, d complex128) complex128

func PostIncComplex64 

func PostIncComplex64(p *complex64, d complex64) complex64

func PostIncFloat32 

func PostIncFloat32(p *float32, d float32) float32

func PostIncFloat64 

func PostIncFloat64(p *float64, d float64) float64

func PostIncInt16 

func PostIncInt16(p *int16, d int16) int16

func PostIncInt32 

func PostIncInt32(p *int32, d int32) int32

func PostIncInt64 

func PostIncInt64(p *int64, d int64) int64

func PostIncInt8 

func PostIncInt8(p *int8, d int8) int8

func PostIncUint16 

func PostIncUint16(p *uint16, d uint16) uint16

func PostIncUint32 

func PostIncUint32(p *uint32, d uint32) uint32

func PostIncUint64 

func PostIncUint64(p *uint64, d uint64) uint64

func PostIncUint8 

func PostIncUint8(p *uint8, d uint8) uint8

func PostIncUintptr 

func PostIncUintptr(p *uintptr, d uintptr) uintptr

func PreDecAtomicInt32 

func PreDecAtomicInt32(p *int32, d int32) int32

func PreDecAtomicInt64 

func PreDecAtomicInt64(p *int64, d int64) int64

func PreDecAtomicUint32 

func PreDecAtomicUint32(p *uint32, d uint32) uint32

func PreDecAtomicUint64 

func PreDecAtomicUint64(p *uint64, d uint64) uint64

func PreDecAtomicUintptr 

func PreDecAtomicUintptr(p *uintptr, d uintptr) uintptr

func PreDecComplex128 

func PreDecComplex128(p *complex128, d complex128) complex128

func PreDecComplex64 

func PreDecComplex64(p *complex64, d complex64) complex64

func PreDecFloat32 

func PreDecFloat32(p *float32, d float32) float32

func PreDecFloat64 

func PreDecFloat64(p *float64, d float64) float64

func PreDecInt16 

func PreDecInt16(p *int16, d int16) int16

func PreDecInt32 

func PreDecInt32(p *int32, d int32) int32

func PreDecInt64 

func PreDecInt64(p *int64, d int64) int64

func PreDecInt8 

func PreDecInt8(p *int8, d int8) int8

func PreDecUint16 

func PreDecUint16(p *uint16, d uint16) uint16

func PreDecUint32 

func PreDecUint32(p *uint32, d uint32) uint32

func PreDecUint64 

func PreDecUint64(p *uint64, d uint64) uint64

func PreDecUint8 

func PreDecUint8(p *uint8, d uint8) uint8

func PreDecUintptr 

func PreDecUintptr(p *uintptr, d uintptr) uintptr

func PreIncAtomicInt32 

func PreIncAtomicInt32(p *int32, d int32) int32

func PreIncAtomicInt64 

func PreIncAtomicInt64(p *int64, d int64) int64

func PreIncAtomicUint32 

func PreIncAtomicUint32(p *uint32, d uint32) uint32

func PreIncAtomicUint64 

func PreIncAtomicUint64(p *uint64, d uint64) uint64

func PreIncAtomicUintptr 

func PreIncAtomicUintptr(p *uintptr, d uintptr) uintptr

func PreIncComplex128 

func PreIncComplex128(p *complex128, d complex128) complex128

func PreIncComplex64 

func PreIncComplex64(p *complex64, d complex64) complex64

func PreIncFloat32 

func PreIncFloat32(p *float32, d float32) float32

func PreIncFloat64 

func PreIncFloat64(p *float64, d float64) float64

func PreIncInt16 

func PreIncInt16(p *int16, d int16) int16

func PreIncInt32 

func PreIncInt32(p *int32, d int32) int32

func PreIncInt64 

func PreIncInt64(p *int64, d int64) int64

func PreIncInt8 

func PreIncInt8(p *int8, d int8) int8

func PreIncUint16 

func PreIncUint16(p *uint16, d uint16) uint16

func PreIncUint32 

func PreIncUint32(p *uint32, d uint32) uint32

func PreIncUint64 

func PreIncUint64(p *uint64, d uint64) uint64

func PreIncUint8 

func PreIncUint8(p *uint8, d uint8) uint8

func PreIncUintptr 

func PreIncUintptr(p *uintptr, d uintptr) uintptr

func SetBitFieldPtr16Int16 

func SetBitFieldPtr16Int16(p uintptr, v int16, off int, mask uint16)

func SetBitFieldPtr16Int32 

func SetBitFieldPtr16Int32(p uintptr, v int32, off int, mask uint16)

func SetBitFieldPtr16Int64 

func SetBitFieldPtr16Int64(p uintptr, v int64, off int, mask uint16)

func SetBitFieldPtr16Int8 

func SetBitFieldPtr16Int8(p uintptr, v int8, off int, mask uint16)

func SetBitFieldPtr16Uint16 

func SetBitFieldPtr16Uint16(p uintptr, v uint16, off int, mask uint16)

func SetBitFieldPtr16Uint32 

func SetBitFieldPtr16Uint32(p uintptr, v uint32, off int, mask uint16)

func SetBitFieldPtr16Uint64 

func SetBitFieldPtr16Uint64(p uintptr, v uint64, off int, mask uint16)

func SetBitFieldPtr16Uint8 

func SetBitFieldPtr16Uint8(p uintptr, v uint8, off int, mask uint16)

func SetBitFieldPtr32Int16 

func SetBitFieldPtr32Int16(p uintptr, v int16, off int, mask uint32)

func SetBitFieldPtr32Int32 

func SetBitFieldPtr32Int32(p uintptr, v int32, off int, mask uint32)

func SetBitFieldPtr32Int64 

func SetBitFieldPtr32Int64(p uintptr, v int64, off int, mask uint32)

func SetBitFieldPtr32Int8 

func SetBitFieldPtr32Int8(p uintptr, v int8, off int, mask uint32)

func SetBitFieldPtr32Uint16 

func SetBitFieldPtr32Uint16(p uintptr, v uint16, off int, mask uint32)

func SetBitFieldPtr32Uint32 

func SetBitFieldPtr32Uint32(p uintptr, v uint32, off int, mask uint32)

func SetBitFieldPtr32Uint64 

func SetBitFieldPtr32Uint64(p uintptr, v uint64, off int, mask uint32)

func SetBitFieldPtr32Uint8 

func SetBitFieldPtr32Uint8(p uintptr, v uint8, off int, mask uint32)

func SetBitFieldPtr64Int16 

func SetBitFieldPtr64Int16(p uintptr, v int16, off int, mask uint64)

func SetBitFieldPtr64Int32 

func SetBitFieldPtr64Int32(p uintptr, v int32, off int, mask uint64)

func SetBitFieldPtr64Int64 

func SetBitFieldPtr64Int64(p uintptr, v int64, off int, mask uint64)

func SetBitFieldPtr64Int8 

func SetBitFieldPtr64Int8(p uintptr, v int8, off int, mask uint64)

func SetBitFieldPtr64Uint16 

func SetBitFieldPtr64Uint16(p uintptr, v uint16, off int, mask uint64)

func SetBitFieldPtr64Uint32 

func SetBitFieldPtr64Uint32(p uintptr, v uint32, off int, mask uint64)

func SetBitFieldPtr64Uint64 

func SetBitFieldPtr64Uint64(p uintptr, v uint64, off int, mask uint64)

func SetBitFieldPtr64Uint8 

func SetBitFieldPtr64Uint8(p uintptr, v uint8, off int, mask uint64)

func SetBitFieldPtr8Int16 

func SetBitFieldPtr8Int16(p uintptr, v int16, off int, mask uint8)

func SetBitFieldPtr8Int32 

func SetBitFieldPtr8Int32(p uintptr, v int32, off int, mask uint8)

func SetBitFieldPtr8Int64 

func SetBitFieldPtr8Int64(p uintptr, v int64, off int, mask uint8)

func SetBitFieldPtr8Int8 

func SetBitFieldPtr8Int8(p uintptr, v int8, off int, mask uint8)

func SetBitFieldPtr8Uint16 

func SetBitFieldPtr8Uint16(p uintptr, v uint16, off int, mask uint8)

func SetBitFieldPtr8Uint32 

func SetBitFieldPtr8Uint32(p uintptr, v uint32, off int, mask uint8)

func SetBitFieldPtr8Uint64 

func SetBitFieldPtr8Uint64(p uintptr, v uint64, off int, mask uint8)

func SetBitFieldPtr8Uint8 

func SetBitFieldPtr8Uint8(p uintptr, v uint8, off int, mask uint8)

func SetEnviron 

func SetEnviron(t *TLS, env []string)

func Start 

func Start(main func(*TLS, int32, uintptr) int32)

func ThreadProc 

func ThreadProc(p uintptr) uintptr

func Uint16 

func Uint16(n uint16) uint16

func Uint16FromComplex128 

func Uint16FromComplex128(n complex128) uint16

func Uint16FromComplex64 

func Uint16FromComplex64(n complex64) uint16

func Uint16FromFloat32 

func Uint16FromFloat32(n float32) uint16

func Uint16FromFloat64 

func Uint16FromFloat64(n float64) uint16

func Uint16FromInt16 

func Uint16FromInt16(n int16) uint16

func Uint16FromInt32 

func Uint16FromInt32(n int32) uint16

func Uint16FromInt64 

func Uint16FromInt64(n int64) uint16

func Uint16FromInt8 

func Uint16FromInt8(n int8) uint16

func Uint16FromUint16 

func Uint16FromUint16(n uint16) uint16

func Uint16FromUint32 

func Uint16FromUint32(n uint32) uint16

func Uint16FromUint64 

func Uint16FromUint64(n uint64) uint16

func Uint16FromUint8 

func Uint16FromUint8(n uint8) uint16

func Uint16FromUintptr 

func Uint16FromUintptr(n uintptr) uint16

func Uint32 

func Uint32(n uint32) uint32

func Uint32FromComplex128 

func Uint32FromComplex128(n complex128) uint32

func Uint32FromComplex64 

func Uint32FromComplex64(n complex64) uint32

func Uint32FromFloat32 

func Uint32FromFloat32(n float32) uint32

func Uint32FromFloat64 

func Uint32FromFloat64(n float64) uint32

func Uint32FromInt16 

func Uint32FromInt16(n int16) uint32

func Uint32FromInt32 

func Uint32FromInt32(n int32) uint32

func Uint32FromInt64 

func Uint32FromInt64(n int64) uint32

func Uint32FromInt8 

func Uint32FromInt8(n int8) uint32

func Uint32FromUint16 

func Uint32FromUint16(n uint16) uint32

func Uint32FromUint32 

func Uint32FromUint32(n uint32) uint32

func Uint32FromUint64 

func Uint32FromUint64(n uint64) uint32

func Uint32FromUint8 

func Uint32FromUint8(n uint8) uint32

func Uint32FromUintptr 

func Uint32FromUintptr(n uintptr) uint32

func Uint64 

func Uint64(n uint64) uint64

func Uint64FromComplex128 

func Uint64FromComplex128(n complex128) uint64

func Uint64FromComplex64 

func Uint64FromComplex64(n complex64) uint64

func Uint64FromFloat32 

func Uint64FromFloat32(n float32) uint64

func Uint64FromFloat64 

func Uint64FromFloat64(n float64) uint64

func Uint64FromInt16 

func Uint64FromInt16(n int16) uint64

func Uint64FromInt32 

func Uint64FromInt32(n int32) uint64

func Uint64FromInt64 

func Uint64FromInt64(n int64) uint64

func Uint64FromInt8 

func Uint64FromInt8(n int8) uint64

func Uint64FromUint16 

func Uint64FromUint16(n uint16) uint64

func Uint64FromUint32 

func Uint64FromUint32(n uint32) uint64

func Uint64FromUint64 

func Uint64FromUint64(n uint64) uint64

func Uint64FromUint8 

func Uint64FromUint8(n uint8) uint64

func Uint64FromUintptr 

func Uint64FromUintptr(n uintptr) uint64

func Uint8 

func Uint8(n uint8) uint8

func Uint8FromComplex128 

func Uint8FromComplex128(n complex128) uint8

func Uint8FromComplex64 

func Uint8FromComplex64(n complex64) uint8

func Uint8FromFloat32 

func Uint8FromFloat32(n float32) uint8

func Uint8FromFloat64 

func Uint8FromFloat64(n float64) uint8

func Uint8FromInt16 

func Uint8FromInt16(n int16) uint8

func Uint8FromInt32 

func Uint8FromInt32(n int32) uint8

func Uint8FromInt64 

func Uint8FromInt64(n int64) uint8

func Uint8FromInt8 

func Uint8FromInt8(n int8) uint8

func Uint8FromUint16 

func Uint8FromUint16(n uint16) uint8

func Uint8FromUint32 

func Uint8FromUint32(n uint32) uint8

func Uint8FromUint64 

func Uint8FromUint64(n uint64) uint8

func Uint8FromUint8 

func Uint8FromUint8(n uint8) uint8

func Uint8FromUintptr 

func Uint8FromUintptr(n uintptr) uint8

func Uintptr 

func Uintptr(n uintptr) uintptr

func UintptrFromComplex128 

func UintptrFromComplex128(n complex128) uintptr

func UintptrFromComplex64 

func UintptrFromComplex64(n complex64) uintptr

func UintptrFromFloat32 

func UintptrFromFloat32(n float32) uintptr

func UintptrFromFloat64 

func UintptrFromFloat64(n float64) uintptr

func UintptrFromInt16 

func UintptrFromInt16(n int16) uintptr

func UintptrFromInt32 

func UintptrFromInt32(n int32) uintptr

func UintptrFromInt64 

func UintptrFromInt64(n int64) uintptr

func UintptrFromInt8 

func UintptrFromInt8(n int8) uintptr

func UintptrFromUint16 

func UintptrFromUint16(n uint16) uintptr

func UintptrFromUint32 

func UintptrFromUint32(n uint32) uintptr

func UintptrFromUint64 

func UintptrFromUint64(n uint64) uintptr

func UintptrFromUint8 

func UintptrFromUint8(n uint8) uintptr

func UintptrFromUintptr 

func UintptrFromUintptr(n uintptr) uintptr

func UsableSize 

func UsableSize(p uintptr) types.Size_t

func VaFloat32 

func VaFloat32(app *uintptr) float32

func VaFloat64 

func VaFloat64(app *uintptr) float64

func VaInt32 

func VaInt32(app *uintptr) int32

func VaInt64 

func VaInt64(app *uintptr) int64

func VaList 

func VaList(p uintptr, args ...interface{}) (r uintptr)

VaList fills a varargs list at p with args and returns p. The list must have been allocated by caller and it must not be in Go managed memory, ie. it must be pinned. Caller is responsible for freeing the list.

Individual arguments must be one of int, uint, int32, uint32, int64, uint64, float64, uintptr or Intptr. Other types will panic.

This function supports code generated by ccgo/v3. For manually constructed var args it's recommended to use the NewVaList function instead.

Note: The C translated to Go varargs ABI alignment for all types is 8 on all architectures.

func VaUint32 

func VaUint32(app *uintptr) uint32

func VaUint64 

func VaUint64(app *uintptr) uint64

func VaUintptr 

func VaUintptr(app *uintptr) uintptr

func Watch 

func Watch()

func WatchDelete 

func WatchDelete(p uintptr)

func WatchFloat32 

func WatchFloat32(p uintptr, msg string)

func WatchFloat64 

func WatchFloat64(p uintptr, msg string)

func WatchInt16 

func WatchInt16(p uintptr, msg string)

func WatchInt32 

func WatchInt32(p uintptr, msg string)

func WatchInt64 

func WatchInt64(p uintptr, msg string)

func WatchInt8 

func WatchInt8(p uintptr, msg string)

func WatchPtr 

func WatchPtr(p uintptr, msg string)

func WatchUint16 

func WatchUint16(p uintptr, msg string)

func WatchUint32 

func WatchUint32(p uintptr, msg string)

func WatchUint64 

func WatchUint64(p uintptr, msg string)

func WatchUint8 

func WatchUint8(p uintptr, msg string)

func WindowsAttrbiutesToStat 

func WindowsAttrbiutesToStat(fa uint32) uint16

func WindowsTickToUnixSeconds 

func WindowsTickToUnixSeconds(windowsTicks int64) int64

func XAccessCheck 

func XAccessCheck(t *TLS, pSecurityDescriptor, ClientToken uintptr, DesiredAccess uint32, GenericMapping, PrivilegeSet, PrivilegeSetLength, GrantedAccess, AccessStatus uintptr) int32

BOOL AccessCheck( 

PSECURITY_DESCRIPTOR pSecurityDescriptor,
HANDLE               ClientToken,
DWORD                DesiredAccess,
PGENERIC_MAPPING     GenericMapping,
PPRIVILEGE_SET       PrivilegeSet,
LPDWORD              PrivilegeSetLength,
LPDWORD              GrantedAccess,
LPBOOL               AccessStatus

);

func XAddAccessDeniedAce 

func XAddAccessDeniedAce(t *TLS, pAcl uintptr, dwAceRevision, AccessMask uint32, pSid uintptr) int32

BOOL AddAccessDeniedAce( 

PACL  pAcl,
DWORD dwAceRevision,
DWORD AccessMask,
PSID  pSid

);

func XAddAce 

func XAddAce(t *TLS, pAcl uintptr, dwAceRevision, dwStartingAceIndex uint32, pAceList uintptr, nAceListLength uint32) int32

BOOL AddAce( 

PACL   pAcl,
DWORD  dwAceRevision,
DWORD  dwStartingAceIndex,
LPVOID pAceList,
DWORD  nAceListLength

);

func XAreFileApisANSI 

func XAreFileApisANSI(t *TLS) int32

BOOL AreFileApisANSI();

func XBuildCommDCBW 

func XBuildCommDCBW(t *TLS, _ ...interface{}) int32

func XCancelSynchronousIo 

func XCancelSynchronousIo(t *TLS, hThread uintptr) int32

BOOL WINAPI CancelSynchronousIo( 

_In_ HANDLE hThread

);

func XCharLowerW 

func XCharLowerW(t *TLS, lpsz uintptr) uintptr

LPWSTR CharLowerW( 

LPWSTR lpsz

);

func XClearCommError 

func XClearCommError(t *TLS, _ ...interface{}) int32

func XCloseHandle 

func XCloseHandle(t *TLS, hObject uintptr) int32

BOOL CloseHandle( 

HANDLE hObject

);

func XCopyFileW 

func XCopyFileW(t *TLS, lpExistingFileName, lpNewFileName uintptr, bFailIfExists int32) int32

BOOL CopyFileW( 

LPCWSTR lpExistingFileName,
LPCWSTR lpNewFileName,
BOOL    bFailIfExists

);

func XCreateDirectoryW 

func XCreateDirectoryW(t *TLS, lpPathName, lpSecurityAttributes uintptr) int32

BOOL CreateDirectoryW( 

LPCWSTR                lpPathName,
LPSECURITY_ATTRIBUTES lpSecurityAttributes

);

func XCreateEventA 

func XCreateEventA(t *TLS, lpEventAttributes uintptr, bManualReset, bInitialState int32, lpName uintptr) uintptr

HANDLE CreateEventA( 

LPSECURITY_ATTRIBUTES lpEventAttributes,
BOOL                  bManualReset,
BOOL                  bInitialState,
LPCSTR                lpName

);

func XCreateEventW 

func XCreateEventW(t *TLS, lpEventAttributes uintptr, bManualReset, bInitialState int32, lpName uintptr) uintptr

HANDLE CreateEventW( 

LPSECURITY_ATTRIBUTES lpEventAttributes,
BOOL                  bManualReset,
BOOL                  bInitialState,
LPCWSTR               lpName

);

func XCreateFileA 

func XCreateFileA(t *TLS, lpFileName uintptr, dwDesiredAccess, dwShareMode uint32,
	lpSecurityAttributes uintptr, dwCreationDisposition, dwFlagsAndAttributes uint32, hTemplateFile uintptr) uintptr

HANDLE CreateFileA( 

LPCSTR                lpFileName,
DWORD                 dwDesiredAccess,
DWORD                 dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD                 dwCreationDisposition,
DWORD                 dwFlagsAndAttributes,
HANDLE                hTemplateFile

);

func XCreateFileMappingA 

func XCreateFileMappingA(t *TLS, hFile, lpFileMappingAttributes uintptr, flProtect, dwMaximumSizeHigh, dwMaximumSizeLow uint32, lpName uintptr) uintptr

HANDLE CreateFileMappingA( 

HANDLE                hFile,
LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
DWORD                 flProtect,
DWORD                 dwMaximumSizeHigh,
DWORD                 dwMaximumSizeLow,
LPCSTR                lpName

);

func XCreateFileMappingW 

func XCreateFileMappingW(t *TLS, hFile, lpFileMappingAttributes uintptr, flProtect, dwMaximumSizeHigh, dwMaximumSizeLow uint32, lpName uintptr) uintptr

HANDLE CreateFileMappingW( 

HANDLE                hFile,
LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
DWORD                 flProtect,
DWORD                 dwMaximumSizeHigh,
DWORD                 dwMaximumSizeLow,
LPCWSTR               lpName

);

func XCreateFileW 

func XCreateFileW(t *TLS, lpFileName uintptr, dwDesiredAccess, dwShareMode uint32, lpSecurityAttributes uintptr, dwCreationDisposition, dwFlagsAndAttributes uint32, hTemplateFile uintptr) uintptr

HANDLE CreateFileW( 

LPCWSTR               lpFileName,
DWORD                 dwDesiredAccess,
DWORD                 dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD                 dwCreationDisposition,
DWORD                 dwFlagsAndAttributes,
HANDLE                hTemplateFile

);

func XCreateHardLinkW 

func XCreateHardLinkW(t *TLS, lpFileName, lpExistingFileName, lpSecurityAttributes uintptr) int32

BOOL CreateHardLinkW( 

LPCWSTR               lpFileName,
LPCWSTR               lpExistingFileName,
LPSECURITY_ATTRIBUTES lpSecurityAttributes

);

func XCreateMutexW 

func XCreateMutexW(t *TLS, lpMutexAttributes uintptr, bInitialOwner int32, lpName uintptr) uintptr

HANDLE CreateMutexW( 

LPSECURITY_ATTRIBUTES lpMutexAttributes,
BOOL                  bInitialOwner,
LPCWSTR               lpName

);

func XCreatePipe 

func XCreatePipe(t *TLS, hReadPipe, hWritePipe, lpPipeAttributes uintptr, nSize uint32) int32

BOOL CreatePipe( 

PHANDLE               hReadPipe,
PHANDLE               hWritePipe,
LPSECURITY_ATTRIBUTES lpPipeAttributes,
DWORD                 nSize

);

func XCreateProcessA 

func XCreateProcessA(t *TLS, lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes uintptr, bInheritHandles int32,
	dwCreationFlags uint32, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation uintptr) int32

BOOL CreateProcessA( 

LPCSTR                lpApplicationName,
LPSTR                 lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL                  bInheritHandles,
DWORD                 dwCreationFlags,
LPVOID                lpEnvironment,
LPCSTR                lpCurrentDirectory,
LPSTARTUPINFOA        lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation

);

func XCreateProcessW 

func XCreateProcessW(t *TLS, lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes uintptr, bInheritHandles int32, dwCreationFlags uint32,
	lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation uintptr) int32

BOOL CreateProcessW( 

LPCWSTR               lpApplicationName,
LPWSTR                lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL                  bInheritHandles,
DWORD                 dwCreationFlags,
LPVOID                lpEnvironment,
LPCWSTR               lpCurrentDirectory,
LPSTARTUPINFOW        lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation

);

func XCreateThread 

func XCreateThread(t *TLS, lpThreadAttributes uintptr, dwStackSize types.Size_t, lpStartAddress, lpParameter uintptr, dwCreationFlags uint32, lpThreadId uintptr) uintptr

HANDLE CreateThread( 

LPSECURITY_ATTRIBUTES   lpThreadAttributes,
SIZE_T                  dwStackSize,
LPTHREAD_START_ROUTINE  lpStartAddress,
__drv_aliasesMem LPVOID lpParameter,
DWORD                   dwCreationFlags,
LPDWORD                 lpThreadId

);

func XCreateWindowExW 

func XCreateWindowExW(t *TLS, dwExStyle uint32, lpClassName, lpWindowName uintptr, dwStyle uint32, x, y, nWidth, nHeight int32, hWndParent, hMenu, hInstance, lpParam uintptr) uintptr

HWND CreateWindowExW( 

DWORD     dwExStyle,
LPCWSTR   lpClassName,
LPCWSTR   lpWindowName,
DWORD     dwStyle,
int       X,
int       Y,
int       nWidth,
int       nHeight,
HWND      hWndParent,
HMENU     hMenu,
HINSTANCE hInstance,
LPVOID    lpParam

);

func XDdeAbandonTransaction 

func XDdeAbandonTransaction(t *TLS, _ ...interface{}) int32

func XDdeAccessData 

func XDdeAccessData(t *TLS, _ ...interface{}) uintptr

func XDdeClientTransaction 

func XDdeClientTransaction(t *TLS, pData uintptr, cbData uint32, hConv uintptr, hszItem uintptr, wFmt, wType, dwTimeout uint32, pdwResult uintptr) uintptr

HDDEDATA DdeClientTransaction( 

LPBYTE  pData,
DWORD   cbData,
HCONV   hConv,
HSZ     hszItem,
UINT    wFmt,
UINT    wType,
DWORD   dwTimeout,
LPDWORD pdwResult

);

func XDdeConnect 

func XDdeConnect(t *TLS, _ ...interface{}) uintptr

func XDdeCreateDataHandle 

func XDdeCreateDataHandle(t *TLS, _ ...interface{}) uintptr

func XDdeCreateStringHandleW 

func XDdeCreateStringHandleW(t *TLS, _ ...interface{}) uintptr

func XDdeDisconnect 

func XDdeDisconnect(t *TLS, _ ...interface{}) int32

func XDdeFreeDataHandle 

func XDdeFreeDataHandle(t *TLS, _ ...interface{}) int32

func XDdeFreeStringHandle 

func XDdeFreeStringHandle(t *TLS, _ ...interface{}) int32

func XDdeGetData 

func XDdeGetData(t *TLS, _ ...interface{}) int32

func XDdeGetLastError 

func XDdeGetLastError(t *TLS, _ ...interface{}) uint32

func XDdeInitializeW 

func XDdeInitializeW(t *TLS, _ ...interface{}) uint32

func XDdeNameService 

func XDdeNameService(t *TLS, _ ...interface{}) int32

func XDdeQueryStringW 

func XDdeQueryStringW(t *TLS, _ ...interface{}) int32

func XDdeUnaccessData 

func XDdeUnaccessData(t *TLS, _ ...interface{}) int32

func XDdeUninitialize 

func XDdeUninitialize(t *TLS, _ ...interface{}) int32

func XDebugBreak 

func XDebugBreak(t *TLS)

DebugBreak

func XDefWindowProcW 

func XDefWindowProcW(t *TLS, _ ...interface{}) int64

LRESULT LRESULT DefWindowProcW( 

HWND   hWnd,
UINT   Msg,
WPARAM wParam,
LPARAM lParam

);

func XDeleteCriticalSection 

func XDeleteCriticalSection(t *TLS, lpCriticalSection uintptr)

void DeleteCriticalSection( 

LPCRITICAL_SECTION lpCriticalSection

);

func XDeleteFileA 

func XDeleteFileA(t *TLS, lpFileName uintptr) int32

BOOL DeleteFileA( 

LPCSTR lpFileName

);

func XDeleteFileW 

func XDeleteFileW(t *TLS, lpFileName uintptr) int32

BOOL DeleteFileW( 

LPCWSTR lpFileName

);

func XDestroyWindow 

func XDestroyWindow(t *TLS, _ ...interface{}) int32

func XDeviceIoControl 

func XDeviceIoControl(t *TLS, hDevice uintptr, dwIoControlCode uint32, lpInBuffer uintptr, nInBufferSize uint32, lpOutBuffer uintptr, nOutBufferSize uint32, lpBytesReturned, lpOverlapped uintptr) int32

BOOL DeviceIoControl( 

HANDLE       hDevice,
DWORD        dwIoControlCode,
LPVOID       lpInBuffer,
DWORD        nInBufferSize,
LPVOID       lpOutBuffer,
DWORD        nOutBufferSize,
LPDWORD      lpBytesReturned,
LPOVERLAPPED lpOverlapped

);

func XDispatchMessageW 

func XDispatchMessageW(t *TLS, _ ...interface{}) int32

func XDuplicateHandle 

func XDuplicateHandle(t *TLS, hSourceProcessHandle, hSourceHandle, hTargetProcessHandle, lpTargetHandle uintptr, dwDesiredAccess uint32, bInheritHandle int32, dwOptions uint32) int32

BOOL DuplicateHandle( 

HANDLE   hSourceProcessHandle,
HANDLE   hSourceHandle,
HANDLE   hTargetProcessHandle,
LPHANDLE lpTargetHandle,
DWORD    dwDesiredAccess,
BOOL     bInheritHandle,
DWORD    dwOptions

);

func XEnterCriticalSection 

func XEnterCriticalSection(t *TLS, lpCriticalSection uintptr)

void EnterCriticalSection( 

LPCRITICAL_SECTION lpCriticalSection

);

func XEnumWindows 

func XEnumWindows(t *TLS, _ ...interface{}) int32

func XEqualSid 

func XEqualSid(t *TLS, pSid1, pSid2 uintptr) int32

BOOL EqualSid( 

PSID pSid1,
PSID pSid2

);

func XEscapeCommFunction 

func XEscapeCommFunction(t *TLS, _ ...interface{}) int32

func XExitProcess 

func XExitProcess(t *TLS, _ ...interface{}) int32

func XFindClose 

func XFindClose(t *TLS, hFindFile uintptr) int32

BOOL FindClose(HANDLE hFindFile);

func XFindFirstFileExW 

func XFindFirstFileExW(t *TLS, lpFileName uintptr, fInfoLevelId int32, lpFindFileData uintptr, fSearchOp int32, lpSearchFilter uintptr, dwAdditionalFlags uint32) uintptr

HANDLE FindFirstFileExW( 

LPCWSTR            lpFileName,
FINDEX_INFO_LEVELS fInfoLevelId,
LPVOID             lpFindFileData,
FINDEX_SEARCH_OPS  fSearchOp,
LPVOID             lpSearchFilter,
DWORD              dwAdditionalFlags

);

func XFindFirstFileW 

func XFindFirstFileW(t *TLS, lpFileName, lpFindFileData uintptr) uintptr

HANDLE FindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData);

func XFindNextFileW 

func XFindNextFileW(t *TLS, hFindFile, lpFindFileData uintptr) int32

BOOL FindNextFileW( 

HANDLE             hFindFile,
LPWIN32_FIND_DATAW lpFindFileData

);

func XFlushFileBuffers 

func XFlushFileBuffers(t *TLS, hFile uintptr) int32

BOOL FlushFileBuffers( 

HANDLE hFile

);

func XFlushViewOfFile 

func XFlushViewOfFile(t *TLS, lpBaseAddress uintptr, dwNumberOfBytesToFlush types.Size_t) int32

BOOL FlushViewOfFile( 

LPCVOID lpBaseAddress,
SIZE_T  dwNumberOfBytesToFlush

);

func XFormatMessageA 

func XFormatMessageA(t *TLS, dwFlagsAndAttributes uint32, lpSource uintptr, dwMessageId, dwLanguageId uint32, lpBuffer uintptr, nSize uint32, Arguments uintptr) uint32

DWORD FormatMessageA( 

DWORD   dwFlags,
LPCVOID lpSource,
DWORD   dwMessageId,
DWORD   dwLanguageId,
LPSTR   lpBuffer,
DWORD   nSize,
va_list *Arguments

);

func XFormatMessageW 

func XFormatMessageW(t *TLS, dwFlags uint32, lpSource uintptr, dwMessageId, dwLanguageId uint32, lpBuffer uintptr, nSize uint32, Arguments uintptr) uint32

DWORD FormatMessageW( 

DWORD   dwFlags,
LPCVOID lpSource,
DWORD   dwMessageId,
DWORD   dwLanguageId,
LPWSTR  lpBuffer,
DWORD   nSize,
va_list *Arguments

);

func XFreeLibrary 

func XFreeLibrary(t *TLS, hLibModule uintptr) int32

BOOL FreeLibrary(HMODULE hLibModule);

func XGetACP 

func XGetACP(t *TLS) uint32

UINT GetACP();

func XGetAce 

func XGetAce(t *TLS, pAcl uintptr, dwAceIndex uint32, pAce uintptr) int32

BOOL GetAce( 

PACL   pAcl,
DWORD  dwAceIndex,
LPVOID *pAce

);

func XGetAclInformation 

func XGetAclInformation(t *TLS, pAcl, pAclInformation uintptr, nAclInformationLength, dwAclInformationClass uint32) int32

BOOL GetAclInformation( 

PACL                  pAcl,
LPVOID                pAclInformation,
DWORD                 nAclInformationLength,
ACL_INFORMATION_CLASS dwAclInformationClass

);

func XGetCommModemStatus 

func XGetCommModemStatus(t *TLS, _ ...interface{}) int32

func XGetCommState 

func XGetCommState(t *TLS, hFile, lpDCB uintptr) int32

BOOL GetCommState( 

HANDLE hFile,
LPDCB  lpDCB

);

func XGetCommandLineW 

func XGetCommandLineW(t *TLS) uintptr

LPWSTR GetCommandLineW();

func XGetComputerNameExW 

func XGetComputerNameExW(t *TLS, nameType int32, lpBuffer, nSize uintptr) int32

BOOL GetComputerNameExW( 

[in]      COMPUTER_NAME_FORMAT NameType,
[out]     LPWSTR               lpBuffer,
[in, out] LPDWORD              nSize

);

func XGetComputerNameW 

func XGetComputerNameW(t *TLS, lpBuffer, nSize uintptr) int32

BOOL GetComputerNameW( 

LPWSTR  lpBuffer,
LPDWORD nSize

);

func XGetConsoleCP 

func XGetConsoleCP(t *TLS) uint32

UINT WINAPI GetConsoleCP(void);

func XGetConsoleMode 

func XGetConsoleMode(t *TLS, hConsoleHandle, lpMode uintptr) int32

BOOL WINAPI GetConsoleMode( 

_In_  HANDLE  hConsoleHandle,
_Out_ LPDWORD lpMode

);

func XGetConsoleScreenBufferInfo 

func XGetConsoleScreenBufferInfo(t *TLS, hConsoleOutput, lpConsoleScreenBufferInfo uintptr) int32

BOOL WINAPI GetConsoleScreenBufferInfo( 

_In_  HANDLE                      hConsoleOutput,
_Out_ PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo

);

func XGetCurrentDirectoryW 

func XGetCurrentDirectoryW(t *TLS, nBufferLength uint32, lpBuffer uintptr) uint32

DWORD GetCurrentDirectory( 

DWORD  nBufferLength,
LPWTSTR lpBuffer

);

func XGetCurrentProcess 

func XGetCurrentProcess(t *TLS) uintptr

HANDLE GetCurrentProcess();

func XGetCurrentProcessId 

func XGetCurrentProcessId(t *TLS) uint32

DWORD GetCurrentProcessId();

func XGetCurrentThread 

func XGetCurrentThread(t *TLS) uintptr

HANDLE GetCurrentThread();

func XGetCurrentThreadId 

func XGetCurrentThreadId(t *TLS) uint32

DWORD GetCurrentThreadId();

func XGetDiskFreeSpaceA 

func XGetDiskFreeSpaceA(t *TLS, lpRootPathName, lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters uintptr) int32

BOOL GetDiskFreeSpaceA( 

LPCSTR  lpRootPathName,
LPDWORD lpSectorsPerCluster,
LPDWORD lpBytesPerSector,
LPDWORD lpNumberOfFreeClusters,
LPDWORD lpTotalNumberOfClusters

);

func XGetDiskFreeSpaceW 

func XGetDiskFreeSpaceW(t *TLS, lpRootPathName, lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters uintptr) int32

BOOL GetDiskFreeSpaceW( 

LPCWSTR lpRootPathName,
LPDWORD lpSectorsPerCluster,
LPDWORD lpBytesPerSector,
LPDWORD lpNumberOfFreeClusters,
LPDWORD lpTotalNumberOfClusters

);

func XGetEnvironmentVariableA 

func XGetEnvironmentVariableA(t *TLS, lpName, lpBuffer uintptr, nSize uint32) uint32

DWORD GetEnvironmentVariableA( 

LPCSTR lpName,
LPSTR  lpBuffer,
DWORD  nSize

);

func XGetEnvironmentVariableW 

func XGetEnvironmentVariableW(t *TLS, lpName, lpBuffer uintptr, nSize uint32) uint32

DWORD GetEnvironmentVariableW( 

LPCWSTR lpName,
LPWSTR  lpBuffer,
DWORD   nSize

);

func XGetExitCodeProcess 

func XGetExitCodeProcess(t *TLS, hProcess, lpExitCode uintptr) int32

BOOL GetExitCodeProcess( 

HANDLE  hProcess,
LPDWORD lpExitCode

);

func XGetExitCodeThread 

func XGetExitCodeThread(t *TLS, hThread, lpExitCode uintptr) int32

BOOL GetExitCodeThread( 

HANDLE  hThread,
LPDWORD lpExitCode

);

func XGetFileAttributesA 

func XGetFileAttributesA(t *TLS, lpFileName uintptr) uint32

DWORD GetFileAttributesA( 

LPCSTR lpFileName

);

func XGetFileAttributesExW 

func XGetFileAttributesExW(t *TLS, lpFileName uintptr, fInfoLevelId uint32, lpFileInformation uintptr) int32

BOOL GetFileAttributesExW( 

LPCWSTR                lpFileName,
GET_FILEEX_INFO_LEVELS fInfoLevelId,
LPVOID                 lpFileInformation

);

func XGetFileAttributesW 

func XGetFileAttributesW(t *TLS, lpFileName uintptr) uint32

DWORD GetFileAttributesW( 

LPCWSTR lpFileName

);

func XGetFileInformationByHandle 

func XGetFileInformationByHandle(t *TLS, hFile, lpFileInformation uintptr) int32

BOOL GetFileInformationByHandle( 

HANDLE                       hFile,
LPBY_HANDLE_FILE_INFORMATION lpFileInformation

);

func XGetFileSecurityA 

func XGetFileSecurityA(t *TLS, lpFileName uintptr, RequestedInformation uint32, pSecurityDescriptor uintptr, nLength uint32, lpnLengthNeeded uintptr) int32

BOOL GetFileSecurityA( 

LPCSTR               lpFileName,
SECURITY_INFORMATION RequestedInformation,
PSECURITY_DESCRIPTOR pSecurityDescriptor,
DWORD                nLength,
LPDWORD              lpnLengthNeeded

);

func XGetFileSecurityW 

func XGetFileSecurityW(t *TLS, lpFileName uintptr, RequestedInformation uint32, pSecurityDescriptor uintptr, nLength uint32, lpnLengthNeeded uintptr) int32

BOOL GetFileSecurityW( 

LPCSTR               lpFileName,
SECURITY_INFORMATION RequestedInformation,
PSECURITY_DESCRIPTOR pSecurityDescriptor,
DWORD                nLength,
LPDWORD              lpnLengthNeeded

);

func XGetFileSize 

func XGetFileSize(t *TLS, hFile, lpFileSizeHigh uintptr) uint32

DWORD GetFileSize( 

HANDLE  hFile,
LPDWORD lpFileSizeHigh

);

func XGetFileType 

func XGetFileType(t *TLS, hFile uintptr) uint32

DWORD GetFileType( 

HANDLE hFile

);

func XGetFullPathNameA 

func XGetFullPathNameA(t *TLS, lpFileName uintptr, nBufferLength uint32, lpBuffer, lpFilePart uintptr) uint32

DWORD GetFullPathNameA( 

LPCSTR lpFileName,
DWORD  nBufferLength,
LPSTR  lpBuffer,
LPSTR  *lpFilePart

);

func XGetFullPathNameW 

func XGetFullPathNameW(t *TLS, lpFileName uintptr, nBufferLength uint32, lpBuffer, lpFilePart uintptr) uint32

DWORD GetFullPathNameW( 

LPCWSTR lpFileName,
DWORD   nBufferLength,
LPWSTR  lpBuffer,
LPWSTR  *lpFilePart

);

func XGetLastError 

func XGetLastError(t *TLS) uint32

DWORD GetLastError();

func XGetLengthSid 

func XGetLengthSid(t *TLS, pSid uintptr) uint32

DWORD GetLengthSid( 

PSID pSid

);

func XGetLogicalDriveStringsA 

func XGetLogicalDriveStringsA(t *TLS, nBufferLength uint32, lpBuffer uintptr) uint32

DWORD GetLogicalDriveStringsA( 

DWORD nBufferLength,
LPSTR lpBuffer

);

func XGetMessageW 

func XGetMessageW(t *TLS, _ ...interface{}) int32

func XGetModuleFileNameA 

func XGetModuleFileNameA(t *TLS, _ ...interface{}) int32

func XGetModuleFileNameW 

func XGetModuleFileNameW(t *TLS, hModule, lpFileName uintptr, nSize uint32) uint32

DWORD GetModuleFileNameW( 

HMODULE hModule,
LPWSTR  lpFileName,
DWORD   nSize

);

func XGetModuleHandleA 

func XGetModuleHandleA(t *TLS, lpModuleName uintptr) uintptr

HMODULE GetModuleHandleA(LPCSTR lpModuleName);

func XGetModuleHandleW 

func XGetModuleHandleW(t *TLS, lpModuleName uintptr) uintptr

HMODULE GetModuleHandleW( 

LPCWSTR lpModuleName

);

func XGetNamedSecurityInfoW 

func XGetNamedSecurityInfoW(t *TLS, pObjectName uintptr, ObjectType, SecurityInfo uint32, ppsidOwner, ppsidGroup, ppDacl, ppSacl, ppSecurityDescriptor uintptr) uint32

DWORD GetNamedSecurityInfoW( 

LPCWSTR              pObjectName,
SE_OBJECT_TYPE       ObjectType,
SECURITY_INFORMATION SecurityInfo,
PSID                 *ppsidOwner,
PSID                 *ppsidGroup,
PACL                 *ppDacl,
PACL                 *ppSacl,
PSECURITY_DESCRIPTOR *ppSecurityDescriptor

);

func XGetOverlappedResult 

func XGetOverlappedResult(t *TLS, _ ...interface{}) int32

func XGetPrivateProfileStringA 

func XGetPrivateProfileStringA(t *TLS, lpAppName, lpKeyName, lpDefault, lpReturnedString uintptr, nSize uint32, lpFileName uintptr) uint32

DWORD GetPrivateProfileStringA( 

LPCSTR lpAppName,
LPCSTR lpKeyName,
LPCSTR lpDefault,
LPSTR  lpReturnedString,
DWORD  nSize,
LPCSTR lpFileName

);

func XGetProcAddress 

func XGetProcAddress(t *TLS, hModule, lpProcName uintptr) uintptr

FARPROC GetProcAddress(HMODULE hModule, LPCSTR lpProcName);

func XGetProcessHeap 

func XGetProcessHeap(t *TLS) uintptr

HANDLE GetProcessHeap();

func XGetProfilesDirectoryW 

func XGetProfilesDirectoryW(t *TLS, lpProfileDir, lpcchSize uintptr) int32

USERENVAPI BOOL GetProfilesDirectoryW( 

[out]     LPWSTR  lpProfileDir,
[in, out] LPDWORD lpcchSize

);

func XGetSecurityDescriptorDacl 

func XGetSecurityDescriptorDacl(t *TLS, pSecurityDescriptor, lpbDaclPresent, pDacl, lpbDaclDefaulted uintptr) int32

BOOL GetSecurityDescriptorDacl( 

PSECURITY_DESCRIPTOR pSecurityDescriptor,
LPBOOL               lpbDaclPresent,
PACL                 *pDacl,
LPBOOL               lpbDaclDefaulted

);

func XGetSecurityDescriptorOwner 

func XGetSecurityDescriptorOwner(t *TLS, pSecurityDescriptor, pOwner, lpbOwnerDefaulted uintptr) int32

BOOL GetSecurityDescriptorOwner( 

PSECURITY_DESCRIPTOR pSecurityDescriptor,
PSID                 *pOwner,
LPBOOL               lpbOwnerDefaulted

);

func XGetShortPathNameW 

func XGetShortPathNameW(t *TLS, _ ...interface{}) int32

func XGetSidIdentifierAuthority 

func XGetSidIdentifierAuthority(t *TLS, pSid uintptr) uintptr

PSID_IDENTIFIER_AUTHORITY GetSidIdentifierAuthority( 

PSID pSid

);

func XGetSidLengthRequired 

func XGetSidLengthRequired(t *TLS, nSubAuthorityCount uint8) int32

DWORD GetSidLengthRequired( 

UCHAR nSubAuthorityCount

);

func XGetSidSubAuthority 

func XGetSidSubAuthority(t *TLS, pSid uintptr, nSubAuthority uint32) uintptr

PDWORD GetSidSubAuthority( 

PSID  pSid,
DWORD nSubAuthority

);

func XGetStdHandle 

func XGetStdHandle(t *TLS, nStdHandle uint32) uintptr

HANDLE WINAPI GetStdHandle( 

_In_ DWORD nStdHandle

);

func XGetSystemInfo 

func XGetSystemInfo(t *TLS, lpSystemInfo uintptr)

void GetSystemInfo( 

LPSYSTEM_INFO lpSystemInfo

);

func XGetSystemTime 

func XGetSystemTime(t *TLS, lpSystemTime uintptr)

void GetSystemTime(LPSYSTEMTIME lpSystemTime);

func XGetSystemTimeAsFileTime 

func XGetSystemTimeAsFileTime(t *TLS, lpSystemTimeAsFileTime uintptr)

void GetSystemTimeAsFileTime( 

LPFILETIME lpSystemTimeAsFileTime

);

func XGetTempFileNameW 

func XGetTempFileNameW(t *TLS, lpPathName, lpPrefixString uintptr, uUnique uint32, lpTempFileName uintptr) uint32

UINT GetTempFileNameW( 

LPCWSTR lpPathName,
LPCWSTR lpPrefixString,
UINT    uUnique,
LPWSTR  lpTempFileName

);

func XGetTempPathA 

func XGetTempPathA(t *TLS, nBufferLength uint32, lpBuffer uintptr) uint32

DWORD GetTempPathA( 

DWORD nBufferLength,
LPSTR lpBuffer

);

func XGetTempPathW 

func XGetTempPathW(t *TLS, nBufferLength uint32, lpBuffer uintptr) uint32

DWORD GetTempPathW( 

DWORD  nBufferLength,
LPWSTR lpBuffer

);

func XGetTickCount 

func XGetTickCount(t *TLS) uint32

DWORD GetTickCount();

func XGetTokenInformation 

func XGetTokenInformation(t *TLS, TokenHandle uintptr, TokenInformationClass uint32, TokenInformation uintptr, TokenInformationLength uint32, ReturnLength uintptr) int32

BOOL GetTokenInformation( 

HANDLE                  TokenHandle,
TOKEN_INFORMATION_CLASS TokenInformationClass,
LPVOID                  TokenInformation,
DWORD                   TokenInformationLength,
PDWORD                  ReturnLength

);

func XGetUserNameW 

func XGetUserNameW(t *TLS, lpBuffer, pcbBuffer uintptr) int32

BOOL GetUserNameW( 

LPWSTR  lpBuffer,
LPDWORD pcbBuffer

);

func XGetVersionExA 

func XGetVersionExA(t *TLS, lpVersionInformation uintptr) int32

BOOL GetVersionExA( 

LPOSVERSIONINFOA lpVersionInformation

);

func XGetVersionExW 

func XGetVersionExW(t *TLS, lpVersionInformation uintptr) int32

BOOL GetVersionExW( 

LPOSVERSIONINFOW lpVersionInformation

);

func XGetVolumeInformationA 

func XGetVolumeInformationA(t *TLS, lpRootPathName, lpVolumeNameBuffer uintptr, nVolumeNameSize uint32, lpVolumeSerialNumber, lpMaximumComponentLength, lpFileSystemFlags, lpFileSystemNameBuffer uintptr, nFileSystemNameSize uint32) int32

BOOL GetVolumeInformationA( 

LPCSTR  lpRootPathName,
LPSTR   lpVolumeNameBuffer,
DWORD   nVolumeNameSize,
LPDWORD lpVolumeSerialNumber,
LPDWORD lpMaximumComponentLength,
LPDWORD lpFileSystemFlags,
LPSTR   lpFileSystemNameBuffer,
DWORD   nFileSystemNameSize

);

func XGetVolumeInformationW 

func XGetVolumeInformationW(t *TLS, lpRootPathName, lpVolumeNameBuffer uintptr, nVolumeNameSize uint32, lpVolumeSerialNumber, lpMaximumComponentLength, lpFileSystemFlags, lpFileSystemNameBuffer uintptr, nFileSystemNameSize uint32) int32

BOOL GetVolumeInformationW( 

LPCWSTR lpRootPathName,
LPWSTR  lpVolumeNameBuffer,
DWORD   nVolumeNameSize,
LPDWORD lpVolumeSerialNumber,
LPDWORD lpMaximumComponentLength,
LPDWORD lpFileSystemFlags,
LPWSTR  lpFileSystemNameBuffer,
DWORD   nFileSystemNameSize

);

func XGetVolumeNameForVolumeMountPointW 

func XGetVolumeNameForVolumeMountPointW(t *TLS, _ ...interface{}) int32

BOOL GetVolumeNameForVolumeMountPointW( 

LPCWSTR lpszVolumeMountPoint,
LPWSTR  lpszVolumeName,
DWORD   cchBufferLength

);

func XGetWindowLongPtrW 

func XGetWindowLongPtrW(t *TLS, _ ...interface{}) int32

func XGetWindowsDirectoryA 

func XGetWindowsDirectoryA(t *TLS, _ ...interface{}) int32

func XGlobalAddAtomW 

func XGlobalAddAtomW(t *TLS, _ ...interface{}) uint16

func XGlobalDeleteAtom 

func XGlobalDeleteAtom(t *TLS, _ ...interface{}) int32

func XGlobalGetAtomNameW 

func XGlobalGetAtomNameW(t *TLS, _ ...interface{}) int32

func XHeapAlloc 

func XHeapAlloc(t *TLS, hHeap uintptr, dwFlags uint32, dwBytes types.Size_t) uintptr

LPVOID HeapAlloc( 

HANDLE hHeap,
DWORD  dwFlags,
SIZE_T dwBytes

);

func XHeapCompact 

func XHeapCompact(t *TLS, hHeap uintptr, dwFlags uint32) types.Size_t

SIZE_T HeapCompact( 

HANDLE hHeap,
DWORD  dwFlags

);

func XHeapCreate 

func XHeapCreate(t *TLS, flOptions uint32, dwInitialSize, dwMaximumSize types.Size_t) uintptr

HANDLE HeapCreate( 

DWORD  flOptions,
SIZE_T dwInitialSize,
SIZE_T dwMaximumSize

);

func XHeapDestroy 

func XHeapDestroy(t *TLS, hHeap uintptr) int32

BOOL HeapDestroy( 

HANDLE hHeap

);

func XHeapFree 

func XHeapFree(t *TLS, hHeap uintptr, dwFlags uint32, lpMem uintptr) int32

BOOL HeapFree( 

HANDLE                 hHeap,
DWORD                  dwFlags,
_Frees_ptr_opt_ LPVOID lpMem

);

func XHeapReAlloc 

func XHeapReAlloc(t *TLS, hHeap uintptr, dwFlags uint32, lpMem uintptr, dwBytes types.Size_t) uintptr

LPVOID HeapReAlloc( 

HANDLE                 hHeap,
DWORD                  dwFlags,
_Frees_ptr_opt_ LPVOID lpMem,
SIZE_T                 dwBytes

);

func XHeapSize 

func XHeapSize(t *TLS, hHeap uintptr, dwFlags uint32, lpMem uintptr) types.Size_t

SIZE_T HeapSize( 

HANDLE  hHeap,
DWORD   dwFlags,
LPCVOID lpMem

);

func XHeapValidate 

func XHeapValidate(t *TLS, hHeap uintptr, dwFlags uint32, lpMem uintptr) int32

BOOL HeapValidate( 

HANDLE  hHeap,
DWORD   dwFlags,
LPCVOID lpMem

);

func XIN6_ADDR_EQUAL 

func XIN6_ADDR_EQUAL(t *TLS, _ ...interface{}) int32

func XIN6_IS_ADDR_V4MAPPED 

func XIN6_IS_ADDR_V4MAPPED(t *TLS, _ ...interface{}) int32

func XImpersonateSelf 

func XImpersonateSelf(t *TLS, ImpersonationLevel int32) int32

BOOL ImpersonateSelf( 

SECURITY_IMPERSONATION_LEVEL ImpersonationLevel

);

func XInitializeAcl 

func XInitializeAcl(t *TLS, pAcl uintptr, nAclLength, dwAclRevision uint32) int32

BOOL InitializeAcl( 

PACL  pAcl,
DWORD nAclLength,
DWORD dwAclRevision

);

func XInitializeCriticalSection 

func XInitializeCriticalSection(t *TLS, lpCriticalSection uintptr)

void InitializeCriticalSection( 

LPCRITICAL_SECTION lpCriticalSection

);

func XInitializeSid 

func XInitializeSid(t *TLS, Sid, pIdentifierAuthority uintptr, nSubAuthorityCount uint8) int32

BOOL InitializeSid( 

PSID                      Sid,
PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
BYTE                      nSubAuthorityCount

);

func XIsDebuggerPresent 

func XIsDebuggerPresent(t *TLS) int32

BOOL IsDebuggerPresent();

func XIsWindow 

func XIsWindow(t *TLS, _ ...interface{}) int32

func XKillTimer 

func XKillTimer(t *TLS, _ ...interface{}) int32

func XLeaveCriticalSection 

func XLeaveCriticalSection(t *TLS, lpCriticalSection uintptr)

void LeaveCriticalSection( 

LPCRITICAL_SECTION lpCriticalSection

);

func XLoadLibraryA 

func XLoadLibraryA(t *TLS, lpLibFileName uintptr) uintptr

HMODULE LoadLibraryA(LPCSTR lpLibFileName);

func XLoadLibraryExW 

func XLoadLibraryExW(t *TLS, lpLibFileName, hFile uintptr, dwFlags uint32) uintptr

HMODULE LoadLibraryExW( 

LPCWSTR lpLibFileName,
HANDLE  hFile,
DWORD   dwFlags

);

func XLoadLibraryW 

func XLoadLibraryW(t *TLS, lpLibFileName uintptr) uintptr

HMODULE LoadLibraryW( 

LPCWSTR lpLibFileName

);

func XLocalFree 

func XLocalFree(t *TLS, hMem uintptr) uintptr

HLOCAL LocalFree( 

HLOCAL hMem

);

func XLockFile 

func XLockFile(t *TLS, hFile uintptr, dwFileOffsetLow, dwFileOffsetHigh, nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh uint32) int32

BOOL LockFile( 

HANDLE hFile,
DWORD  dwFileOffsetLow,
DWORD  dwFileOffsetHigh,
DWORD  nNumberOfBytesToLockLow,
DWORD  nNumberOfBytesToLockHigh

);

func XLockFileEx 

func XLockFileEx(t *TLS, hFile uintptr, dwFlags, dwReserved, nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh uint32, lpOverlapped uintptr) int32

BOOL LockFileEx( 

HANDLE       hFile,
DWORD        dwFlags,
DWORD        dwReserved,
DWORD        nNumberOfBytesToLockLow,
DWORD        nNumberOfBytesToLockHigh,
LPOVERLAPPED lpOverlapped

);

func XMapViewOfFile 

func XMapViewOfFile(t *TLS, hFileMappingObject uintptr, dwDesiredAccess, dwFileOffsetHigh, dwFileOffsetLow uint32, dwNumberOfBytesToMap types.Size_t) uintptr

LPVOID MapViewOfFile( 

HANDLE hFileMappingObject,
DWORD  dwDesiredAccess,
DWORD  dwFileOffsetHigh,
DWORD  dwFileOffsetLow,
SIZE_T dwNumberOfBytesToMap

);

func XMessageBeep 

func XMessageBeep(t *TLS, _ ...interface{}) int32

func XMessageBoxW 

func XMessageBoxW(t *TLS, _ ...interface{}) int32

func XMoveFileW 

func XMoveFileW(t *TLS, lpExistingFileName, lpNewFileName uintptr) int32

BOOL MoveFileW( 

LPCWSTR lpExistingFileName,
LPCWSTR lpNewFileName

);

func XMsgWaitForMultipleObjectsEx 

func XMsgWaitForMultipleObjectsEx(t *TLS, nCount uint32, pHandles uintptr, dwMilliseconds, dwWakeMask, dwFlags uint32) uint32

DWORD MsgWaitForMultipleObjectsEx( 

DWORD        nCount,
const HANDLE *pHandles,
DWORD        dwMilliseconds,
DWORD        dwWakeMask,
DWORD        dwFlags

);

func XMultiByteToWideChar 

func XMultiByteToWideChar(t *TLS, CodePage uint32, dwFlags uint32, lpMultiByteStr uintptr, cbMultiByte int32, lpWideCharStr uintptr, cchWideChar int32) int32

int MultiByteToWideChar( 

UINT                              CodePage,
DWORD                             dwFlags,
_In_NLS_string_(cbMultiByte)LPCCH lpMultiByteStr,
int                               cbMultiByte,
LPWSTR                            lpWideCharStr,
int                               cchWideChar

);

func XNetApiBufferFree 

func XNetApiBufferFree(t *TLS, _ ...interface{}) int32

func XNetGetDCName 

func XNetGetDCName(t *TLS, ServerName, DomainName, Buffer uintptr) int32

NET_API_STATUS NET_API_FUNCTION NetGetDCName( 

LPCWSTR ServerName,
LPCWSTR DomainName,
LPBYTE  *Buffer

);

func XNetUserGetInfo 

func XNetUserGetInfo(t *TLS, servername, username uintptr, level uint32, bufptr uintptr) uint32

NET_API_STATUS NET_API_FUNCTION NetUserGetInfo( 

LPCWSTR servername,
LPCWSTR username,
DWORD   level,
LPBYTE  *bufptr

);

func XOpenEventA 

func XOpenEventA(t *TLS, dwDesiredAccess uint32, bInheritHandle uint32, lpName uintptr) uintptr

HANDLE OpenEventA( 

DWORD  dwDesiredAccess,
BOOL   bInheritHandle,
LPCSTR lpName

);

func XOpenProcessToken 

func XOpenProcessToken(t *TLS, ProcessHandle uintptr, DesiredAccess uint32, TokenHandle uintptr) int32

BOOL OpenProcessToken( 

HANDLE  ProcessHandle,
DWORD   DesiredAccess,
PHANDLE TokenHandle

);

func XOpenThreadToken 

func XOpenThreadToken(t *TLS, ThreadHandle uintptr, DesiredAccess uint32, OpenAsSelf int32, TokenHandle uintptr) int32

BOOL OpenThreadToken( 

HANDLE  ThreadHandle,
DWORD   DesiredAccess,
BOOL    OpenAsSelf,
PHANDLE TokenHandle

);

func XOutputDebugStringA 

func XOutputDebugStringA(t *TLS, lpOutputString uintptr)

void OutputDebugStringA( 

LPCSTR lpOutputString

)

func XOutputDebugStringW 

func XOutputDebugStringW(t *TLS, lpOutputString uintptr)

void OutputDebugStringW( 

LPCWSTR lpOutputString

);

func XPeekConsoleInputW 

func XPeekConsoleInputW(t *TLS, hConsoleInput, lpBuffer uintptr, nLength uint32, lpNumberOfEventsRead uintptr) int32

BOOL WINAPI PeekConsoleInput( 

_In_  HANDLE        hConsoleInput,
_Out_ PINPUT_RECORD lpBuffer,
_In_  DWORD         nLength,
_Out_ LPDWORD       lpNumberOfEventsRead

);

func XPeekMessageW 

func XPeekMessageW(t *TLS, lpMsg, hWnd uintptr, wMsgFilterMin, wMsgFilterMax, wRemoveMsg uint32) int32

BOOL PeekMessageW( 

LPMSG lpMsg,
HWND  hWnd,
UINT  wMsgFilterMin,
UINT  wMsgFilterMax,
UINT  wRemoveMsg

);

func XPeekNamedPipe 

func XPeekNamedPipe(t *TLS, hNamedPipe, lpBuffer uintptr, nBufferSize uint32, lpBytesRead, lpTotalBytesAvail, lpBytesLeftThisMessage uintptr) int32

BOOL PeekNamedPipe( 

HANDLE  hNamedPipe,
LPVOID  lpBuffer,
DWORD   nBufferSize,
LPDWORD lpBytesRead,
LPDWORD lpTotalBytesAvail,
LPDWORD lpBytesLeftThisMessage

);

func XPostMessageW 

func XPostMessageW(t *TLS, _ ...interface{}) int32

func XPostQuitMessage 

func XPostQuitMessage(t *TLS, _ ...interface{}) int32

func XPurgeComm 

func XPurgeComm(t *TLS, _ ...interface{}) int32

func XQueryPerformanceCounter 

func XQueryPerformanceCounter(t *TLS, lpPerformanceCount uintptr) int32

BOOL QueryPerformanceCounter( 

LARGE_INTEGER *lpPerformanceCount

);

func XQueryPerformanceFrequency 

func XQueryPerformanceFrequency(t *TLS, lpFrequency uintptr) int32

BOOL QueryPerformanceFrequency( 

LARGE_INTEGER *lpFrequency

);

func XRaiseException 

func XRaiseException(t *TLS, dwExceptionCode, dwExceptionFlags, nNumberOfArguments uint32, lpArguments uintptr)

VOID RaiseException( 

DWORD           dwExceptionCode,
DWORD           dwExceptionFlags,
DWORD           nNumberOfArguments,
const ULONG_PTR *lpArguments

);

func XReadConsoleW 

func XReadConsoleW(t *TLS, hConsoleInput, lpBuffer uintptr, nNumberOfCharsToRead uint32, lpNumberOfCharsRead, pInputControl uintptr) int32

BOOL WINAPI ReadConsole( 

_In_     HANDLE  hConsoleInput,
_Out_    LPVOID  lpBuffer,
_In_     DWORD   nNumberOfCharsToRead,
_Out_    LPDWORD lpNumberOfCharsRead,
_In_opt_ LPVOID  pInputControl

);

func XReadFile 

func XReadFile(t *TLS, hFile, lpBuffer uintptr, nNumberOfBytesToRead uint32, lpNumberOfBytesRead, lpOverlapped uintptr) int32

BOOL ReadFile( 

HANDLE       hFile,
LPVOID       lpBuffer,
DWORD        nNumberOfBytesToRead,
LPDWORD      lpNumberOfBytesRead,
LPOVERLAPPED lpOverlapped

);

func XRegCloseKey 

func XRegCloseKey(t *TLS, _ ...interface{}) int32

func XRegConnectRegistryW 

func XRegConnectRegistryW(t *TLS, _ ...interface{}) int32

func XRegCreateKeyExW 

func XRegCreateKeyExW(t *TLS, _ ...interface{}) int32

func XRegDeleteKeyW 

func XRegDeleteKeyW(t *TLS, _ ...interface{}) int32

func XRegDeleteValueW 

func XRegDeleteValueW(t *TLS, _ ...interface{}) int32

func XRegEnumKeyExW 

func XRegEnumKeyExW(t *TLS, _ ...interface{}) int32

func XRegEnumValueW 

func XRegEnumValueW(t *TLS, _ ...interface{}) int32

func XRegOpenKeyExW 

func XRegOpenKeyExW(t *TLS, _ ...interface{}) int32

func XRegQueryValueExW 

func XRegQueryValueExW(t *TLS, _ ...interface{}) int32

func XRegSetValueExW 

func XRegSetValueExW(t *TLS, _ ...interface{}) int32

func XRegisterClassExW 

func XRegisterClassExW(t *TLS, _ ...interface{}) int32

func XRegisterClassW 

func XRegisterClassW(t *TLS, lpWndClass uintptr) int32

ATOM RegisterClassW( 

const WNDCLASSW *lpWndClass

);

func XRemoveDirectoryW 

func XRemoveDirectoryW(t *TLS, lpPathName uintptr) int32

BOOL RemoveDirectoryW( 

LPCWSTR lpPathName

);

func XResetEvent 

func XResetEvent(t *TLS, hEvent uintptr) int32

BOOL ResetEvent( 

HANDLE hEvent

);

func XRevertToSelf 

func XRevertToSelf(t *TLS) int32

BOOL RevertToSelf();

func XRtlGetVersion 

func XRtlGetVersion(t *TLS, lpVersionInformation uintptr) uintptr

NTSYSAPI NTSTATUS RtlGetVersion( // ntdll.dll 

PRTL_OSVERSIONINFOW lpVersionInformation

);

func XSearchPathW 

func XSearchPathW(t *TLS, lpPath, lpFileName, lpExtension uintptr, nBufferLength uint32, lpBuffer, lpFilePart uintptr) int32

DWORD SearchPathW( 

LPCWSTR lpPath,
LPCWSTR lpFileName,
LPCWSTR lpExtension,
DWORD   nBufferLength,
LPWSTR  lpBuffer,
LPWSTR  *lpFilePart

);

func XSendMessageTimeoutW 

func XSendMessageTimeoutW(t *TLS, _ ...interface{}) int64

func XSendMessageW 

func XSendMessageW(t *TLS, _ ...interface{}) int32

func XSetCommState 

func XSetCommState(t *TLS, _ ...interface{}) int32

func XSetCommTimeouts 

func XSetCommTimeouts(t *TLS, _ ...interface{}) int32

func XSetConsoleCtrlHandler 

func XSetConsoleCtrlHandler(t *TLS, HandlerRoutine uintptr, Add int32) int32

BOOL WINAPI SetConsoleCtrlHandler( 

_In_opt_ PHANDLER_ROUTINE HandlerRoutine,
_In_     BOOL             Add

);

func XSetConsoleMode 

func XSetConsoleMode(t *TLS, hConsoleHandle uintptr, dwMode uint32) int32

BOOL WINAPI SetConsoleMode( 

_In_ HANDLE hConsoleHandle,
_In_ DWORD  dwMode

);

func XSetConsoleTextAttribute 

func XSetConsoleTextAttribute(t *TLS, hConsoleOutput uintptr, wAttributes uint16) int32

BOOL WINAPI SetConsoleTextAttribute( 

_In_ HANDLE hConsoleOutput,
_In_ WORD   wAttributes

);

func XSetCurrentDirectoryW 

func XSetCurrentDirectoryW(t *TLS, lpPathName uintptr) int32

BOOL SetCurrentDirectoryW( 

LPCTSTR lpPathName

);

func XSetEndOfFile 

func XSetEndOfFile(t *TLS, hFile uintptr) int32

BOOL SetEndOfFile( 

HANDLE hFile

);

func XSetErrorMode 

func XSetErrorMode(t *TLS, uMode uint32) int32

UINT SetErrorMode( 

UINT uMode

);

func XSetEvent 

func XSetEvent(t *TLS, hEvent uintptr) int32

BOOL SetEvent( 

HANDLE hEvent

);

func XSetFileAttributesW 

func XSetFileAttributesW(t *TLS, lpFileName uintptr, dwFileAttributes uint32) int32

BOOL SetFileAttributesW( 

LPCWSTR lpFileName,
DWORD   dwFileAttributes

);

func XSetFilePointer 

func XSetFilePointer(t *TLS, hFile uintptr, lDistanceToMove long, lpDistanceToMoveHigh uintptr, dwMoveMethod uint32) uint32

DWORD SetFilePointer( 

HANDLE hFile,
LONG   lDistanceToMove,
PLONG  lpDistanceToMoveHigh,
DWORD  dwMoveMethod

);

func XSetFileTime 

func XSetFileTime(t *TLS, hFile uintptr, lpCreationTime, lpLastAccessTime, lpLastWriteTime uintptr) int32

BOOL SetFileTime( 

HANDLE         hFile,
const FILETIME *lpCreationTime,
const FILETIME *lpLastAccessTime,
const FILETIME *lpLastWriteTime

);

func XSetHandleInformation 

func XSetHandleInformation(t *TLS, _ ...interface{}) int32

func XSetNamedSecurityInfoA 

func XSetNamedSecurityInfoA(t *TLS, pObjectName uintptr, ObjectType, SecurityInfo uint32, psidOwner, psidGroup, pDacl, pSacl uintptr) uint32

DWORD SetNamedSecurityInfoA( 

LPSTR                pObjectName,
SE_OBJECT_TYPE       ObjectType,
SECURITY_INFORMATION SecurityInfo,
PSID                 psidOwner,
PSID                 psidGroup,
PACL                 pDacl,
PACL                 pSacl

);

func XSetThreadPriority 

func XSetThreadPriority(t *TLS, hThread uintptr, nPriority int32) int32

BOOL SetThreadPriority( 

HANDLE hThread,
int    nPriority

);

func XSetTimer 

func XSetTimer(t *TLS, _ ...interface{}) int32

func XSetWindowLongPtrW 

func XSetWindowLongPtrW(t *TLS, _ ...interface{}) int32

func XSetupComm 

func XSetupComm(t *TLS, _ ...interface{}) int32

func XSleep 

func XSleep(t *TLS, dwMilliseconds uint32)

void Sleep( 

DWORD dwMilliseconds

);

func XSleepEx 

func XSleepEx(t *TLS, dwMilliseconds uint32, bAlertable int32) uint32

DWORD SleepEx( 

DWORD dwMilliseconds,
BOOL  bAlertable

);

func XSystemTimeToFileTime 

func XSystemTimeToFileTime(t *TLS, lpSystemTime, lpFileTime uintptr) int32

BOOL SystemTimeToFileTime(const SYSTEMTIME *lpSystemTime, LPFILETIME lpFileTime);

func XTerminateThread 

func XTerminateThread(t *TLS, hThread uintptr, dwExitCode uint32) int32

BOOL TerminateThread( 

[in, out] HANDLE hThread,
[in]      DWORD  dwExitCode

);

func XTranslateMessage 

func XTranslateMessage(t *TLS, _ ...interface{}) int32

func XUnlockFile 

func XUnlockFile(t *TLS, hFile uintptr, dwFileOffsetLow, dwFileOffsetHigh, nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh uint32) int32

BOOL UnlockFile( 

HANDLE hFile,
DWORD  dwFileOffsetLow,
DWORD  dwFileOffsetHigh,
DWORD  nNumberOfBytesToUnlockLow,
DWORD  nNumberOfBytesToUnlockHigh

);

func XUnlockFileEx 

func XUnlockFileEx(t *TLS, hFile uintptr, dwReserved, nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh uint32, lpOverlapped uintptr) int32

BOOL UnlockFileEx( 

HANDLE       hFile,
DWORD        dwReserved,
DWORD        nNumberOfBytesToUnlockLow,
DWORD        nNumberOfBytesToUnlockHigh,
LPOVERLAPPED lpOverlapped

);

func XUnmapViewOfFile 

func XUnmapViewOfFile(t *TLS, lpBaseAddress uintptr) int32

BOOL UnmapViewOfFile( 

LPCVOID lpBaseAddress

);

func XUnregisterClassW 

func XUnregisterClassW(t *TLS, lpClassName, hInstance uintptr) int32

BOOL UnregisterClassW( 

LPCWSTR   lpClassName,
HINSTANCE hInstance

);

func XWSAAsyncSelect 

func XWSAAsyncSelect(t *TLS, _ ...interface{}) int32

func XWSAGetLastError 

func XWSAGetLastError(t *TLS, _ ...interface{}) int32

func XWSAStartup 

func XWSAStartup(t *TLS, wVersionRequired uint16, lpWSAData uintptr) int32

int WSAStartup( 

WORD      wVersionRequired,
LPWSADATA lpWSAData

);

func XWaitForInputIdle 

func XWaitForInputIdle(t *TLS, hProcess uintptr, dwMilliseconds uint32) int32

DWORD WaitForInputIdle( 

HANDLE hProcess,
DWORD  dwMilliseconds

);

func XWaitForSingleObject 

func XWaitForSingleObject(t *TLS, hHandle uintptr, dwMilliseconds uint32) uint32

DWORD WaitForSingleObject( 

HANDLE hHandle,
DWORD  dwMilliseconds

);

func XWaitForSingleObjectEx 

func XWaitForSingleObjectEx(t *TLS, hHandle uintptr, dwMilliseconds uint32, bAlertable int32) uint32

DWORD WaitForSingleObjectEx( 

HANDLE hHandle,
DWORD  dwMilliseconds,
BOOL   bAlertable

);

func XWideCharToMultiByte 

func XWideCharToMultiByte(t *TLS, CodePage uint32, dwFlags uint32, lpWideCharStr uintptr, cchWideChar int32, lpMultiByteStr uintptr, cbMultiByte int32, lpDefaultChar, lpUsedDefaultChar uintptr) int32

int WideCharToMultiByte( 

UINT                               CodePage,
DWORD                              dwFlags,
_In_NLS_string_(cchWideChar)LPCWCH lpWideCharStr,
int                                cchWideChar,
LPSTR                              lpMultiByteStr,
int                                cbMultiByte,
LPCCH                              lpDefaultChar,
LPBOOL                             lpUsedDefaultChar

);

func XWriteConsoleW 

func XWriteConsoleW(t *TLS, hConsoleOutput, lpBuffer uintptr, nNumberOfCharsToWrite uint32, lpNumberOfCharsWritten, lpReserved uintptr) int32

BOOL WINAPI WriteConsoleW( 

_In_             HANDLE  hConsoleOutput,
_In_       const VOID    *lpBuffer,
_In_             DWORD   nNumberOfCharsToWrite,
_Out_opt_        LPDWORD lpNumberOfCharsWritten,
_Reserved_       LPVOID  lpReserved

);

func XWriteFile 

func XWriteFile(t *TLS, hFile, lpBuffer uintptr, nNumberOfBytesToWrite uint32, lpNumberOfBytesWritten, lpOverlapped uintptr) int32

BOOL WriteFile( 

HANDLE       hFile,
LPCVOID      lpBuffer,
DWORD        nNumberOfBytesToWrite,
LPDWORD      lpNumberOfBytesWritten,
LPOVERLAPPED lpOverlapped

);

func XWspiapiFreeAddrInfo 

func XWspiapiFreeAddrInfo(t *TLS, _ ...interface{}) int32

func XWspiapiGetAddrInfo 

func XWspiapiGetAddrInfo(t *TLS, _ ...interface{}) int32

INT WSAAPI getaddrinfo( 

PCSTR           pNodeName,
PCSTR           pServiceName,
const ADDRINFOA *pHints,
PADDRINFOA      *ppResult

);

func XWspiapiGetNameInfo 

func XWspiapiGetNameInfo(t *TLS, _ ...interface{}) int32

func X_IO_putc 

func X_IO_putc(t *TLS, c int32, fp uintptr) int32

int _IO_putc(int __c, _IO_FILE *__fp);

func X_InterlockedCompareExchange 

func X_InterlockedCompareExchange(t *TLS, Destination uintptr, Exchange, Comparand long) long

long _InterlockedCompareExchange( 

long volatile * Destination,
long Exchange,
long Comparand

);

func X_InterlockedExchange 

func X_InterlockedExchange(t *TLS, Target uintptr, Value long) long

long _InterlockedExchange( 

long volatile * Target,
long Value

);

func X___errno_location 

func X___errno_location(t *TLS) uintptr

func X__acrt_iob_func 

func X__acrt_iob_func(t *TLS, fd uint32) uintptr

__acrt_iob_func

func X__assert_fail 

func X__assert_fail(t *TLS, assertion, file uintptr, line uint32, function uintptr)

void __assert_fail(const char * assertion, const char * file, unsigned int line, const char * function);

func X__atomic_load_n 

func X__atomic_load_n(t *TLS)

__atomic_load_n

func X__atomic_store_n 

func X__atomic_store_n(t *TLS, _ ...interface{}) int32

__atomic_store_n

func X__builtin___memcpy_chk 

func X__builtin___memcpy_chk(t *TLS, dest, src uintptr, n, os types.Size_t) (r uintptr)

void * __builtin___memcpy_chk (void *dest, const void *src, size_t n, size_t os);

func X__builtin___memmove_chk 

func X__builtin___memmove_chk(t *TLS, dest, src uintptr, n, os types.Size_t) uintptr

void * __builtin___memmove_chk (void *dest, const void *src, size_t n, size_t os);

func X__builtin___memset_chk 

func X__builtin___memset_chk(t *TLS, s uintptr, c int32, n, os types.Size_t) uintptr

void * __builtin___memset_chk (void *s, int c, size_t n, size_t os);

func X__builtin___snprintf_chk 

func X__builtin___snprintf_chk(t *TLS, str uintptr, maxlen types.Size_t, flag int32, os types.Size_t, format, args uintptr) (r int32)

int __builtin___snprintf_chk(char * str, size_t maxlen, int flag, size_t os, const char * format, ...);

func X__builtin___sprintf_chk 

func X__builtin___sprintf_chk(t *TLS, s uintptr, flag int32, os types.Size_t, format, args uintptr) (r int32)

int __builtin___sprintf_chk (char *s, int flag, size_t os, const char *fmt, ...);

func X__builtin___strcat_chk 

func X__builtin___strcat_chk(t *TLS, dest, src uintptr, os types.Size_t) (r uintptr)

char * __builtin___strcat_chk (char *dest, const char *src, size_t os);

func X__builtin___strcpy_chk 

func X__builtin___strcpy_chk(t *TLS, dest, src uintptr, os types.Size_t) uintptr

char * __builtin___strcpy_chk (char *dest, const char *src, size_t os);

func X__builtin___strncpy_chk 

func X__builtin___strncpy_chk(t *TLS, dest, src uintptr, n, os types.Size_t) (r uintptr)

char * __builtin___strncpy_chk (char *dest, const char *src, size_t n, size_t os);

func X__builtin___vsnprintf_chk 

func X__builtin___vsnprintf_chk(t *TLS, str uintptr, maxlen types.Size_t, flag int32, os types.Size_t, format, args uintptr) (r int32)

int __builtin___vsnprintf_chk (char *s, size_t maxlen, int flag, size_t os, const char *fmt, va_list ap);

func X__builtin_abort 

func X__builtin_abort(t *TLS)

func X__builtin_abs 

func X__builtin_abs(t *TLS, j int32) int32

func X__builtin_add_overflow 

func X__builtin_add_overflow(t *TLS)

__builtin_add_overflow

func X__builtin_add_overflowInt64 

func X__builtin_add_overflowInt64(t *TLS, a, b int64, res uintptr) int32

bool __builtin_add_overflow (type1 a, type2 b, type3 *res)

func X__builtin_add_overflowUint32 

func X__builtin_add_overflowUint32(t *TLS, a, b uint32, res uintptr) int32

bool __builtin_add_overflow (type1 a, type2 b, type3 *res)

func X__builtin_add_overflowUint64 

func X__builtin_add_overflowUint64(t *TLS, a, b uint64, res uintptr) int32

bool __builtin_add_overflow (type1 a, type2 b, type3 *res)

func X__builtin_bswap16 

func X__builtin_bswap16(t *TLS, x uint16) uint16

uint16_t __builtin_bswap16 (uint32_t x)

func X__builtin_bswap32 

func X__builtin_bswap32(t *TLS, x uint32) uint32

uint32_t __builtin_bswap32 (uint32_t x)

func X__builtin_bswap64 

func X__builtin_bswap64(t *TLS, x uint64) uint64

uint64_t __builtin_bswap64 (uint64_t x)

func X__builtin_bzero 

func X__builtin_bzero(t *TLS, s uintptr, n types.Size_t)

func X__builtin_clz 

func X__builtin_clz(t *TLS, n uint32) int32

func X__builtin_clzl 

func X__builtin_clzl(t *TLS, n ulong) int32

func X__builtin_clzll 

func X__builtin_clzll(t *TLS, n uint64) int32

func X__builtin_constant_p_impl 

func X__builtin_constant_p_impl()

func X__builtin_copysign 

func X__builtin_copysign(t *TLS, x, y float64) float64

func X__builtin_copysignf 

func X__builtin_copysignf(t *TLS, x, y float32) float32

func X__builtin_copysignl 

func X__builtin_copysignl(t *TLS, x, y float64) float64

func X__builtin_exit 

func X__builtin_exit(t *TLS, status int32)

func X__builtin_expect 

func X__builtin_expect(t *TLS, exp, c long) long

func X__builtin_fabs 

func X__builtin_fabs(t *TLS, x float64) float64

func X__builtin_fabsf 

func X__builtin_fabsf(t *TLS, x float32) float32

func X__builtin_fabsl 

func X__builtin_fabsl(t *TLS, x float64) float64

func X__builtin_free 

func X__builtin_free(t *TLS, ptr uintptr)

func X__builtin_getentropy 

func X__builtin_getentropy(t *TLS, buf uintptr, n types.Size_t) int32

func X__builtin_huge_val 

func X__builtin_huge_val(t *TLS) float64

func X__builtin_huge_valf 

func X__builtin_huge_valf(t *TLS) float32

func X__builtin_inf 

func X__builtin_inf(t *TLS) float64

func X__builtin_inff 

func X__builtin_inff(t *TLS) float32

func X__builtin_infl 

func X__builtin_infl(t *TLS) float64

func X__builtin_isnan 

func X__builtin_isnan(t *TLS, x float64) int32

func X__builtin_isunordered 

func X__builtin_isunordered(t *TLS, a, b float64) int32

func X__builtin_llabs 

func X__builtin_llabs(tls *TLS, a int64) int64

func X__builtin_malloc 

func X__builtin_malloc(t *TLS, size types.Size_t) uintptr

func X__builtin_memcmp 

func X__builtin_memcmp(t *TLS, s1, s2 uintptr, n types.Size_t) int32

func X__builtin_memcpy 

func X__builtin_memcpy(t *TLS, dest, src uintptr, n types.Size_t) (r uintptr)

func X__builtin_memset 

func X__builtin_memset(t *TLS, s uintptr, c int32, n types.Size_t) uintptr

func X__builtin_mmap 

func X__builtin_mmap(t *TLS, addr uintptr, length types.Size_t, prot, flags, fd int32, offset types.Off_t) uintptr

func X__builtin_mul_overflow 

func X__builtin_mul_overflow(t *TLS)

__builtin_mul_overflow

func X__builtin_mul_overflowInt64 

func X__builtin_mul_overflowInt64(t *TLS, a, b int64, res uintptr) int32

bool __builtin_mul_overflow (type1 a, type2 b, type3 *res)

func X__builtin_mul_overflowUint128 

func X__builtin_mul_overflowUint128(t *TLS, a, b Uint128, res uintptr) int32

bool __builtin_mul_overflow (type1 a, type2 b, type3 *res)

func X__builtin_mul_overflowUint64 

func X__builtin_mul_overflowUint64(t *TLS, a, b uint64, res uintptr) int32

bool __builtin_mul_overflow (type1 a, type2 b, type3 *res)

func X__builtin_nan 

func X__builtin_nan(t *TLS, s uintptr) float64

func X__builtin_nanf 

func X__builtin_nanf(t *TLS, s uintptr) float32

func X__builtin_nanl 

func X__builtin_nanl(t *TLS, s uintptr) float64

func X__builtin_object_size 

func X__builtin_object_size(t *TLS, p uintptr, typ int32) types.Size_t

size_t __builtin_object_size (const void * ptr, int type)

func X__builtin_popcount 

func X__builtin_popcount(t *TLS, x uint32) int32

int __builtin_popcount (unsigned int x)

func X__builtin_popcountl 

func X__builtin_popcountl(t *TLS, x ulong) int32

int __builtin_popcountl (unsigned long x)

func X__builtin_prefetch 

func X__builtin_prefetch(t *TLS, addr, args uintptr)

func X__builtin_printf 

func X__builtin_printf(t *TLS, s, args uintptr) int32

func X__builtin_snprintf 

func X__builtin_snprintf(t *TLS, str uintptr, size types.Size_t, format, args uintptr) int32

func X__builtin_sprintf 

func X__builtin_sprintf(t *TLS, str, format, args uintptr) (r int32)

func X__builtin_strchr 

func X__builtin_strchr(t *TLS, s uintptr, c int32) uintptr

func X__builtin_strcmp 

func X__builtin_strcmp(t *TLS, s1, s2 uintptr) int32

func X__builtin_strcpy 

func X__builtin_strcpy(t *TLS, dest, src uintptr) uintptr

func X__builtin_strlen 

func X__builtin_strlen(t *TLS, s uintptr) types.Size_t

func X__builtin_sub_overflow 

func X__builtin_sub_overflow(t *TLS)

__builtin_sub_overflow

func X__builtin_sub_overflowInt64 

func X__builtin_sub_overflowInt64(t *TLS, a, b int64, res uintptr) int32

bool __builtin_sub_overflow (type1 a, type2 b, type3 *res)

func X__builtin_trap 

func X__builtin_trap(t *TLS)

func X__builtin_unreachable 

func X__builtin_unreachable(t *TLS)

func X__ccgo_dmesg 

func X__ccgo_dmesg(t *TLS, fmt uintptr, va uintptr)

func X__ccgo_getMutexType 

func X__ccgo_getMutexType(tls *TLS, m uintptr) int32

func X__ccgo_in6addr_anyp 

func X__ccgo_in6addr_anyp(t *TLS, _ ...interface{}) int32

func X__ccgo_pthreadAttrGetDetachState 

func X__ccgo_pthreadAttrGetDetachState(tls *TLS, a uintptr) int32

func X__ccgo_pthreadMutexattrGettype 

func X__ccgo_pthreadMutexattrGettype(tls *TLS, a uintptr) int32

func X__ccgo_sqlite3_log 

func X__ccgo_sqlite3_log(t *TLS, iErrCode int32, zFormat uintptr, args uintptr)

void sqlite3_log(int iErrCode, const char *zFormat, ...);

func X__ctype_get_mb_cur_max 

func X__ctype_get_mb_cur_max(t *TLS) types.Size_t

size_t __ctype_get_mb_cur_max(void);

func X__env_rm_add 

func X__env_rm_add(tls *TLS, old uintptr, new uintptr)

func X__errno_location 

func X__errno_location(t *TLS) uintptr

int * __errno_location(void);

func X__isalnum_l 

func X__isalnum_l(tls *TLS, c int32, l locale_t) int32

func X__isalpha_l 

func X__isalpha_l(tls *TLS, c int32, l locale_t) int32

func X__isdigit_l 

func X__isdigit_l(tls *TLS, c int32, l locale_t) int32

func X__islower_l 

func X__islower_l(tls *TLS, c int32, l locale_t) int32

func X__isnan 

func X__isnan(t *TLS, arg float64) int32

func X__isnanf 

func X__isnanf(t *TLS, arg float32) int32

func X__isnanl 

func X__isnanl(t *TLS, arg float64) int32

func X__isoc99_sscanf 

func X__isoc99_sscanf(t *TLS, str, format, va uintptr) int32

int __isoc99_sscanf(const char *str, const char *format, ...);

func X__isprint_l 

func X__isprint_l(tls *TLS, c int32, l locale_t) int32

func X__isspace_l 

func X__isspace_l(tls *TLS, c int32, l locale_t) int32

func X__isxdigit_l 

func X__isxdigit_l(tls *TLS, c int32, l locale_t) int32

func X__mingw_vfprintf 

func X__mingw_vfprintf(t *TLS, f uintptr, format, va uintptr) int32

int vfprintf(FILE * restrict stream, const char * restrict format, va_list arg);

func X__mingw_vfscanf 

func X__mingw_vfscanf(t *TLS, stream, format, ap uintptr) int32

int vfscanf(FILE * restrict stream, const char * restrict format, va_list arg);

func X__mingw_vfwprintf 

func X__mingw_vfwprintf(t *TLS, stream, format, ap uintptr) int32

int vfwprintf(FILE * restrict stream, const wchar_t * restrict format, va_list arg);

func X__mingw_vfwscanf 

func X__mingw_vfwscanf(t *TLS, stream uintptr, format, ap uintptr) int32

int vfwscanf(FILE *stream, const wchar_t *format, va_list argptr;);

func X__mingw_vprintf 

func X__mingw_vprintf(t *TLS, s, ap uintptr) int32

int vprintf(const char *format, va_list ap);

func X__mingw_vsnprintf 

func X__mingw_vsnprintf(t *TLS, str uintptr, size types.Size_t, format, ap uintptr) int32

int vsnprintf(char *str, size_t size, const char *format, va_list ap);

func X__mingw_vsnwprintf 

func X__mingw_vsnwprintf(t *TLS, buffer uintptr, count types.Size_t, format, va uintptr) int32

int _vsnwprintf( 

wchar_t *buffer,
size_t count,
const wchar_t *format,
va_list argptr

);

func X__mingw_vsprintf 

func X__mingw_vsprintf(t *TLS, s, format, ap uintptr) int32

int vsprintf(char * restrict s, const char * restrict format, va_list arg);

func X__mingw_vsscanf 

func X__mingw_vsscanf(t *TLS, str, format, ap uintptr) int32

int vsscanf(const char *str, const char *format, va_list ap);

func X__mingw_vswscanf 

func X__mingw_vswscanf(t *TLS, stream uintptr, format, ap uintptr) int32

int vswscanf(const wchar_t *buffer, const wchar_t *format, va_list arglist);

func X__ms_vfscanf 

func X__ms_vfscanf(t *TLS, stream, format, ap uintptr) int32

int vfscanf(FILE * restrict stream, const char * restrict format, va_list arg);

func X__ms_vfwscanf 

func X__ms_vfwscanf(t *TLS, stream uintptr, format, ap uintptr) int32

int vfwscanf(FILE *stream, const wchar_t *format, va_list argptr;);

func X__ms_vscanf 

func X__ms_vscanf(t *TLS, format, ap uintptr) int32

int vscanf(const char *format, va_list ap);

func X__ms_vsnprintf 

func X__ms_vsnprintf(t *TLS, str uintptr, size types.Size_t, format, ap uintptr) int32

int vsnprintf(char *str, size_t size, const char *format, va_list ap);

func X__ms_vsscanf 

func X__ms_vsscanf(t *TLS, str, format, ap uintptr) int32

int vsscanf(const char *str, const char *format, va_list ap);

func X__ms_vswscanf 

func X__ms_vswscanf(t *TLS, stream uintptr, format, ap uintptr) int32

int vswscanf(const wchar_t *buffer, const wchar_t *format, va_list arglist);

func X__ms_vwscanf 

func X__ms_vwscanf(t *TLS, format, ap uintptr) int32

int vwscanf(const wchar_t * restrict format, va_list arg);

func X__putenv 

func X__putenv(tls *TLS, s uintptr, l size_t, r uintptr) int32

func X__stdio_common_vfprintf 

func X__stdio_common_vfprintf(t *TLS, args ...interface{}) int32

func X__stdio_common_vfprintf_p 

func X__stdio_common_vfprintf_p(t *TLS, args ...interface{}) int32

func X__stdio_common_vfprintf_s 

func X__stdio_common_vfprintf_s(t *TLS, args ...interface{}) int32

func X__stdio_common_vfscanf 

func X__stdio_common_vfscanf(t *TLS, args ...interface{}) int32

func X__stdio_common_vfwprintf_s 

func X__stdio_common_vfwprintf_s(t *TLS, args ...interface{}) int32

func X__stdio_common_vfwscanf 

func X__stdio_common_vfwscanf(t *TLS, args ...interface{}) int32

func X__stdio_common_vsnprintf_s 

func X__stdio_common_vsnprintf_s(t *TLS, args ...interface{}) int32

func X__stdio_common_vsnwprintf_s 

func X__stdio_common_vsnwprintf_s(t *TLS, args ...interface{}) int32

func X__stdio_common_vsprintf 

func X__stdio_common_vsprintf(t *TLS, args ...interface{}) int32

func X__stdio_common_vsprintf_p 

func X__stdio_common_vsprintf_p(t *TLS, args ...interface{}) int32

func X__stdio_common_vsprintf_s 

func X__stdio_common_vsprintf_s(t *TLS, args ...interface{}) int32

func X__stdio_common_vsscanf 

func X__stdio_common_vsscanf(t *TLS, args ...interface{}) int32

func X__stdio_common_vswprintf 

func X__stdio_common_vswprintf(t *TLS, args ...interface{}) int32

func X__stdio_common_vswprintf_s 

func X__stdio_common_vswprintf_s(t *TLS, args ...interface{}) int32

func X__stdio_common_vswscanf 

func X__stdio_common_vswscanf(t *TLS, args ...interface{}) int32

func X__strchrnul 

func X__strchrnul(tls *TLS, s uintptr, c int32) uintptr

func X__sync_add_and_fetch_uint32 

func X__sync_add_and_fetch_uint32(t *TLS, p uintptr, v uint32) uint32

unsigned __sync_add_and_fetch_uint32(*unsigned, unsigned)

func X__sync_sub_and_fetch_uint32 

func X__sync_sub_and_fetch_uint32(t *TLS, p uintptr, v uint32) uint32

unsigned __sync_sub_and_fetch_uint32(*unsigned, unsigned)

func X__sync_synchronize 

func X__sync_synchronize(t *TLS)

__sync_synchronize();

func X_access 

func X_access(t *TLS, pathname uintptr, mode int32) int32

int _access( 

const char *path,
int mode

);

func X_assert 

func X_assert(t *TLS, message, filename uintptr, line uint32)

void _assert( 

char const* message,
char const* filename,
unsigned line

);

func X_beginthread 

func X_beginthread(t *TLS, procAddr uintptr, stack_sz uint32, args uintptr) int32

The calling convention for beginthread is cdecl -- but in this case we're just intercepting it and sending it through CreateThread which expects stdcall and gets that via the go callback. This is safe because the thread is calling into go not a cdecl function which would expect the stack setup of cdecl.

func X_beginthreadex 

func X_beginthreadex(t *TLS, _ uintptr, stack_sz uint32, procAddr uintptr, args uintptr, initf uint32, thAddr uintptr) int32

uintptr_t _beginthreadex( // NATIVE CODE 

void *security,
unsigned stack_size,
unsigned ( __stdcall *start_address )( void * ),
void *arglist,
unsigned initflag,
unsigned *thrdaddr

);

func X_byteswap_uint64 

func X_byteswap_uint64(t *TLS, val uint64) uint64

unsigned __int64 _byteswap_uint64 ( unsigned __int64 val );

func X_byteswap_ulong 

func X_byteswap_ulong(t *TLS, val ulong) ulong

unsigned long _byteswap_ulong ( unsigned long val );

func X_chmod 

func X_chmod(t *TLS, filename uintptr, pmode int32) int32

int _chmod( const char *filename, int pmode );

func X_chsize 

func X_chsize(t *TLS, fd int32, size long) int32

int _chsize( 

int fd,
long size

);

func X_commit 

func X_commit(t *TLS, fd int32) int32

int _commit( 

int fd

);

func X_controlfp 

func X_controlfp(t *TLS, _ ...interface{}) uint32

func X_copysign 

func X_copysign(t *TLS, x, y float64) float64

double _copysign( 

double x,
double y

);

func X_endthreadex 

func X_endthreadex(t *TLS, _ ...interface{})

func X_errno 

func X_errno(t *TLS) uintptr

_CRTIMP extern int *__cdecl _errno(void); // /usr/share/mingw-w64/include/errno.h:17:

func X_exit 

func X_exit(_ *TLS, status int32)

void _exit(int status);

func X_fileno 

func X_fileno(t *TLS, stream uintptr) int32

int _fileno(FILE *stream);

func X_findclose 

func X_findclose(t *TLS, handle types.Intptr_t) int32

int _findclose( 

intptr_t handle

);

func X_findfirst32 

func X_findfirst32(t *TLS, filespec, fileinfo uintptr) types.Intptr_t

intptr_t _findfirst32( 

const char *filespec,
struct _finddata32_t *fileinfo

);

func X_findfirst64i32 

func X_findfirst64i32(t *TLS, filespec, fileinfo uintptr) types.Intptr_t

intptr_t _findfirst64i32( 

const char *filespec,
struct _finddata64i32_t *fileinfo

);

func X_findnext32 

func X_findnext32(t *TLS, handle types.Intptr_t, buffer uintptr) int32

int _findnext32( 

intptr_t handle,
struct _finddata32_t *fileinfo

);

func X_findnext64i32 

func X_findnext64i32(t *TLS, handle types.Intptr_t, fileinfo uintptr) int32

int _findnext64i32( 

intptr_t handle,
struct _finddata64i32_t *fileinfo

);

func X_fstat64 

func X_fstat64(t *TLS, fd int32, buffer uintptr) int32

int _fstat64( 

int fd,
struct __stat64 *buffer

);

func X_fstati64 

func X_fstati64(t *TLS, fd int32, buffer uintptr) int32

int _fstati64( 

int fd,
struct _stati64 *buffer

);

func X_ftime 

func X_ftime(t *TLS, timeptr uintptr)

void _ftime( struct _timeb *timeptr );

func X_ftime64 

func X_ftime64(t *TLS, timeptr uintptr)

void _ftime64( struct __timeb64 *timeptr );

func X_gmtime64 

func X_gmtime64(t *TLS, sourceTime uintptr) uintptr

struct tm *_gmtime64( const __time64_t *sourceTime );

func X_isatty 

func X_isatty(t *TLS, fd int32) int32

int _isatty( int fd );

func X_localtime64 

func X_localtime64(_ *TLS, timep uintptr) uintptr

struct tm *localtime(const time_t *timep);

func X_longjmp 

func X_longjmp(t *TLS, env uintptr, val int32)

void _longjmp(jmp_buf env, int val);

func X_mkdir 

func X_mkdir(t *TLS, dirname uintptr) int32

int _mkdir(const char *dirname);

func X_mktime64 

func X_mktime64(t *TLS, timeptr uintptr) time.X__time64_t

__time64_t _mktime64(struct tm *timeptr);

func X_msize 

func X_msize(t *TLS, memblock uintptr) types.Size_t

size_t _msize( 

void *memblock

);

func X_obstack_begin 

func X_obstack_begin(t *TLS, obstack uintptr, size, alignment int32, chunkfun, freefun uintptr) int32

int _obstack_begin (struct obstack *h, _OBSTACK_SIZE_T size, _OBSTACK_SIZE_T alignment, void *(*chunkfun) (size_t), void (*freefun) (void *))

func X_obstack_newchunk 

func X_obstack_newchunk(t *TLS, obstack uintptr, length int32) int32

extern void _obstack_newchunk(struct obstack *, int);

func X_pclose 

func X_pclose(t *TLS, stream uintptr) int32

int pclose(FILE *stream);

func X_popen 

func X_popen(t *TLS, command, mode uintptr) uintptr

FILE *_popen( 

const char *command,
const char *mode

);

func X_putchar 

func X_putchar(t *TLS, c int32) int32

int putchar(int char)

func X_set_abort_behavior 

func X_set_abort_behavior(t *TLS, _ ...interface{}) uint32

unsigned int _set_abort_behavior( 

unsigned int flags,
unsigned int mask

);

func X_setjmp 

func X_setjmp(t *TLS, env uintptr) int32

int _setjmp(jmp_buf env);

func X_setmode 

func X_setmode(t *TLS, fd, mode int32) int32

int _setmode (int fd, int mode);

func X_snprintf 

func X_snprintf(t *TLS, str uintptr, size types.Size_t, format, args uintptr) int32

int _snprintf(char *str, size_t size, const char *format, ...);

func X_snwprintf 

func X_snwprintf(t *TLS, _ ...interface{}) int32

func X_stat64 

func X_stat64(t *TLS, path, buffer uintptr) int32

int _stat64(const char *path, struct __stat64 *buffer);

func X_stati64 

func X_stati64(t *TLS, path, buffer uintptr) int32

int _stati64( 

const char *path,
struct _stati64 *buffer

);

func X_strdup 

func X_strdup(t *TLS, s uintptr) uintptr

char *strdup(const char *s);

func X_stricmp 

func X_stricmp(t *TLS, string1, string2 uintptr) int32

int _stricmp( 

const char *string1,
const char *string2

);

func X_strnicmp 

func X_strnicmp(t *TLS, _ ...interface{}) int32
func X_unlink(t *TLS, filename uintptr) int32

int _unlink( 

const char *filename

);

func X_vsnwprintf 

func X_vsnwprintf(t *TLS, buffer uintptr, count types.Size_t, format, ap uintptr) int32

int _vsnwprintf(wchar_t *buffer, size_t count, const wchar_t *format, va_list argptr);

func X_wcsicmp 

func X_wcsicmp(t *TLS, string1, string2 uintptr) int32

int _wcsicmp( 

const wchar_t *string1,
const wchar_t *string2

);

func X_wcsnicmp 

func X_wcsnicmp(t *TLS, string1, string2 uintptr, count types.Size_t) int32

int _wcsnicmp( 

const wchar_t *string1,
const wchar_t *string2,
size_t count

);

func X_wgetenv 

func X_wgetenv(t *TLS, varname uintptr) uintptr

wchar_t *_wgetenv( 

const wchar_t *varname

);

func X_wopen 

func X_wopen(t *TLS, pathname uintptr, flags int32, args uintptr) int32

int _wopen( 

const wchar_t *filename,
int oflag [,
int pmode]

);

func X_wputenv 

func X_wputenv(t *TLS, envstring uintptr) int32

int _wputenv( 

const wchar_t *envstring

);

func X_wtoi 

func X_wtoi(t *TLS, str uintptr) int32

int _wtoi( 

const wchar_t *str

); 

func X_wunlink(t *TLS, filename uintptr) int32

int _wunlink( 

const wchar_t *filename

);

func Xabort 

func Xabort(t *TLS)

func Xabs 

func Xabs(t *TLS, j int32) int32

int abs(int j);

func Xaccept 

func Xaccept(t *TLS, sockfd uint64, addr uintptr, addrlen uintptr) uint64

func Xaccess 

func Xaccess(t *TLS, pathname uintptr, mode int32) int32

int access(const char *pathname, int mode);

func Xacos 

func Xacos(t *TLS, x float64) float64

func Xacosh 

func Xacosh(t *TLS, x float64) float64

func Xalarm 

func Xalarm(t *TLS, seconds uint32) uint32

unsigned int alarm(unsigned int seconds);

func Xasin 

func Xasin(t *TLS, x float64) float64

func Xasinh 

func Xasinh(t *TLS, x float64) float64

func Xatan 

func Xatan(t *TLS, x float64) float64

func Xatan2 

func Xatan2(t *TLS, x, y float64) float64

func Xatanh 

func Xatanh(t *TLS, x float64) float64

func Xatexit 

func Xatexit(t *TLS, function uintptr) int32

int atexit(void (*function)(void));

func Xatof 

func Xatof(t *TLS, nptr uintptr) float64

double atof(const char *nptr);

func Xatoi 

func Xatoi(t *TLS, nptr uintptr) int32

int atoi(const char *nptr);

func Xatol 

func Xatol(t *TLS, nptr uintptr) long

long atol(const char *nptr);

func Xbacktrace 

func Xbacktrace(t *TLS, buf uintptr, size int32) int32

int backtrace(void **buffer, int size);

func Xbacktrace_symbols_fd 

func Xbacktrace_symbols_fd(t *TLS, buffer uintptr, size, fd int32)

void backtrace_symbols_fd(void *const *buffer, int size, int fd);

func Xbind 

func Xbind(t *TLS, sockfd uint64, addr uintptr, addrlen int32) int32

func Xbsearch 

func Xbsearch(tls *TLS, key uintptr, base uintptr, nel size_t, width size_t, cmp uintptr) uintptr

func Xbzero 

func Xbzero(t *TLS, s uintptr, n types.Size_t)

void bzero(void *s, size_t n);

func Xcalloc 

func Xcalloc(t *TLS, n, size types.Size_t) uintptr

void *calloc(size_t nmemb, size_t size);

func Xceil 

func Xceil(t *TLS, x float64) float64

func Xceilf 

func Xceilf(t *TLS, x float32) float32

func Xcfsetispeed 

func Xcfsetispeed(t *TLS, termios_p uintptr, speed uint32) int32

int cfsetispeed(struct termios *termios_p, speed_t speed);

func Xcfsetospeed 

func Xcfsetospeed(t *TLS, termios_p uintptr, speed uint32) int32

int cfsetospeed(struct termios *termios_p, speed_t speed);

func Xchdir 

func Xchdir(t *TLS, path uintptr) int32

int chdir(const char *path);

func Xchmod 

func Xchmod(t *TLS, pathname uintptr, mode int32) int32

func Xclock_gettime 

func Xclock_gettime(t *TLS, clk_id int32, tp uintptr) int32

int clock_gettime(clockid_t clk_id, struct timespec *tp);

func Xclose 

func Xclose(t *TLS, fd int32) int32

int close(int fd);

func Xclosedir 

func Xclosedir(tls *TLS, dir uintptr) int32

func Xclosesocket 

func Xclosesocket(t *TLS, _ ...interface{}) int32

func Xconfstr 

func Xconfstr(t *TLS, name int32, buf uintptr, len types.Size_t) types.Size_t

size_t confstr(int name, char *buf, size_t len);

func Xconnect 

func Xconnect(t *TLS, sockfd uint64, addr uintptr, addrlen int32) int32

func Xcopysign 

func Xcopysign(t *TLS, x, y float64) float64

func Xcopysignf 

func Xcopysignf(t *TLS, x, y float32) float32

func Xcos 

func Xcos(t *TLS, x float64) float64

func Xcosf 

func Xcosf(t *TLS, x float32) float32

func Xcosh 

func Xcosh(t *TLS, x float64) float64

func Xdlclose 

func Xdlclose(t *TLS, handle uintptr) int32

int dlclose(void *handle);

func Xdlerror 

func Xdlerror(t *TLS) uintptr

char *dlerror(void);

func Xdlopen 

func Xdlopen(t *TLS, filename uintptr, flags int32) uintptr

void *dlopen(const char *filename, int flags);

func Xdlsym 

func Xdlsym(t *TLS, handle, symbol uintptr) uintptr

void *dlsym(void *handle, const char *symbol);

func Xdup2 

func Xdup2(t *TLS, oldfd, newfd int32) int32

int dup2(int oldfd, int newfd);

func Xexecvp 

func Xexecvp(t *TLS, file, argv uintptr) int32

int execvp(const char *file, char *const argv[]);

func Xexit 

func Xexit(t *TLS, status int32)

func Xexp 

func Xexp(t *TLS, x float64) float64

func Xfabs 

func Xfabs(t *TLS, x float64) float64

func Xfabsf 

func Xfabsf(t *TLS, x float32) float32

func Xfabsl 

func Xfabsl(t *TLS, x float64) float64

func Xfchmod 

func Xfchmod(t *TLS, fd int32, mode types.Mode_t) int32

int fchmod(int fd, mode_t mode);

func Xfclose 

func Xfclose(t *TLS, stream uintptr) int32

int fclose(FILE *stream);

func Xfcntl 

func Xfcntl(t *TLS, fd, cmd int32, args uintptr) int32

int fcntl(int fd, int cmd, ... /* arg */ );

func Xfcntl64 

func Xfcntl64(t *TLS, fd, cmd int32, args uintptr) int32

int fcntl(int fd, int cmd, ... /* arg */ );

func Xfdopen 

func Xfdopen(t *TLS, fd int32, mode uintptr) uintptr

FILE *fdopen(int fd, const char *mode);

func Xferror 

func Xferror(t *TLS, stream uintptr) int32

int ferror(FILE *stream);

func Xfflush 

func Xfflush(t *TLS, stream uintptr) int32

int fflush(FILE *stream);

func Xfgetc 

func Xfgetc(t *TLS, stream uintptr) int32

int getc(FILE *stream);

func Xfgets 

func Xfgets(t *TLS, s uintptr, size int32, stream uintptr) uintptr

char *fgets(char *s, int size, FILE *stream);

func Xfileno 

func Xfileno(t *TLS, stream uintptr) int32

int fileno(FILE *stream);

func Xfloor 

func Xfloor(t *TLS, x float64) float64

func Xfmod 

func Xfmod(t *TLS, x, y float64) float64

func Xfopen 

func Xfopen(t *TLS, pathname, mode uintptr) uintptr

FILE *fopen(const char *pathname, const char *mode);

func Xfopen64 

func Xfopen64(t *TLS, pathname, mode uintptr) uintptr

FILE *fopen64(const char *pathname, const char *mode);

func Xfork 

func Xfork(t *TLS) int32

pid_t fork(void);

func Xfprintf 

func Xfprintf(t *TLS, stream, format, args uintptr) int32

int fprintf(FILE *stream, const char *format, ...);

func Xfputc 

func Xfputc(t *TLS, c int32, stream uintptr) int32

int fputc(int c, FILE *stream);

func Xfputs 

func Xfputs(t *TLS, s, stream uintptr) int32

int fputs(const char *s, FILE *stream);

func Xfread 

func Xfread(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) types.Size_t

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

func Xfree 

func Xfree(t *TLS, p uintptr)

void free(void *ptr);

func Xfrexp 

func Xfrexp(t *TLS, x float64, exp uintptr) float64

func Xfscanf 

func Xfscanf(t *TLS, stream, format, va uintptr) int32

int fscanf(FILE *stream, const char *format, ...);

func Xfseek 

func Xfseek(t *TLS, stream uintptr, offset long, whence int32) int32

int fseek(FILE *stream, long offset, int whence);

func Xfstat 

func Xfstat(t *TLS, fd int32, statbuf uintptr) int32

int fstat(int fd, struct stat *statbuf);

func Xfstat64 

func Xfstat64(t *TLS, fd int32, statbuf uintptr) int32

int fstat(int fd, struct stat *statbuf);

func Xfsync 

func Xfsync(t *TLS, fd int32) int32

int fsync(int fd);

func Xftell 

func Xftell(t *TLS, stream uintptr) long

long ftell(FILE *stream);

func Xftruncate 

func Xftruncate(t *TLS, fd int32, length types.Off_t) int32

int ftruncate(int fd, off_t length);

func Xftruncate64 

func Xftruncate64(t *TLS, fd int32, length types.Off_t) int32

int ftruncate(int fd, off_t length);

func Xfts64_close 

func Xfts64_close(t *TLS, ftsp uintptr) int32

int fts_close(FTS *ftsp);

func Xfts64_open 

func Xfts64_open(t *TLS, path_argv uintptr, options int32, compar uintptr) uintptr

FTS *fts_open(char * const *path_argv, int options, int (*compar)(const FTSENT **, const FTSENT **));

func Xfts64_read 

func Xfts64_read(t *TLS, ftsp uintptr) uintptr

FTSENT *fts_read(FTS *ftsp);

func Xfts_close 

func Xfts_close(t *TLS, ftsp uintptr) int32

int fts_close(FTS *ftsp);

func Xfts_read 

func Xfts_read(t *TLS, ftsp uintptr) uintptr

FTSENT *fts_read(FTS *ftsp);

func Xfwrite 

func Xfwrite(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) types.Size_t

size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);

func Xgai_strerror 

func Xgai_strerror(t *TLS, errcode int32) uintptr

const char *gai_strerror(int errcode);

func Xgai_strerrorA 

func Xgai_strerrorA(t *TLS, ecode int32) uintptr

char * gai_strerrorA(int ecode);

func Xgai_strerrorW 

func Xgai_strerrorW(t *TLS, _ ...interface{}) uintptr

WCHAR * gai_strerrorW( 

int ecode

);

func Xgetc 

func Xgetc(t *TLS, stream uintptr) int32

int getc(FILE *stream);

func Xgetcwd 

func Xgetcwd(t *TLS, buf uintptr, size types.Size_t) uintptr

char *getcwd(char *buf, size_t size);

func Xgetentropy 

func Xgetentropy(t *TLS, buffer uintptr, length size_t) int32

int getentropy(void *buffer, size_t length);

The getentropy() function writes length bytes of high-quality random data to the buffer starting at the location pointed to by buffer. The maximum permitted value for the length argument is 256.

func Xgetenv 

func Xgetenv(t *TLS, name uintptr) uintptr

char *getenv(const char *name);

func Xgethostname 

func Xgethostname(t *TLS, _ ...interface{}) int32

func Xgetpeername 

func Xgetpeername(t *TLS, sockfd uint64, addr uintptr, addrlen uintptr) int32

func Xgetpid 

func Xgetpid(t *TLS) int32

pid_t getpid(void);

func Xgetpwuid 

func Xgetpwuid(t *TLS, uid uint32) uintptr

struct passwd *getpwuid(uid_t uid);

func Xgetrlimit 

func Xgetrlimit(t *TLS, resource int32, rlim uintptr) int32

int getrlimit(int resource, struct rlimit *rlim);

func Xgetrlimit64 

func Xgetrlimit64(t *TLS, resource int32, rlim uintptr) int32

int getrlimit(int resource, struct rlimit *rlim);

func Xgetrusage 

func Xgetrusage(t *TLS, who int32, usage uintptr) int32

int getrusage(int who, struct rusage *usage);

func Xgetservbyname 

func Xgetservbyname(t *TLS, _ ...interface{}) uintptr

servent * getservbyname( 

const char *name,
const char *proto

);

func Xgetsockname 

func Xgetsockname(t *TLS, sockfd uint64, addr, addrlen uintptr) int32

func Xgetsockopt 

func Xgetsockopt(t *TLS, _ ...interface{}) int32

int getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen);

func Xgettimeofday 

func Xgettimeofday(t *TLS, tv, tz uintptr) int32

int gettimeofday(struct timeval *tv, struct timezone *tz);

func Xgmtime 

func Xgmtime(t *TLS, _ ...interface{}) uintptr

func Xgmtime_r 

func Xgmtime_r(t *TLS, timep, result uintptr) uintptr

struct tm *gmtime_r(const time_t *timep, struct tm *result);

func Xhtonl 

func Xhtonl(t *TLS, hostlong uint32) uint32

uint32_t htonl(uint32_t hostlong);

func Xhtons 

func Xhtons(t *TLS, hostshort uint16) uint16

uint16_t htons(uint16_t hostshort);

func Xhypot 

func Xhypot(t *TLS, x, y float64) float64

func Xinet_ntoa 

func Xinet_ntoa(t *TLS, _ ...interface{}) uintptr

func Xioctl 

func Xioctl(t *TLS, fd int32, request ulong, va uintptr) int32

int ioctl(int fd, unsigned long request, ...);

func Xioctlsocket 

func Xioctlsocket(t *TLS, _ ...interface{}) int32

func Xisalnum 

func Xisalnum(tls *TLS, c int32) int32

func Xisalpha 

func Xisalpha(tls *TLS, c int32) int32

func Xisascii 

func Xisascii(t *TLS, c int32) int32

int isascii(int c);

func Xisatty 

func Xisatty(t *TLS, fd int32) int32

int isatty(int fd);

func Xisdigit 

func Xisdigit(tls *TLS, c int32) int32

func Xislower 

func Xislower(tls *TLS, c int32) int32

func Xisnan 

func Xisnan(t *TLS, x float64) int32

func Xisnanf 

func Xisnanf(t *TLS, x float32) int32

func Xisnanl 

func Xisnanl(t *TLS, x float64) int32

func Xisprint 

func Xisprint(tls *TLS, c int32) int32

func Xisspace 

func Xisspace(tls *TLS, c int32) int32

func Xisxdigit 

func Xisxdigit(tls *TLS, c int32) int32

func Xkill 

func Xkill(t *TLS, pid types.Pid_t, sig int32) int32

int kill(pid_t pid, int sig);

func Xldexp 

func Xldexp(t *TLS, x float64, exp int32) float64
func Xlink(t *TLS, oldpath, newpath uintptr) int32

int link(const char *oldpath, const char *newpath);

func Xlisten 

func Xlisten(t *TLS, sockfd uint64, backlog int32) int32

func Xllabs 

func Xllabs(tls *TLS, a int64) int64

func Xlocaltime 

func Xlocaltime(_ *TLS, timep uintptr) uintptr

struct tm *localtime(const time_t *timep);

func Xlocaltime_r 

func Xlocaltime_r(_ *TLS, timep, result uintptr) uintptr

struct tm *localtime_r(const time_t *timep, struct tm *result);

func Xlog 

func Xlog(t *TLS, x float64) float64

func Xlog10 

func Xlog10(t *TLS, x float64) float64

func Xlog2 

func Xlog2(t *TLS, x float64) float64

func Xlongjmp 

func Xlongjmp(t *TLS, env uintptr, val int32)

void longjmp(jmp_buf env, int val);

func Xlseek 

func Xlseek(t *TLS, fd int32, offset types.Off_t, whence int32) types.Off_t

off_t lseek(int fd, off_t offset, int whence);

func Xlseek64 

func Xlseek64(t *TLS, fd int32, offset types.Off_t, whence int32) types.Off_t

off64_t lseek64(int fd, off64_t offset, int whence);

func Xlstat 

func Xlstat(t *TLS, pathname, statbuf uintptr) int32

int lstat(const char *pathname, struct stat *statbuf);

func Xlstat64 

func Xlstat64(t *TLS, pathname, statbuf uintptr) int32

int lstat(const char *pathname, struct stat *statbuf);

func XlstrcmpiA 

func XlstrcmpiA(t *TLS, lpString1, lpString2 uintptr) int32

int lstrcmpiA( 

LPCSTR lpString1,
LPCSTR lpString2

);

func XlstrlenW 

func XlstrlenW(t *TLS, _ ...interface{}) int32

func Xmalloc 

func Xmalloc(t *TLS, n types.Size_t) uintptr

void *malloc(size_t size);

func Xmblen 

func Xmblen(t *TLS, s uintptr, n types.Size_t) int32

int mblen(const char *s, size_t n);

func Xmbstowcs 

func Xmbstowcs(t *TLS, dest, src uintptr, n types.Size_t) types.Size_t

size_t mbstowcs(wchar_t *dest, const char *src, size_t n);

func Xmbtowc 

func Xmbtowc(t *TLS, pwc, s uintptr, n types.Size_t) int32

int mbtowc(wchar_t *pwc, const char *s, size_t n);

func Xmemchr 

func Xmemchr(t *TLS, s uintptr, c int32, n types.Size_t) uintptr

void *memchr(const void *s, int c, size_t n);

func Xmemcmp 

func Xmemcmp(t *TLS, s1, s2 uintptr, n types.Size_t) int32

int memcmp(const void *s1, const void *s2, size_t n);

func Xmemcpy 

func Xmemcpy(t *TLS, dest, src uintptr, n types.Size_t) (r uintptr)

void *memcpy(void *dest, const void *src, size_t n);

func Xmemmove 

func Xmemmove(t *TLS, dest, src uintptr, n types.Size_t) uintptr

void *memmove(void *dest, const void *src, size_t n);

func Xmemset 

func Xmemset(t *TLS, s uintptr, c int32, n types.Size_t) uintptr

void *memset(void *s, int c, size_t n)

func Xmkdir 

func Xmkdir(t *TLS, path uintptr, mode types.Mode_t) int32

int mkdir(const char *path, mode_t mode);

func Xmkfifo 

func Xmkfifo(t *TLS, pathname uintptr, mode types.Mode_t) int32

int mkfifo(const char *pathname, mode_t mode);

func Xmknod 

func Xmknod(t *TLS, pathname uintptr, mode types.Mode_t, dev types.Dev_t) int32

int mknod(const char *pathname, mode_t mode, dev_t dev);

func Xmkstemp64 

func Xmkstemp64(t *TLS, template uintptr) int32

int mkstemp(char *template);

func Xmkstemps 

func Xmkstemps(t *TLS, template uintptr, suffixlen int32) int32

int mkstemps(char *template, int suffixlen);

func Xmkstemps64 

func Xmkstemps64(t *TLS, template uintptr, suffixlen int32) int32

int mkstemps(char *template, int suffixlen);

func Xmktime 

func Xmktime(t *TLS, ptm uintptr) time.Time_t

time_t mktime(struct tm *tm);

func Xmmap 

func Xmmap(t *TLS, addr uintptr, length types.Size_t, prot, flags, fd int32, offset types.Off_t) uintptr

func Xmmap64 

func Xmmap64(t *TLS, addr uintptr, length types.Size_t, prot, flags, fd int32, offset types.Off_t) uintptr

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);

func Xmodf 

func Xmodf(t *TLS, x float64, iptr uintptr) float64

func Xmremap 

func Xmremap(t *TLS, old_address uintptr, old_size, new_size types.Size_t, flags int32, args uintptr) uintptr

void *mremap(void *old_address, size_t old_size, size_t new_size, int flags, ... /* void *new_address */);

func Xmunmap 

func Xmunmap(t *TLS, addr uintptr, length types.Size_t) int32

int munmap(void *addr, size_t length);

func Xntohs 

func Xntohs(t *TLS, netshort uint16) uint16

func Xobstack_free 

func Xobstack_free(t *TLS, obstack, obj uintptr)

void obstack_free (struct obstack *h, void *obj)

func Xobstack_vprintf 

func Xobstack_vprintf(t *TLS, obstack, template, va uintptr) int32

int obstack_vprintf (struct obstack *obstack, const char *template, va_list ap)

func Xopen 

func Xopen(t *TLS, pathname uintptr, flags int32, args uintptr) int32

int open(const char *pathname, int flags, ...);

func Xopen64 

func Xopen64(t *TLS, pathname uintptr, flags int32, cmode uintptr) int32

int open(const char *pathname, int flags, ...);

func Xopendir 

func Xopendir(tls *TLS, name uintptr) uintptr

func Xopenpty 

func Xopenpty(t *TLS, amaster, aslave, name, termp, winp uintptr) int32

int openpty(int *amaster, int *aslave, char *name, 

const struct termios *termp,
const struct winsize *winp);

func Xpclose 

func Xpclose(t *TLS, stream uintptr) int32

int pclose(FILE *stream);

func Xperror 

func Xperror(t *TLS, s uintptr)

void perror(const char *s);

func Xpipe 

func Xpipe(t *TLS, pipefd uintptr) int32

int pipe(int pipefd[2]);

func Xpopen 

func Xpopen(t *TLS, command, type1 uintptr) uintptr

FILE *popen(const char *command, const char *type);

func Xpow 

func Xpow(t *TLS, x, y float64) float64

func Xprintf 

func Xprintf(t *TLS, format, args uintptr) int32

int printf(const char *format, ...);

func Xpselect 

func Xpselect(t *TLS, nfds int32, readfds, writefds, exceptfds, timeout, sigmask uintptr) int32

int pselect(int nfds, fd_set *readfds, fd_set *writefds, 

fd_set *exceptfds, const struct timespec *timeout,
const sigset_t *sigmask);

func Xpthread_attr_destroy 

func Xpthread_attr_destroy(t *TLS, pAttr uintptr) int32

int pthread_attr_destroy(pthread_attr_t *attr);

func Xpthread_attr_init 

func Xpthread_attr_init(t *TLS, pAttr uintptr) int32

int pthread_attr_init(pthread_attr_t *attr);

func Xpthread_attr_setscope 

func Xpthread_attr_setscope(t *TLS, pAttr uintptr, contentionScope int32) int32

int pthread_attr_setscope(pthread_attr_t *attr, int contentionscope);

func Xpthread_attr_setstacksize 

func Xpthread_attr_setstacksize(t *TLS, attr uintptr, stackSize types.Size_t) int32

int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);

func Xpthread_cond_broadcast 

func Xpthread_cond_broadcast(t *TLS, pCond uintptr) int32

int pthread_cond_broadcast(pthread_cond_t *cond);

func Xpthread_cond_destroy 

func Xpthread_cond_destroy(t *TLS, pCond uintptr) int32

int pthread_cond_destroy(pthread_cond_t *cond);

func Xpthread_cond_init 

func Xpthread_cond_init(t *TLS, pCond, pAttr uintptr) int32

The pthread_cond_init() function shall initialize the condition variable referenced by cond with attributes referenced by attr. If attr is NULL, the default condition variable attributes shall be used; the effect is the same as passing the address of a default condition variable attributes object. Upon successful initialization, the state of the condition variable shall become initialized.

If successful, the pthread_cond_destroy() and pthread_cond_init() functions shall return zero; otherwise, an error number shall be returned to indicate the error.

int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);

func Xpthread_cond_signal 

func Xpthread_cond_signal(t *TLS, pCond uintptr) int32

int pthread_cond_signal(pthread_cond_t *cond);

func Xpthread_cond_timedwait 

func Xpthread_cond_timedwait(t *TLS, pCond, pMutex, pAbsTime uintptr) int32

int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);

func Xpthread_cond_wait 

func Xpthread_cond_wait(t *TLS, pCond, pMutex uintptr) int32

int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);

func Xpthread_create 

func Xpthread_create(t *TLS, pThread, pAttr, startRoutine, arg uintptr) int32

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);

func Xpthread_detach 

func Xpthread_detach(t *TLS, thread pthread.Pthread_t) int32

int pthread_detach(pthread_t thread);

func Xpthread_equal 

func Xpthread_equal(t *TLS, t1, t2 pthread.Pthread_t) int32

int pthread_equal(pthread_t t1, pthread_t t2);

func Xpthread_exit 

func Xpthread_exit(t *TLS, value uintptr)

void pthread_exit(void *value_ptr);

func Xpthread_getspecific 

func Xpthread_getspecific(t *TLS, key pthread.Pthread_key_t) uintptr

void *pthread_getspecific(pthread_key_t key);

func Xpthread_join 

func Xpthread_join(t *TLS, thread pthread.Pthread_t, pValue uintptr) int32

int pthread_join(pthread_t thread, void **value_ptr);

func Xpthread_key_create 

func Xpthread_key_create(t *TLS, pKey, destructor uintptr) int32

int pthread_key_create(pthread_key_t *key, void (*destructor)(void*));

func Xpthread_key_delete 

func Xpthread_key_delete(t *TLS, key pthread.Pthread_key_t) int32

int pthread_key_delete(pthread_key_t key);

func Xpthread_mutex_destroy 

func Xpthread_mutex_destroy(t *TLS, pMutex uintptr) int32

int pthread_mutex_destroy(pthread_mutex_t *mutex);

func Xpthread_mutex_init 

func Xpthread_mutex_init(t *TLS, pMutex, pAttr uintptr) int32

The pthread_mutex_init() function shall initialize the mutex referenced by mutex with attributes specified by attr. If attr is NULL, the default mutex attributes are used; the effect shall be the same as passing the address of a default mutex attributes object. Upon successful initialization, the state of the mutex becomes initialized and unlocked.

If successful, the pthread_mutex_destroy() and pthread_mutex_init() functions shall return zero; otherwise, an error number shall be returned to indicate the error.

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);

func Xpthread_mutex_lock 

func Xpthread_mutex_lock(t *TLS, pMutex uintptr) int32

int pthread_mutex_lock(pthread_mutex_t *mutex);

func Xpthread_mutex_trylock 

func Xpthread_mutex_trylock(t *TLS, pMutex uintptr) int32

int pthread_mutex_trylock(pthread_mutex_t *mutex);

func Xpthread_mutex_unlock 

func Xpthread_mutex_unlock(t *TLS, pMutex uintptr) int32

int pthread_mutex_unlock(pthread_mutex_t *mutex);

func Xpthread_self 

func Xpthread_self(t *TLS) pthread.Pthread_t

pthread_t pthread_self(void);

func Xpthread_setspecific 

func Xpthread_setspecific(t *TLS, key pthread.Pthread_key_t, value uintptr) int32

int pthread_setspecific(pthread_key_t key, const void *value);

func Xputc 

func Xputc(t *TLS, c int32, fp uintptr) int32

int putc(int c, FILE *stream);

func Xputchar 

func Xputchar(t *TLS, c int32) int32

int putchar(int c);

func Xputenv 

func Xputenv(tls *TLS, s uintptr) int32

func Xputs 

func Xputs(t *TLS, s uintptr) int32

int puts(const char *s);

func Xqsort 

func Xqsort(t *TLS, base uintptr, nmemb, size types.Size_t, compar uintptr)

void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));

func Xraise 

func Xraise(t *TLS, sig int32) int32

int raise(int sig);

func Xrand 

func Xrand(t *TLS) int32

int rand(void);

func Xrandom 

func Xrandom(t *TLS) long

long int random(void);

func Xread 

func Xread(t *TLS, fd int32, buf uintptr, count uint32) int32

int _read( // https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/read?view=msvc-160 

int const fd,
void * const buffer,
unsigned const buffer_size

);

func Xreaddir 

func Xreaddir(tls *TLS, dir uintptr) uintptr
func Xreadlink(t *TLS, path, buf uintptr, bufsize types.Size_t) types.Ssize_t

ssize_t readlink(const char *restrict path, char *restrict buf, size_t bufsize);

func Xreadv 

func Xreadv(t *TLS, fd int32, iov uintptr, iovcnt int32) types.Ssize_t

ssize_t readv(int fd, const struct iovec *iov, int iovcnt);

func Xrealloc 

func Xrealloc(t *TLS, ptr uintptr, size types.Size_t) uintptr

void *realloc(void *ptr, size_t size);

func Xreallocarray 

func Xreallocarray(t *TLS, ptr uintptr, nmemb, size size_t) uintptr

void * reallocarray(void *ptr, size_t nmemb, size_t size);

func Xrealpath 

func Xrealpath(t *TLS, path, resolved_path uintptr) uintptr

char *realpath(const char *path, char *resolved_path);

func Xrecv 

func Xrecv(t *TLS, sockfd uint64, buf uintptr, len, flags int32) int32

func Xrename 

func Xrename(t *TLS, oldpath, newpath uintptr) int32

int rename(const char *oldpath, const char *newpath);

func Xrewind 

func Xrewind(t *TLS, stream uintptr)

void rewind(FILE *stream);

func Xrindex 

func Xrindex(t *TLS, s uintptr, c int32) uintptr

char *rindex(const char *s, int c);

func Xrint 

func Xrint(tls *TLS, x float64) float64

func Xrmdir 

func Xrmdir(t *TLS, pathname uintptr) int32

int rmdir(const char *pathname);

func Xround 

func Xround(t *TLS, x float64) float64

func Xsched_yield 

func Xsched_yield(t *TLS)

int sched_yield(void);

func Xselect 

func Xselect(t *TLS, nfds int32, readfds, writefds, exceptfds, timeout uintptr) int32

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

func Xsend 

func Xsend(t *TLS, sockfd uint64, buf uintptr, len, flags int32) int32

func Xsetbuf 

func Xsetbuf(t *TLS, stream, buf uintptr)

void setbuf(FILE *stream, char *buf);

func Xsetenv 

func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) int32

func Xsetjmp 

func Xsetjmp(t *TLS, env uintptr) int32

int setjmp(jmp_buf env);

func Xsetlocale 

func Xsetlocale(t *TLS, category int32, locale uintptr) uintptr

char *setlocale(int category, const char *locale);

func Xsetmode 

func Xsetmode(t *TLS, fd, mode int32) int32

int setmode (int fd, int mode);

func Xsetrlimit 

func Xsetrlimit(t *TLS, resource int32, rlim uintptr) int32

int setrlimit(int resource, const struct rlimit *rlim);

func Xsetrlimit64 

func Xsetrlimit64(t *TLS, resource int32, rlim uintptr) int32

int setrlimit(int resource, const struct rlimit *rlim);

func Xsetsid 

func Xsetsid(t *TLS) types.Pid_t

pid_t setsid(void);

func Xsetsockopt 

func Xsetsockopt(t *TLS, _ ...interface{}) int32

// int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);

func Xsetvbuf 

func Xsetvbuf(t *TLS, stream, buf uintptr, mode int32, size types.Size_t) int32

int setvbuf(FILE *stream, char *buf, int mode, size_t size);

func Xshutdown 

func Xshutdown(t *TLS, sockfd uint64, how int32) int32

func Xsigaction 

func Xsigaction(t *TLS, signum int32, act, oldact uintptr) int32

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

func Xsin 

func Xsin(t *TLS, x float64) float64

func Xsinf 

func Xsinf(t *TLS, x float32) float32

func Xsinh 

func Xsinh(t *TLS, x float64) float64

func Xsleep 

func Xsleep(t *TLS, seconds uint32) uint32

unsigned int sleep(unsigned int seconds);

func Xsnprintf 

func Xsnprintf(t *TLS, str uintptr, size types.Size_t, format, args uintptr) (r int32)

int snprintf(char *str, size_t size, const char *format, ...);

func Xsocket 

func Xsocket(t *TLS, domain, type1, protocol int32) uint64

func Xsprintf 

func Xsprintf(t *TLS, str, format, args uintptr) (r int32)

int sprintf(char *str, const char *format, ...);

func Xsqrt 

func Xsqrt(t *TLS, x float64) float64

func Xsscanf 

func Xsscanf(t *TLS, str, format, va uintptr) int32

int sscanf(const char *str, const char *format, ...);

func Xstat 

func Xstat(t *TLS, pathname, statbuf uintptr) int32

int stat(const char *pathname, struct stat *statbuf);

func Xstat64 

func Xstat64(t *TLS, pathname, statbuf uintptr) int32

int stat(const char *pathname, struct stat *statbuf);

func Xstrcasecmp 

func Xstrcasecmp(t *TLS, s1, s2 uintptr) int32

int strcasecmp(const char *s1, const char *s2);

func Xstrcat 

func Xstrcat(t *TLS, dest, src uintptr) (r uintptr)

char *strcat(char *dest, const char *src)

func Xstrchr 

func Xstrchr(t *TLS, s uintptr, c int32) uintptr

char *strchr(const char *s, int c)

func Xstrcmp 

func Xstrcmp(t *TLS, s1, s2 uintptr) int32

int strcmp(const char *s1, const char *s2)

func Xstrcpy 

func Xstrcpy(t *TLS, dest, src uintptr) (r uintptr)

char *strcpy(char *dest, const char *src)

func Xstrcspn 

func Xstrcspn(t *TLS, s, reject uintptr) (r types.Size_t)

size_t strcspn(const char *s, const char *reject);

func Xstrdup 

func Xstrdup(tls *TLS, s uintptr) uintptr

func Xstrerror 

func Xstrerror(t *TLS, errnum int32) uintptr

char *strerror(int errnum);

func Xstrlen 

func Xstrlen(t *TLS, s uintptr) (r types.Size_t)

size_t strlen(const char *s)

func Xstrncmp 

func Xstrncmp(t *TLS, s1, s2 uintptr, n types.Size_t) int32

int strncmp(const char *s1, const char *s2, size_t n)

func Xstrncpy 

func Xstrncpy(t *TLS, dest, src uintptr, n types.Size_t) (r uintptr)

char *strncpy(char *dest, const char *src, size_t n)

func Xstrpbrk 

func Xstrpbrk(t *TLS, s, accept uintptr) uintptr

char *strpbrk(const char *s, const char *accept);

func Xstrrchr 

func Xstrrchr(t *TLS, s uintptr, c int32) (r uintptr)

char *strrchr(const char *s, int c)

func Xstrstr 

func Xstrstr(t *TLS, haystack, needle uintptr) uintptr

char *strstr(const char *haystack, const char *needle);

func Xstrtod 

func Xstrtod(tls *TLS, s uintptr, p uintptr) float64

func Xstrtol 

func Xstrtol(t *TLS, nptr, endptr uintptr, base int32) long

long strtol(const char *nptr, char **endptr, int base);

func Xstrtoul 

func Xstrtoul(t *TLS, nptr, endptr uintptr, base int32) ulong

unsigned long int strtoul(const char *nptr, char **endptr, int base); 

func Xsymlink(t *TLS, target, linkpath uintptr) int32

int symlink(const char *target, const char *linkpath);

func Xsysconf 

func Xsysconf(t *TLS, name int32) long

long sysconf(int name);

func Xsystem 

func Xsystem(t *TLS, command uintptr) int32

int system(const char *command);

func Xtan 

func Xtan(t *TLS, x float64) float64

func Xtanh 

func Xtanh(t *TLS, x float64) float64

func Xtcgetattr 

func Xtcgetattr(t *TLS, fd int32, termios_p uintptr) int32

int tcgetattr(int fd, struct termios *termios_p);

func Xtcsendbreak 

func Xtcsendbreak(t *TLS, fd, duration int32) int32

int tcsendbreak(int fd, int duration);

func Xtcsetattr 

func Xtcsetattr(t *TLS, fd, optional_actions int32, termios_p uintptr) int32

int tcsetattr(int fd, int optional_actions, const struct termios *termios_p);

func Xtime 

func Xtime(t *TLS, tloc uintptr) types.Time_t

time_t time(time_t *tloc);

func Xtolower 

func Xtolower(t *TLS, c int32) int32

int tolower(int c);

func Xtoupper 

func Xtoupper(t *TLS, c int32) int32

int toupper(int c);

func Xtrunc 

func Xtrunc(t *TLS, x float64) float64

func Xtzset 

func Xtzset(t *TLS)

void tzset (void);

func Xumask 

func Xumask(t *TLS, mask types.Mode_t) types.Mode_t

mode_t umask(mode_t mask);

func Xuname 

func Xuname(t *TLS, buf uintptr) int32

int uname(struct utsname *buf);

func Xungetc 

func Xungetc(t *TLS, c int32, stream uintptr) int32

int ungetc(int c, FILE *stream); 

func Xunlink(t *TLS, pathname uintptr) int32

int unlink(const char *pathname);

func Xunsetenv 

func Xunsetenv(tls *TLS, name uintptr) int32

func Xusleep 

func Xusleep(t *TLS, usec types.Useconds_t) int32

int usleep(useconds_t usec);

func Xutime 

func Xutime(t *TLS, filename, times uintptr) int32

int utime(const char *filename, const struct utimbuf *times);

func Xutimes 

func Xutimes(t *TLS, filename, times uintptr) int32

int utimes(const char *filename, const struct timeval times[2]);

func Xvasprintf 

func Xvasprintf(t *TLS, strp, fmt, ap uintptr) int32

int vasprintf(char **strp, const char *fmt, va_list ap);

func Xvfprintf 

func Xvfprintf(t *TLS, stream, format, ap uintptr) int32

func Xvprintf 

func Xvprintf(t *TLS, s, ap uintptr) int32

int vprintf(const char *format, va_list ap);

func Xvsnprintf 

func Xvsnprintf(t *TLS, str uintptr, size types.Size_t, format, va uintptr) int32

int vsnprintf(char *str, size_t size, const char *format, va_list ap);

func Xvsprintf 

func Xvsprintf(t *TLS, str, format, va uintptr) int32

int vsprintf(char *str, const char *format, va_list ap);

func Xwaitpid 

func Xwaitpid(t *TLS, pid types.Pid_t, wstatus uintptr, optname int32) types.Pid_t

pid_t waitpid(pid_t pid, int *wstatus, int options);

func Xwcrtomb 

func Xwcrtomb(tls *TLS, s uintptr, wc wchar_t, st uintptr) size_t

func Xwcschr 

func Xwcschr(t *TLS, str uintptr, c wchar_t) uintptr

wchar_t *wcschr( 

const wchar_t *str,
wchar_t c

);

func Xwcscmp 

func Xwcscmp(t *TLS, string1, string2 uintptr) int32

int wcscmp( 

const wchar_t *string1,
const wchar_t *string2

);

func Xwcscpy 

func Xwcscpy(t *TLS, strDestination, strSource uintptr) uintptr

wchar_t *wcscpy( 

wchar_t *strDestination,
const wchar_t *strSource

);

func Xwcsicmp 

func Xwcsicmp(t *TLS, string1, string2 uintptr) int32

int _wcsicmp( 

const wchar_t *string1,
const wchar_t *string2

);

func Xwcslen 

func Xwcslen(t *TLS, str uintptr) types.Size_t

size_t wcslen( 

const wchar_t *str

);

func Xwcsncmp 

func Xwcsncmp(t *TLS, string1, string2 uintptr, count types.Size_t) int32

int wcsncmp( 

const wchar_t *string1,
const wchar_t *string2,
size_t count

);

func Xwcsrtombs 

func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n size_t, st uintptr) size_t

func Xwcstombs 

func Xwcstombs(tls *TLS, s uintptr, ws uintptr, n size_t) size_t

func Xwctomb 

func Xwctomb(t *TLS, s uintptr, wc wchar_t) int32

int wctomb(char *s, wchar_t wc);

func Xwcwidth 

func Xwcwidth(t *TLS, c wchar_t) int32

int wcwidth(wchar_t c);

func Xwrite 

func Xwrite(t *TLS, fd int32, buf uintptr, count uint32) int32

int _write( // https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/write?view=msvc-160 

int fd,
const void *buffer,
unsigned int count

);

func XwsprintfA 

func XwsprintfA(t *TLS, buf, format, args uintptr) int32

int WINAPIV wsprintfA( 

LPSTR  ,
LPCSTR ,
...

);

func XwsprintfW 

func XwsprintfW(t *TLS, _ ...interface{}) int32

Types

type Int128 

type Int128 mathutil.Int128

func Int128FromFloat32 

func Int128FromFloat32(n float32) Int128

func Int128FromFloat64 

func Int128FromFloat64(n float64) Int128

func Int128FromInt16 

func Int128FromInt16(n int16) Int128

func Int128FromInt32 

func Int128FromInt32(n int32) Int128

func Int128FromInt64 

func Int128FromInt64(n int64) Int128

func Int128FromInt8 

func Int128FromInt8(n int8) Int128

func Int128FromUint128 

func Int128FromUint128(n Uint128) Int128

func Int128FromUint16 

func Int128FromUint16(n uint16) Int128

func Int128FromUint32 

func Int128FromUint32(n uint32) Int128

func Int128FromUint64 

func Int128FromUint64(n uint64) Int128

func Int128FromUint8 

func Int128FromUint8(n uint8) Int128

func (Int128) Add 

func (n Int128) Add(m Int128) (r Int128)

func (Int128) And 

func (n Int128) And(v Int128) Int128

func (Int128) Cmp 

func (n Int128) Cmp(y Int128) int

func (Int128) Float32 

func (n Int128) Float32() float32

func (Int128) Float64 

func (n Int128) Float64() float64

func (Int128) Int16 

func (n Int128) Int16() int16

func (Int128) Int32 

func (n Int128) Int32() int32

func (Int128) Int64 

func (n Int128) Int64() int64

func (Int128) Int8 

func (n Int128) Int8() int8

func (*Int128) LValueDec 

func (n *Int128) LValueDec()

func (*Int128) LValueInc 

func (n *Int128) LValueInc()

func (*Int128) LValueShl 

func (n *Int128) LValueShl(c int32)

func (*Int128) LValueShr 

func (n *Int128) LValueShr(c int32)

func (Int128) Mul 

func (n Int128) Mul(m Int128) Int128

func (Int128) Neg 

func (n Int128) Neg() Int128

func (Int128) Or 

func (n Int128) Or(v Int128) Int128

func (Int128) Shl 

func (n Int128) Shl(c int32) (r Int128)

func (Int128) Shr 

func (n Int128) Shr(c int32) (r Int128)

func (Int128) Uint128 

func (n Int128) Uint128() (r Uint128)

func (Int128) Uint16 

func (n Int128) Uint16() uint16

func (Int128) Uint32 

func (n Int128) Uint32() uint32

func (Int128) Uint64 

func (n Int128) Uint64() uint64

func (Int128) Uint8 

func (n Int128) Uint8() uint8

func (Int128) Xor 

func (n Int128) Xor(v Int128) Int128

type PerfCounter 

type PerfCounter struct {
	// contains filtered or unexported fields
}

func NewPerfCounter 

func NewPerfCounter(labels []string) *PerfCounter

func (*PerfCounter) Clear 

func (c *PerfCounter) Clear()

func (*PerfCounter) Disable 

func (c *PerfCounter) Disable()

func (*PerfCounter) Enable 

func (c *PerfCounter) Enable()

func (*PerfCounter) Inc 

func (c *PerfCounter) Inc(n int)

func (*PerfCounter) IncN 

func (c *PerfCounter) IncN(n, m int)

func (*PerfCounter) String 

func (c *PerfCounter) String() string

type RawMem 

type RawMem [1<<50 - 1]byte

RawMem represents the biggest byte array the runtime can handle

type RawMem64 

type RawMem64 [unsafe.Sizeof(RawMem{}) / unsafe.Sizeof(uint64(0))]uint64

RawMem64 represents the biggest uint64 array the runtime can handle.

type StackCapture 

type StackCapture struct {
	sync.Mutex
	// contains filtered or unexported fields
}

func NewStackCapture 

func NewStackCapture(depth int) *StackCapture

func (*StackCapture) Clear 

func (c *StackCapture) Clear()

func (*StackCapture) Disable 

func (c *StackCapture) Disable()

func (*StackCapture) Enable 

func (c *StackCapture) Enable()

func (*StackCapture) Record 

func (c *StackCapture) Record()

func (*StackCapture) String 

func (c *StackCapture) String() string

type TLS 

type TLS struct {
	ID int32
	// contains filtered or unexported fields
}

Thread local storage.

func NewTLS 

func NewTLS() *TLS

func (*TLS) Alloc 

func (t *TLS) Alloc(n int) (r uintptr)

Alloc allocates n bytes of thread-local storage. It must be paired with a call to t.Free(n), using the same n. The order matters. This is ok: 

t.Alloc(11)
	t.Alloc(22)
	t.Free(22)
t.Free(11)

This is not correct: 

t.Alloc(11)
	t.Alloc(22)
	t.Free(11)
t.Free(22)

func (*TLS) Close 

func (t *TLS) Close()

Close frees the resources of t.

func (*TLS) Free 

func (t *TLS) Free(n int)

Free deallocates n bytes of thread-local storage. See TLS.Alloc for details on correct usage.

type ThreadAdapter 

type ThreadAdapter struct {
	// contains filtered or unexported fields
}

type Uint128 

type Uint128 mathutil.Uint128

func Uint128FromFloat32 

func Uint128FromFloat32(n float32) Uint128

func Uint128FromFloat64 

func Uint128FromFloat64(n float64) Uint128

func Uint128FromInt128 

func Uint128FromInt128(n Int128) Uint128

func Uint128FromInt16 

func Uint128FromInt16(n int16) Uint128

func Uint128FromInt32 

func Uint128FromInt32(n int32) Uint128

func Uint128FromInt64 

func Uint128FromInt64(n int64) (r Uint128)

func Uint128FromInt8 

func Uint128FromInt8(n int8) Uint128

func Uint128FromUint16 

func Uint128FromUint16(n uint16) Uint128

func Uint128FromUint32 

func Uint128FromUint32(n uint32) Uint128

func Uint128FromUint64 

func Uint128FromUint64(n uint64) Uint128

func Uint128FromUint8 

func Uint128FromUint8(n uint8) Uint128

func (Uint128) Add 

func (n Uint128) Add(m Uint128) (r Uint128)

func (Uint128) And 

func (n Uint128) And(m Uint128) Uint128

func (Uint128) Cmp 

func (n Uint128) Cmp(m Uint128) int

func (Uint128) Div 

func (n Uint128) Div(m Uint128) (r Uint128)

func (Uint128) Float32 

func (n Uint128) Float32() float32

func (Uint128) Float64 

func (n Uint128) Float64() float64

func (Uint128) Int128 

func (n Uint128) Int128() Int128

func (Uint128) Int16 

func (n Uint128) Int16() int16

func (Uint128) Int32 

func (n Uint128) Int32() int32

func (Uint128) Int64 

func (n Uint128) Int64() int64

func (Uint128) Int8 

func (n Uint128) Int8() int8

func (*Uint128) LValueShl 

func (n *Uint128) LValueShl(c int32)

func (*Uint128) LValueShr 

func (n *Uint128) LValueShr(c int32)

func (Uint128) Mul 

func (n Uint128) Mul(m Uint128) Uint128

func (Uint128) Or 

func (n Uint128) Or(m Uint128) Uint128

func (Uint128) Shl 

func (n Uint128) Shl(c int32) (r Uint128)

func (Uint128) Shr 

func (n Uint128) Shr(c int32) (r Uint128)

func (Uint128) Sub 

func (n Uint128) Sub(m Uint128) Uint128

func (Uint128) Uint16 

func (n Uint128) Uint16() uint16

func (Uint128) Uint32 

func (n Uint128) Uint32() uint32

func (Uint128) Uint64 

func (n Uint128) Uint64() uint64

func (Uint128) Uint8 

func (n Uint128) Uint8() uint8

func (Uint128) Xor 

func (n Uint128) Xor(m Uint128) Uint128

Source Files

View all Source files

Directories

Path Synopsis
honnef.co
go/netdb
Package netdb provides a Go interface for the protoent and servent structures as defined in netdb.h
 Package netdb provides a Go interface for the protoent and servent structures as defined in netdb.h
netinet
in
sys
random
socket
stat
types
vfs

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.