GoToSocial/vendor/modernc.org/libc/libc_windows.go

// Copyright 2020 The Libc Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package libc // import "modernc.org/libc"

import (
	"errors"
	"fmt"
	"math"
	"os"
	"os/exec"
	"os/user"
	"path/filepath"
	"strings"
	"sync"
	"sync/atomic"
	"syscall"
	gotime "time"
	"unicode"
	"unicode/utf16"
	"unsafe"

	"modernc.org/libc/errno"
	"modernc.org/libc/fcntl"
	"modernc.org/libc/limits"
	"modernc.org/libc/stdio"
	"modernc.org/libc/sys/stat"
	"modernc.org/libc/sys/types"
	"modernc.org/libc/time"
	"modernc.org/libc/unistd"
)

// Keep these outside of the var block otherwise go generate will miss them.
var X__imp__environ = EnvironP()
var X__imp__wenviron = uintptr(unsafe.Pointer(&wenviron))
var X_imp___environ = EnvironP()
var X_iob [stdio.X_IOB_ENTRIES]stdio.FILE

var Xtimezone long // extern long timezone;

var (
	iobMap     = map[uintptr]int32{} // &_iob[fd] -> fd
	wenvValid  bool
	wenviron   uintptr // &winEnviron[0]
	winEnviron = []uintptr{0}
)

func init() {
	for i := range X_iob {
		iobMap[uintptr(unsafe.Pointer(&X_iob[i]))] = int32(i)
	}
}

func winGetObject(stream uintptr) interface{} {
	if fd, ok := iobMap[stream]; ok {
		f, _ := fdToFile(fd)
		return f
	}

	return getObject(stream)
}

type (
	long  = int32
	ulong = uint32
)

var (
	modkernel32 = syscall.NewLazyDLL("kernel32.dll")
	//--
	procAreFileApisANSI            = modkernel32.NewProc("AreFileApisANSI")
	procCopyFileW                  = modkernel32.NewProc("CopyFileW")
	procCreateEventA               = modkernel32.NewProc("CreateEventA")
	procCreateEventW               = modkernel32.NewProc("CreateEventW")
	procCreateFileA                = modkernel32.NewProc("CreateFileA")
	procCreateFileMappingW         = modkernel32.NewProc("CreateFileMappingW")
	procCreateFileW                = modkernel32.NewProc("CreateFileW")
	procCreateHardLinkW            = modkernel32.NewProc("CreateHardLinkW")
	procCreatePipe                 = modkernel32.NewProc("CreatePipe")
	procCreateProcessA             = modkernel32.NewProc("CreateProcessA")
	procCreateProcessW             = modkernel32.NewProc("CreateProcessW")
	procCreateThread               = modkernel32.NewProc("CreateThread")
	procDeleteCriticalSection      = modkernel32.NewProc("DeleteCriticalSection")
	procDeviceIoControl            = modkernel32.NewProc("DeviceIoControl")
	procDuplicateHandle            = modkernel32.NewProc("DuplicateHandle")
	procEnterCriticalSection       = modkernel32.NewProc("EnterCriticalSection")
	procFindClose                  = modkernel32.NewProc("FindClose")
	procFindFirstFileExW           = modkernel32.NewProc("FindFirstFileExW")
	procFindFirstFileW             = modkernel32.NewProc("FindFirstFileW")
	procFindNextFileW              = modkernel32.NewProc("FindNextFileW")
	procFormatMessageW             = modkernel32.NewProc("FormatMessageW")
	procGetACP                     = modkernel32.NewProc("GetACP")
	procGetCommState               = modkernel32.NewProc("GetCommState")
	procGetComputerNameExW         = modkernel32.NewProc("GetComputerNameExW")
	procGetConsoleCP               = modkernel32.NewProc("GetConsoleCP")
	procGetConsoleScreenBufferInfo = modkernel32.NewProc("GetConsoleScreenBufferInfo")
	procGetCurrentProcess          = modkernel32.NewProc("GetCurrentProcess")
	procGetCurrentProcessId        = modkernel32.NewProc("GetCurrentProcessId")
	procGetCurrentThread           = modkernel32.NewProc("GetCurrentThread")
	procGetCurrentThreadId         = modkernel32.NewProc("GetCurrentThreadId")
	procGetEnvironmentVariableA    = modkernel32.NewProc("GetEnvironmentVariableA")
	procGetEnvironmentVariableW    = modkernel32.NewProc("GetEnvironmentVariableW")
	procGetExitCodeProcess         = modkernel32.NewProc("GetExitCodeProcess")
	procGetExitCodeThread          = modkernel32.NewProc("GetExitCodeThread")
	procGetFileAttributesA         = modkernel32.NewProc("GetFileAttributesA")
	procGetFileAttributesExA       = modkernel32.NewProc("GetFileAttributesExA")
	procGetFileAttributesExW       = modkernel32.NewProc("GetFileAttributesExW")
	procGetFileInformationByHandle = modkernel32.NewProc("GetFileInformationByHandle")
	procGetFileSize                = modkernel32.NewProc("GetFileSize")
	procGetFullPathNameW           = modkernel32.NewProc("GetFullPathNameW")
	procGetLastError               = modkernel32.NewProc("GetLastError")
	procGetLogicalDriveStringsA    = modkernel32.NewProc("GetLogicalDriveStringsA")
	procGetModuleFileNameW         = modkernel32.NewProc("GetModuleFileNameW")
	procGetModuleHandleA           = modkernel32.NewProc("GetModuleHandleA")
	procGetModuleHandleW           = modkernel32.NewProc("GetModuleHandleW")
	procGetPrivateProfileStringA   = modkernel32.NewProc("GetPrivateProfileStringA")
	procGetProcAddress             = modkernel32.NewProc("GetProcAddress")
	procGetProcessHeap             = modkernel32.NewProc("GetProcessHeap")
	procGetSystemInfo              = modkernel32.NewProc("GetSystemInfo")
	procGetSystemTime              = modkernel32.NewProc("GetSystemTime")
	procGetSystemTimeAsFileTime    = modkernel32.NewProc("GetSystemTimeAsFileTime")
	procGetTempFileNameW           = modkernel32.NewProc("GetTempFileNameW")
	procGetTickCount               = modkernel32.NewProc("GetTickCount")
	procGetVersionExA              = modkernel32.NewProc("GetVersionExA")
	procGetVersionExW              = modkernel32.NewProc("GetVersionExW")
	procGetVolumeInformationA      = modkernel32.NewProc("GetVolumeInformationA")
	procGetVolumeInformationW      = modkernel32.NewProc("GetVolumeInformationW")
	procHeapAlloc                  = modkernel32.NewProc("HeapAlloc")
	procHeapFree                   = modkernel32.NewProc("HeapFree")
	procInitializeCriticalSection  = modkernel32.NewProc("InitializeCriticalSection")
	procLeaveCriticalSection       = modkernel32.NewProc("LeaveCriticalSection")
	procLockFile                   = modkernel32.NewProc("LockFile")
	procLockFileEx                 = modkernel32.NewProc("LockFileEx")
	procLstrlenW                   = modkernel32.NewProc("lstrlenW")
	procMapViewOfFile              = modkernel32.NewProc("MapViewOfFile")
	procMoveFileW                  = modkernel32.NewProc("MoveFileW")
	procMultiByteToWideChar        = modkernel32.NewProc("MultiByteToWideChar")
	procOpenEventA                 = modkernel32.NewProc("OpenEventA")
	procPeekConsoleInputW          = modkernel32.NewProc("PeekConsoleInputW")
	procPeekNamedPipe              = modkernel32.NewProc("PeekNamedPipe")
	procQueryPerformanceCounter    = modkernel32.NewProc("QueryPerformanceCounter")
	procQueryPerformanceFrequency  = modkernel32.NewProc("QueryPerformanceFrequency")
	procReadConsoleW               = modkernel32.NewProc("ReadConsoleW")
	procReadFile                   = modkernel32.NewProc("ReadFile")
	procResetEvent                 = modkernel32.NewProc("ResetEvent")
	procSearchPathW                = modkernel32.NewProc("SearchPathW")
	procSetConsoleCtrlHandler      = modkernel32.NewProc("SetConsoleCtrlHandler")
	procSetConsoleMode             = modkernel32.NewProc("SetConsoleMode")
	procSetConsoleTextAttribute    = modkernel32.NewProc("SetConsoleTextAttribute")
	procSetEvent                   = modkernel32.NewProc("SetEvent")
	procSetFilePointer             = modkernel32.NewProc("SetFilePointer")
	procSleepEx                    = modkernel32.NewProc("SleepEx")
	procSystemTimeToFileTime       = modkernel32.NewProc("SystemTimeToFileTime")
	procTerminateThread            = modkernel32.NewProc("TerminateThread")
	procUnlockFile                 = modkernel32.NewProc("UnlockFile")
	procUnlockFileEx               = modkernel32.NewProc("UnlockFileEx")
	procWaitForSingleObjectEx      = modkernel32.NewProc("WaitForSingleObjectEx")
	procWideCharToMultiByte        = modkernel32.NewProc("WideCharToMultiByte")
	procWriteConsoleA              = modkernel32.NewProc("WriteConsoleA")
	procWriteConsoleW              = modkernel32.NewProc("WriteConsoleW")
	procWriteFile                  = modkernel32.NewProc("WriteFile")

	//	procSetConsoleCP               = modkernel32.NewProc("SetConsoleCP")
	//	procSetThreadPriority          = modkernel32.NewProc("SetThreadPriority")
	//--

	modadvapi = syscall.NewLazyDLL("advapi32.dll")
	//--
	procAccessCheck                = modadvapi.NewProc("AccessCheck")
	procGetAclInformation          = modadvapi.NewProc("GetAclInformation")
	procGetFileSecurityA           = modadvapi.NewProc("GetFileSecurityA")
	procGetFileSecurityW           = modadvapi.NewProc("GetFileSecurityW")
	procGetSecurityDescriptorDacl  = modadvapi.NewProc("GetSecurityDescriptorDacl")
	procGetSecurityDescriptorOwner = modadvapi.NewProc("GetSecurityDescriptorOwner")
	procGetSidIdentifierAuthority  = modadvapi.NewProc("GetSidIdentifierAuthority")
	procGetSidLengthRequired       = modadvapi.NewProc("GetSidLengthRequired")
	procGetSidSubAuthority         = modadvapi.NewProc("GetSidSubAuthority")
	procImpersonateSelf            = modadvapi.NewProc("ImpersonateSelf")
	procInitializeSid              = modadvapi.NewProc("InitializeSid")
	procOpenThreadToken            = modadvapi.NewProc("OpenThreadToken")
	procRevertToSelf               = modadvapi.NewProc("RevertToSelf")
	//--

	modws2_32 = syscall.NewLazyDLL("ws2_32.dll")
	//--
	procWSAStartup = modws2_32.NewProc("WSAStartup")
	//--

	moduser32 = syscall.NewLazyDLL("user32.dll")
	//--
	procCreateWindowExW             = moduser32.NewProc("CreateWindowExW")
	procMsgWaitForMultipleObjectsEx = moduser32.NewProc("MsgWaitForMultipleObjectsEx")
	procPeekMessageW                = moduser32.NewProc("PeekMessageW")
	procRegisterClassW              = moduser32.NewProc("RegisterClassW")
	procUnregisterClassW            = moduser32.NewProc("UnregisterClassW")
	procWaitForInputIdle            = moduser32.NewProc("WaitForInputIdle")
	//--

	netapi             = syscall.NewLazyDLL("netapi32.dll")
	procNetGetDCName   = netapi.NewProc("NetGetDCName")
	procNetUserGetInfo = netapi.NewProc("NetUserGetInfo")

	userenvapi                = syscall.NewLazyDLL("userenv.dll")
	procGetProfilesDirectoryW = userenvapi.NewProc("GetProfilesDirectoryW")
)

var (
	threadCallback uintptr
)

func init() {
	isWindows = true
	threadCallback = syscall.NewCallback(ThreadProc)
}

// ---------------------------------
// Windows filehandle-to-fd mapping
// so the lib-c interface contract looks
// like normal fds being passed around
// but we're mapping them back and forth to
// native windows file handles (syscall.Handle)
//

var EBADF = errors.New("EBADF")

var w_nextFd int32 = 42
var w_fdLock sync.Mutex
var w_fd_to_file = map[int32]*file{}

type file struct {
	_fd    int32
	hadErr bool
	t      uintptr
	syscall.Handle
}

func addFile(hdl syscall.Handle, fd int32) uintptr {
	var f = file{_fd: fd, Handle: hdl}
	w_fdLock.Lock()
	defer w_fdLock.Unlock()
	w_fd_to_file[fd] = &f
	f.t = addObject(&f)
	return f.t
}

func remFile(f *file) {
	removeObject(f.t)
	w_fdLock.Lock()
	defer w_fdLock.Unlock()
	delete(w_fd_to_file, f._fd)
}

func fdToFile(fd int32) (*file, bool) {
	w_fdLock.Lock()
	defer w_fdLock.Unlock()
	f, ok := w_fd_to_file[fd]
	return f, ok
}

// Wrap the windows handle up tied to a unique fd
func wrapFdHandle(hdl syscall.Handle) (uintptr, int32) {
	newFd := atomic.AddInt32(&w_nextFd, 1)
	return addFile(hdl, newFd), newFd
}

func (f *file) err() bool {
	return f.hadErr
}

func (f *file) setErr() {
	f.hadErr = true
}

// -----------------------------------
// On windows we have to fetch these
//
// stdout, stdin, sterr
//
// Using the windows specific GetStdHandle
// they're mapped to the standard fds (0,1,2)
// Note: it's possible they don't exist
// if the app has been built for a GUI only
// target in windows. If that's the case
// panic seems like the only reasonable option
// ------------------------------

func newFile(t *TLS, fd int32) uintptr {

	if fd == unistd.STDIN_FILENO {
		h, err := syscall.GetStdHandle(syscall.STD_INPUT_HANDLE)
		if err != nil {
			panic("no console")
		}
		return addFile(h, fd)
	}
	if fd == unistd.STDOUT_FILENO {
		h, err := syscall.GetStdHandle(syscall.STD_OUTPUT_HANDLE)
		if err != nil {
			panic("no console")
		}
		return addFile(h, fd)
	}
	if fd == unistd.STDERR_FILENO {
		h, err := syscall.GetStdHandle(syscall.STD_ERROR_HANDLE)
		if err != nil {
			panic("no console")
		}
		return addFile(h, fd)
	}

	// should not get here -- unless newFile
	// is being used from somewhere we don't know about
	// to originate fds.

	panic("unknown fd source")
	return 0
}

func (f *file) close(t *TLS) int32 {
	remFile(f)
	err := syscall.Close(f.Handle)
	if err != nil {
		return (-1) // EOF
	}
	return 0
}

func fwrite(fd int32, b []byte) (int, error) {
	if fd == unistd.STDOUT_FILENO {
		return write(b)
	}

	f, ok := fdToFile(fd)
	if !ok {
		return -1, EBADF
	}

	if dmesgs {
		dmesg("%v: fd %v: %s", origin(1), fd, b)
	}
	return syscall.Write(f.Handle, b)
}

// int fprintf(FILE *stream, const char *format, ...);
func Xfprintf(t *TLS, stream, format, args uintptr) int32 {
	f, ok := winGetObject(stream).(*file)
	if !ok {
		t.setErrno(errno.EBADF)
		return -1
	}

	n, _ := fwrite(f._fd, printf(format, args))
	return int32(n)
}

// int usleep(useconds_t usec);
func Xusleep(t *TLS, usec types.Useconds_t) int32 {
	gotime.Sleep(gotime.Microsecond * gotime.Duration(usec))
	return 0
}

// int getrusage(int who, struct rusage *usage);
func Xgetrusage(t *TLS, who int32, usage uintptr) int32 {
	panic(todo(""))
	// if _, _, err := unix.Syscall(unix.SYS_GETRUSAGE, uintptr(who), usage, 0); err != 0 {
	// 	t.setErrno(err)
	// 	return -1
	// }

	// return 0
}

// int lstat(const char *pathname, struct stat *statbuf);
func Xlstat(t *TLS, pathname, statbuf uintptr) int32 {
	return Xlstat64(t, pathname, statbuf)
}

// int stat(const char *pathname, struct stat *statbuf);
func Xstat(t *TLS, pathname, statbuf uintptr) int32 {
	return Xstat64(t, pathname, statbuf)
}

// int chdir(const char *path);
func Xchdir(t *TLS, path uintptr) int32 {
	err := syscall.Chdir(GoString(path))
	if err != nil {
		t.setErrno(err)
		return -1
	}

	if dmesgs {
		dmesg("%v: %q: ok", origin(1), GoString(path))
	}
	return 0
}

var localtime time.Tm

// struct tm *localtime(const time_t *timep);
func Xlocaltime(_ *TLS, timep uintptr) uintptr {
	loc := getLocalLocation()
	ut := *(*time.Time_t)(unsafe.Pointer(timep))
	t := gotime.Unix(int64(ut), 0).In(loc)
	localtime.Ftm_sec = int32(t.Second())
	localtime.Ftm_min = int32(t.Minute())
	localtime.Ftm_hour = int32(t.Hour())
	localtime.Ftm_mday = int32(t.Day())
	localtime.Ftm_mon = int32(t.Month() - 1)
	localtime.Ftm_year = int32(t.Year() - 1900)
	localtime.Ftm_wday = int32(t.Weekday())
	localtime.Ftm_yday = int32(t.YearDay())
	localtime.Ftm_isdst = Bool32(isTimeDST(t))
	return uintptr(unsafe.Pointer(&localtime))
}

// struct tm *localtime(const time_t *timep);
func X_localtime64(_ *TLS, timep uintptr) uintptr {
	return Xlocaltime(nil, timep)
}

// struct tm *localtime_r(const time_t *timep, struct tm *result);
func Xlocaltime_r(_ *TLS, timep, result uintptr) uintptr {
	panic(todo(""))
	// loc := getLocalLocation()
	// ut := *(*unix.Time_t)(unsafe.Pointer(timep))
	// t := gotime.Unix(int64(ut), 0).In(loc)
	// (*time.Tm)(unsafe.Pointer(result)).Ftm_sec = int32(t.Second())
	// (*time.Tm)(unsafe.Pointer(result)).Ftm_min = int32(t.Minute())
	// (*time.Tm)(unsafe.Pointer(result)).Ftm_hour = int32(t.Hour())
	// (*time.Tm)(unsafe.Pointer(result)).Ftm_mday = int32(t.Day())
	// (*time.Tm)(unsafe.Pointer(result)).Ftm_mon = int32(t.Month() - 1)
	// (*time.Tm)(unsafe.Pointer(result)).Ftm_year = int32(t.Year() - 1900)
	// (*time.Tm)(unsafe.Pointer(result)).Ftm_wday = int32(t.Weekday())
	// (*time.Tm)(unsafe.Pointer(result)).Ftm_yday = int32(t.YearDay())
	// (*time.Tm)(unsafe.Pointer(result)).Ftm_isdst = Bool32(isTimeDST(t))
	// return result
}

// int _wopen(
//
//	const wchar_t *filename,
//	int oflag [,
//	int pmode]
//
// );
func X_wopen(t *TLS, pathname uintptr, flags int32, args uintptr) int32 {
	var mode types.Mode_t
	if args != 0 {
		mode = *(*types.Mode_t)(unsafe.Pointer(args))
	}
	s := goWideString(pathname)
	h, err := syscall.Open(GoString(pathname), int(flags), uint32(mode))
	if err != nil {
		if dmesgs {
			dmesg("%v: %q %#x: %v", origin(1), s, flags, err)
		}

		t.setErrno(err)
		return 0
	}

	_, n := wrapFdHandle(h)
	if dmesgs {
		dmesg("%v: %q flags %#x mode %#o: fd %v", origin(1), s, flags, mode, n)
	}
	return n
}

// int open(const char *pathname, int flags, ...);
func Xopen(t *TLS, pathname uintptr, flags int32, args uintptr) int32 {
	return Xopen64(t, pathname, flags, args)
}

// int open(const char *pathname, int flags, ...);
func Xopen64(t *TLS, pathname uintptr, flags int32, cmode uintptr) int32 {

	var mode types.Mode_t
	if cmode != 0 {
		mode = (types.Mode_t)(VaUint32(&cmode))
	}
	// 	fdcwd := fcntl.AT_FDCWD
	h, err := syscall.Open(GoString(pathname), int(flags), uint32(mode))
	if err != nil {

		if dmesgs {
			dmesg("%v: %q %#x: %v", origin(1), GoString(pathname), flags, err)
		}

		t.setErrno(err)
		return -1
	}

	_, n := wrapFdHandle(h)
	if dmesgs {
		dmesg("%v: %q flags %#x mode %#o: fd %v", origin(1), GoString(pathname), flags, mode, n)
	}
	return n
}

// off_t lseek(int fd, off_t offset, int whence);
func Xlseek(t *TLS, fd int32, offset types.Off_t, whence int32) types.Off_t {
	return types.Off_t(Xlseek64(t, fd, offset, whence))
}

func whenceStr(whence int32) string {
	switch whence {
	case syscall.FILE_CURRENT:
		return "SEEK_CUR"
	case syscall.FILE_END:
		return "SEEK_END"
	case syscall.FILE_BEGIN:
		return "SEEK_SET"
	default:
		return fmt.Sprintf("whence(%d)", whence)
	}
}

var fsyncStatbuf stat.Stat

// int fsync(int fd);
func Xfsync(t *TLS, fd int32) int32 {

	f, ok := fdToFile(fd)
	if !ok {
		t.setErrno(errno.EBADF)
		return -1
	}
	err := syscall.FlushFileBuffers(f.Handle)
	if err != nil {
		t.setErrno(err)
		return -1
	}

	if dmesgs {
		dmesg("%v: %d: ok", origin(1), fd)
	}
	return 0
}

// long sysconf(int name);
func Xsysconf(t *TLS, name int32) long {
	panic(todo(""))
	// switch name {
	// case unistd.X_SC_PAGESIZE:
	// 	return long(unix.Getpagesize())
	// }

	// panic(todo(""))
}

// int close(int fd);
func Xclose(t *TLS, fd int32) int32 {

	f, ok := fdToFile(fd)
	if !ok {
		t.setErrno(errno.EBADF)
		return -1
	}

	err := syscall.Close(f.Handle)
	if err != nil {
		t.setErrno(err)
		return -1
	}

	if dmesgs {
		dmesg("%v: %d: ok", origin(1), fd)
	}
	return 0
}

// char *getcwd(char *buf, size_t size);
func Xgetcwd(t *TLS, buf uintptr, size types.Size_t) uintptr {

	b := make([]uint16, size)
	n, err := syscall.GetCurrentDirectory(uint32(len(b)), &b[0])
	if err != nil {
		t.setErrno(err)
		return 0
	}
	// to bytes
	var wd = []byte(string(utf16.Decode(b[0:n])))
	if types.Size_t(len(wd)) > size {
		t.setErrno(errno.ERANGE)
		return 0
	}

	copy((*RawMem)(unsafe.Pointer(buf))[:], wd)
	(*RawMem)(unsafe.Pointer(buf))[len(wd)] = 0

	if dmesgs {
		dmesg("%v: %q: ok", origin(1), GoString(buf))
	}
	return buf
}

// int fstat(int fd, struct stat *statbuf);
func Xfstat(t *TLS, fd int32, statbuf uintptr) int32 {
	return Xfstat64(t, fd, statbuf)
}

// int ftruncate(int fd, off_t length);
func Xftruncate(t *TLS, fd int32, length types.Off_t) int32 {
	return Xftruncate64(t, fd, length)
}

// int fcntl(int fd, int cmd, ... /* arg */ );
func Xfcntl(t *TLS, fd, cmd int32, args uintptr) int32 {
	return Xfcntl64(t, fd, cmd, args)
}

// 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 Xread(t *TLS, fd int32, buf uintptr, count uint32) int32 {
	f, ok := fdToFile(fd)
	if !ok {
		t.setErrno(errno.EBADF)
		return -1
	}

	var obuf = ((*RawMem)(unsafe.Pointer(buf)))[:count]
	n, err := syscall.Read(f.Handle, obuf)
	if err != nil {
		t.setErrno(err)
		return -1
	}

	if dmesgs {
		// dmesg("%v: %d %#x: %#x\n%s", origin(1), fd, count, n, hex.Dump(GoBytes(buf, int(n))))
		dmesg("%v: %d %#x: %#x", origin(1), fd, count, n)
	}
	return int32(n)
}

// 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 Xwrite(t *TLS, fd int32, buf uintptr, count uint32) int32 {
	f, ok := fdToFile(fd)
	if !ok {
		t.setErrno(errno.EBADF)
		return -1
	}

	var obuf = ((*RawMem)(unsafe.Pointer(buf)))[:count]
	n, err := syscall.Write(f.Handle, obuf)
	if err != nil {
		if dmesgs {
			dmesg("%v: fd %v, count %#x: %v", origin(1), fd, count, err)
		}
		t.setErrno(err)
		return -1
	}

	if dmesgs {
		// dmesg("%v: %d %#x: %#x\n%s", origin(1), fd, count, n, hex.Dump(GoBytes(buf, int(n))))
		dmesg("%v: %d %#x: %#x", origin(1), fd, count, n)
	}
	return int32(n)
}

// int fchmod(int fd, mode_t mode);
func Xfchmod(t *TLS, fd int32, mode types.Mode_t) int32 {
	panic(todo(""))
	// if _, _, err := unix.Syscall(unix.SYS_FCHMOD, uintptr(fd), uintptr(mode), 0); err != 0 {
	// 	t.setErrno(err)
	// 	return -1
	// }

	// if dmesgs {
	// 	dmesg("%v: %d %#o: ok", origin(1), fd, mode)
	// }
	// return 0
}

// // int fchown(int fd, uid_t owner, gid_t group);
// func Xfchown(t *TLS, fd int32, owner types.Uid_t, group types.Gid_t) int32 {
// 	if _, _, err := unix.Syscall(unix.SYS_FCHOWN, uintptr(fd), uintptr(owner), uintptr(group)); err != 0 {
// 		t.setErrno(err)
// 		return -1
// 	}
//
// 	return 0
// }

// // uid_t geteuid(void);
// func Xgeteuid(t *TLS) types.Uid_t {
// 	n, _, _ := unix.Syscall(unix.SYS_GETEUID, 0, 0, 0)
// 	return types.Uid_t(n)
// }

// int munmap(void *addr, size_t length);
func Xmunmap(t *TLS, addr uintptr, length types.Size_t) int32 {
	panic(todo(""))
	// if _, _, err := unix.Syscall(unix.SYS_MUNMAP, addr, uintptr(length), 0); err != 0 {
	// 	t.setErrno(err)
	// 	return -1
	// }

	// return 0
}

// int gettimeofday(struct timeval *tv, struct timezone *tz);
func Xgettimeofday(t *TLS, tv, tz uintptr) int32 {
	panic(todo(""))
	// if tz != 0 {
	// 	panic(todo(""))
	// }

	// var tvs unix.Timeval
	// err := unix.Gettimeofday(&tvs)
	// if err != nil {
	// 	t.setErrno(err)
	// 	return -1
	// }

	// *(*unix.Timeval)(unsafe.Pointer(tv)) = tvs
	// return 0
}

// int getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen);
func Xgetsockopt(t *TLS, _ ...interface{}) int32 {
	panic(todo(""))
	// if _, _, err := unix.Syscall6(unix.SYS_GETSOCKOPT, uintptr(sockfd), uintptr(level), uintptr(optname), optval, optlen, 0); err != 0 {
	// 	t.setErrno(err)
	// 	return -1
	// }

	// return 0
}

// // int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);
func Xsetsockopt(t *TLS, _ ...interface{}) int32 {
	panic(todo(""))
}

// int ioctl(int fd, unsigned long request, ...);
func Xioctl(t *TLS, fd int32, request ulong, va uintptr) int32 {
	panic(todo(""))
	// var argp uintptr
	// if va != 0 {
	// 	argp = VaUintptr(&va)
	// }
	// n, _, err := unix.Syscall(unix.SYS_IOCTL, uintptr(fd), uintptr(request), argp)
	// if err != 0 {
	// 	t.setErrno(err)
	// 	return -1
	// }

	// return int32(n)
}

// int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
func Xselect(t *TLS, nfds int32, readfds, writefds, exceptfds, timeout uintptr) int32 {
	panic(todo(""))
	// n, err := unix.Select(
	// 	int(nfds),
	// 	(*unix.FdSet)(unsafe.Pointer(readfds)),
	// 	(*unix.FdSet)(unsafe.Pointer(writefds)),
	// 	(*unix.FdSet)(unsafe.Pointer(exceptfds)),
	// 	(*unix.Timeval)(unsafe.Pointer(timeout)),
	// )
	// if err != nil {
	// 	t.setErrno(err)
	// 	return -1
	// }

	// return int32(n)
}

// int mkfifo(const char *pathname, mode_t mode);
func Xmkfifo(t *TLS, pathname uintptr, mode types.Mode_t) int32 {
	panic(todo(""))
	// 	if err := unix.Mkfifo(GoString(pathname), mode); err != nil {
	// 		t.setErrno(err)
	// 		return -1
	// 	}
	//
	// 	return 0
}

// mode_t umask(mode_t mask);
func Xumask(t *TLS, mask types.Mode_t) types.Mode_t {
	panic(todo(""))
	// 	n, _, _ := unix.Syscall(unix.SYS_UMASK, uintptr(mask), 0, 0)
	// 	return types.Mode_t(n)
}

// int execvp(const char *file, char *const argv[]);
func Xexecvp(t *TLS, file, argv uintptr) int32 {
	panic(todo(""))
	// 	if _, _, err := unix.Syscall(unix.SYS_EXECVE, file, argv, Environ()); err != 0 {
	// 		t.setErrno(err)
	// 		return -1
	// 	}
	//
	// 	return 0
}

// pid_t waitpid(pid_t pid, int *wstatus, int options);
func Xwaitpid(t *TLS, pid types.Pid_t, wstatus uintptr, optname int32) types.Pid_t {
	panic(todo(""))
	// 	n, _, err := unix.Syscall6(unix.SYS_WAIT4, uintptr(pid), wstatus, uintptr(optname), 0, 0, 0)
	// 	if err != 0 {
	// 		t.setErrno(err)
	// 		return -1
	// 	}
	//
	// 	return types.Pid_t(n)
}

// int uname(struct utsname *buf);
func Xuname(t *TLS, buf uintptr) int32 {
	panic(todo(""))
	// 	if _, _, err := unix.Syscall(unix.SYS_UNAME, buf, 0, 0); err != 0 {
	// 		t.setErrno(err)
	// 		return -1
	// 	}
	//
	// 	return 0
}

// int getrlimit(int resource, struct rlimit *rlim);
func Xgetrlimit(t *TLS, resource int32, rlim uintptr) int32 {
	return Xgetrlimit64(t, resource, rlim)
}

// int setrlimit(int resource, const struct rlimit *rlim);
func Xsetrlimit(t *TLS, resource int32, rlim uintptr) int32 {
	return Xsetrlimit64(t, resource, rlim)
}

// int setrlimit(int resource, const struct rlimit *rlim);
func Xsetrlimit64(t *TLS, resource int32, rlim uintptr) int32 {
	panic(todo(""))
	// 	if _, _, err := unix.Syscall(unix.SYS_SETRLIMIT, uintptr(resource), uintptr(rlim), 0); err != 0 {
	// 		t.setErrno(err)
	// 		return -1
	// 	}
	//
	// 	return 0
}

// // uid_t getuid(void);
// func Xgetuid(t *TLS) types.Uid_t {
// 	return types.Uid_t(os.Getuid())
// }

// pid_t getpid(void);
func Xgetpid(t *TLS) int32 {
	return int32(os.Getpid())
}

// int system(const char *command);
func Xsystem(t *TLS, command uintptr) int32 {
	s := GoString(command)
	if command == 0 {
		panic(todo(""))
	}

	cmd := exec.Command("sh", "-c", s)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	err := cmd.Run()
	if err != nil {
		ps := err.(*exec.ExitError)
		return int32(ps.ExitCode())
	}

	return 0
}

// var staticGetpwuid pwd.Passwd
//
// func init() {
// 	atExit = append(atExit, func() { closePasswd(&staticGetpwuid) })
// }
//
// func closePasswd(p *pwd.Passwd) {
// 	Xfree(nil, p.Fpw_name)
// 	Xfree(nil, p.Fpw_passwd)
// 	Xfree(nil, p.Fpw_gecos)
// 	Xfree(nil, p.Fpw_dir)
// 	Xfree(nil, p.Fpw_shell)
// 	*p = pwd.Passwd{}
// }

// struct passwd *getpwuid(uid_t uid);
func Xgetpwuid(t *TLS, uid uint32) uintptr {
	panic(todo(""))
	// 	f, err := os.Open("/etc/passwd")
	// 	if err != nil {
	// 		panic(todo("", err))
	// 	}
	//
	// 	defer f.Close()
	//
	// 	sid := strconv.Itoa(int(uid))
	// 	sc := bufio.NewScanner(f)
	// 	for sc.Scan() {
	// 		// eg. "root:x:0:0:root:/root:/bin/bash"
	// 		a := strings.Split(sc.Text(), ":")
	// 		if len(a) < 7 {
	// 			panic(todo(""))
	// 		}
	//
	// 		if a[2] == sid {
	// 			uid, err := strconv.Atoi(a[2])
	// 			if err != nil {
	// 				panic(todo(""))
	// 			}
	//
	// 			gid, err := strconv.Atoi(a[3])
	// 			if err != nil {
	// 				panic(todo(""))
	// 			}
	//
	// 			closePasswd(&staticGetpwuid)
	// 			gecos := a[4]
	// 			if strings.Contains(gecos, ",") {
	// 				a := strings.Split(gecos, ",")
	// 				gecos = a[0]
	// 			}
	// 			initPasswd(t, &staticGetpwuid, a[0], a[1], uint32(uid), uint32(gid), gecos, a[5], a[6])
	// 			return uintptr(unsafe.Pointer(&staticGetpwuid))
	// 		}
	// 	}
	//
	// 	if sc.Err() != nil {
	// 		panic(todo(""))
	// 	}
	//
	// 	return 0
}

// func initPasswd(t *TLS, p *pwd.Passwd, name, pwd string, uid, gid uint32, gecos, dir, shell string) {
// 	p.Fpw_name = cString(t, name)
// 	p.Fpw_passwd = cString(t, pwd)
// 	p.Fpw_uid = uid
// 	p.Fpw_gid = gid
// 	p.Fpw_gecos = cString(t, gecos)
// 	p.Fpw_dir = cString(t, dir)
// 	p.Fpw_shell = cString(t, shell)
// }

// int setvbuf(FILE *stream, char *buf, int mode, size_t size);
func Xsetvbuf(t *TLS, stream, buf uintptr, mode int32, size types.Size_t) int32 {
	return 0 //TODO
}

// int raise(int sig);
func Xraise(t *TLS, sig int32) int32 {
	panic(todo(""))
}

// int backtrace(void **buffer, int size);
func Xbacktrace(t *TLS, buf uintptr, size int32) int32 {
	panic(todo(""))
}

// void backtrace_symbols_fd(void *const *buffer, int size, int fd);
func Xbacktrace_symbols_fd(t *TLS, buffer uintptr, size, fd int32) {
	panic(todo(""))
}

// int fileno(FILE *stream);
func Xfileno(t *TLS, stream uintptr) int32 {
	if stream == 0 {
		t.setErrno(errno.EBADF)
		return -1
	}

	f, ok := winGetObject(stream).(*file)
	if !ok {
		t.setErrno(errno.EBADF)
		return -1
	}
	return f._fd
}

// var staticGetpwnam pwd.Passwd
//
// func init() {
// 	atExit = append(atExit, func() { closePasswd(&staticGetpwnam) })
// }
//
// // struct passwd *getpwnam(const char *name);
// func Xgetpwnam(t *TLS, name uintptr) uintptr {
// 	f, err := os.Open("/etc/passwd")
// 	if err != nil {
// 		panic(todo("", err))
// 	}
//
// 	defer f.Close()
//
// 	sname := GoString(name)
// 	sc := bufio.NewScanner(f)
// 	for sc.Scan() {
// 		// eg. "root:x:0:0:root:/root:/bin/bash"
// 		a := strings.Split(sc.Text(), ":")
// 		if len(a) < 7 {
// 			panic(todo(""))
// 		}
//
// 		if a[0] == sname {
// 			uid, err := strconv.Atoi(a[2])
// 			if err != nil {
// 				panic(todo(""))
// 			}
//
// 			gid, err := strconv.Atoi(a[3])
// 			if err != nil {
// 				panic(todo(""))
// 			}
//
// 			closePasswd(&staticGetpwnam)
// 			gecos := a[4]
// 			if strings.Contains(gecos, ",") {
// 				a := strings.Split(gecos, ",")
// 				gecos = a[0]
// 			}
// 			initPasswd(t, &staticGetpwnam, a[0], a[1], uint32(uid), uint32(gid), gecos, a[5], a[6])
// 			return uintptr(unsafe.Pointer(&staticGetpwnam))
// 		}
// 	}
//
// 	if sc.Err() != nil {
// 		panic(todo(""))
// 	}
//
// 	return 0
// }
//
// var staticGetgrnam grp.Group
//
// func init() {
// 	atExit = append(atExit, func() { closeGroup(&staticGetgrnam) })
// }
//
// // struct group *getgrnam(const char *name);
// func Xgetgrnam(t *TLS, name uintptr) uintptr {
// 	f, err := os.Open("/etc/group")
// 	if err != nil {
// 		panic(todo(""))
// 	}
//
// 	defer f.Close()
//
// 	sname := GoString(name)
// 	sc := bufio.NewScanner(f)
// 	for sc.Scan() {
// 		// eg. "root:x:0:"
// 		a := strings.Split(sc.Text(), ":")
// 		if len(a) < 4 {
// 			panic(todo(""))
// 		}
//
// 		if a[0] == sname {
// 			closeGroup(&staticGetgrnam)
// 			gid, err := strconv.Atoi(a[2])
// 			if err != nil {
// 				panic(todo(""))
// 			}
//
// 			var names []string
// 			if a[3] != "" {
// 				names = strings.Split(a[3], ",")
// 			}
// 			initGroup(t, &staticGetgrnam, a[0], a[1], uint32(gid), names)
// 			return uintptr(unsafe.Pointer(&staticGetgrnam))
// 		}
// 	}
//
// 	if sc.Err() != nil {
// 		panic(todo(""))
// 	}
//
// 	return 0
// }
//
// func closeGroup(p *grp.Group) {
// 	Xfree(nil, p.Fgr_name)
// 	Xfree(nil, p.Fgr_passwd)
// 	if p.Fgr_mem != 0 {
// 		panic(todo(""))
// 	}
//
// 	*p = grp.Group{}
// }
//
// func initGroup(t *TLS, p *grp.Group, name, pwd string, gid uint32, names []string) {
// 	p.Fgr_name = cString(t, name)
// 	p.Fgr_passwd = cString(t, pwd)
// 	p.Fgr_gid = gid
// 	p.Fgr_mem = 0
// 	if len(names) != 0 {
// 		panic(todo("%q %q %v %q %v", name, pwd, gid, names, len(names)))
// 	}
// }
//
// func init() {
// 	atExit = append(atExit, func() { closeGroup(&staticGetgrgid) })
// }
//
// var staticGetgrgid grp.Group
//
// // struct group *getgrgid(gid_t gid);
// func Xgetgrgid(t *TLS, gid uint32) uintptr {
// 	f, err := os.Open("/etc/group")
// 	if err != nil {
// 		panic(todo(""))
// 	}
//
// 	defer f.Close()
//
// 	sid := strconv.Itoa(int(gid))
// 	sc := bufio.NewScanner(f)
// 	for sc.Scan() {
// 		// eg. "root:x:0:"
// 		a := strings.Split(sc.Text(), ":")
// 		if len(a) < 4 {
// 			panic(todo(""))
// 		}
//
// 		if a[2] == sid {
// 			closeGroup(&staticGetgrgid)
// 			var names []string
// 			if a[3] != "" {
// 				names = strings.Split(a[3], ",")
// 			}
// 			initGroup(t, &staticGetgrgid, a[0], a[1], gid, names)
// 			return uintptr(unsafe.Pointer(&staticGetgrgid))
// 		}
// 	}
//
// 	if sc.Err() != nil {
// 		panic(todo(""))
// 	}
//
// 	return 0
// }

// int mkstemps(char *template, int suffixlen);
func Xmkstemps(t *TLS, template uintptr, suffixlen int32) int32 {
	return Xmkstemps64(t, template, suffixlen)
}

// int mkstemps(char *template, int suffixlen);
func Xmkstemps64(t *TLS, template uintptr, suffixlen int32) int32 {
	panic(todo(""))
	// 	len := uintptr(Xstrlen(t, template))
	// 	x := template + uintptr(len-6) - uintptr(suffixlen)
	// 	for i := uintptr(0); i < 6; i++ {
	// 		if *(*byte)(unsafe.Pointer(x + i)) != 'X' {
	// 			t.setErrno(errno.EINVAL)
	// 			return -1
	// 		}
	// 	}
	//
	// 	fd, err := tempFile(template, x)
	// 	if err != 0 {
	// 		t.setErrno(err)
	// 		return -1
	// 	}
	//
	// 	return int32(fd)
}

// int mkstemp(char *template);
func Xmkstemp64(t *TLS, template uintptr) int32 {
	return Xmkstemps64(t, template, 0)
}

// func newFtsent(t *TLS, info int, path string, stat *unix.Stat_t, err syscall.Errno) (r *fts.FTSENT) {
// 	var statp uintptr
// 	if stat != nil {
// 		statp = Xmalloc(t, types.Size_t(unsafe.Sizeof(unix.Stat_t{})))
// 		if statp == 0 {
// 			panic("OOM")
// 		}
//
// 		*(*unix.Stat_t)(unsafe.Pointer(statp)) = *stat
// 	}
// 	csp := CString(path)
// 	if csp == 0 {
// 		panic("OOM")
// 	}
//
// 	return &fts.FTSENT{
// 		Ffts_info:    uint16(info),
// 		Ffts_path:    csp,
// 		Ffts_pathlen: uint16(len(path)),
// 		Ffts_statp:   statp,
// 		Ffts_errno:   int32(err),
// 	}
// }
//
// func newCFtsent(t *TLS, info int, path string, stat *unix.Stat_t, err syscall.Errno) uintptr {
// 	p := Xcalloc(t, types.Size_t(unsafe.Sizeof(fts.FTSENT{})))
// 	if p == 0 {
// 		panic("OOM")
// 	}
//
// 	*(*fts.FTSENT)(unsafe.Pointer(p)) = *newFtsent(t, info, path, stat, err)
// 	return p
// }
//
// func ftsentClose(t *TLS, p uintptr) {
// 	Xfree(t, (*fts.FTSENT)(unsafe.Pointer(p)).Ffts_path)
// 	Xfree(t, (*fts.FTSENT)(unsafe.Pointer(p)).Ffts_statp)
// }

type ftstream struct {
	s []uintptr
	x int
}

// func (f *ftstream) close(t *TLS) {
// 	for _, p := range f.s {
// 		ftsentClose(t, p)
// 		Xfree(t, p)
// 	}
// 	*f = ftstream{}
// }
//
// // FTS *fts_open(char * const *path_argv, int options, int (*compar)(const FTSENT **, const FTSENT **));
// func Xfts_open(t *TLS, path_argv uintptr, options int32, compar uintptr) uintptr {
// 	return Xfts64_open(t, path_argv, options, compar)
// }

// FTS *fts_open(char * const *path_argv, int options, int (*compar)(const FTSENT **, const FTSENT **));
func Xfts64_open(t *TLS, path_argv uintptr, options int32, compar uintptr) uintptr {
	panic(todo(""))
	// 	f := &ftstream{}
	//
	// 	var walk func(string)
	// 	walk = func(path string) {
	// 		var fi os.FileInfo
	// 		var err error
	// 		switch {
	// 		case options&fts.FTS_LOGICAL != 0:
	// 			fi, err = os.Stat(path)
	// 		case options&fts.FTS_PHYSICAL != 0:
	// 			fi, err = os.Lstat(path)
	// 		default:
	// 			panic(todo(""))
	// 		}
	//
	// 		if err != nil {
	// 			panic(todo(""))
	// 		}
	//
	// 		var statp *unix.Stat_t
	// 		if options&fts.FTS_NOSTAT == 0 {
	// 			var stat unix.Stat_t
	// 			switch {
	// 			case options&fts.FTS_LOGICAL != 0:
	// 				if err := unix.Stat(path, &stat); err != nil {
	// 					panic(todo(""))
	// 				}
	// 			case options&fts.FTS_PHYSICAL != 0:
	// 				if err := unix.Lstat(path, &stat); err != nil {
	// 					panic(todo(""))
	// 				}
	// 			default:
	// 				panic(todo(""))
	// 			}
	//
	// 			statp = &stat
	// 		}
	//
	// 	out:
	// 		switch {
	// 		case fi.IsDir():
	// 			f.s = append(f.s, newCFtsent(t, fts.FTS_D, path, statp, 0))
	// 			g, err := os.Open(path)
	// 			switch x := err.(type) {
	// 			case nil:
	// 				// ok
	// 			case *os.PathError:
	// 				f.s = append(f.s, newCFtsent(t, fts.FTS_DNR, path, statp, errno.EACCES))
	// 				break out
	// 			default:
	// 				panic(todo("%q: %v %T", path, x, x))
	// 			}
	//
	// 			names, err := g.Readdirnames(-1)
	// 			g.Close()
	// 			if err != nil {
	// 				panic(todo(""))
	// 			}
	//
	// 			for _, name := range names {
	// 				walk(path + "/" + name)
	// 				if f == nil {
	// 					break out
	// 				}
	// 			}
	//
	// 			f.s = append(f.s, newCFtsent(t, fts.FTS_DP, path, statp, 0))
	// 		default:
	// 			info := fts.FTS_F
	// 			if fi.Mode()&os.ModeSymlink != 0 {
	// 				info = fts.FTS_SL
	// 			}
	// 			switch {
	// 			case statp != nil:
	// 				f.s = append(f.s, newCFtsent(t, info, path, statp, 0))
	// 			case options&fts.FTS_NOSTAT != 0:
	// 				f.s = append(f.s, newCFtsent(t, fts.FTS_NSOK, path, nil, 0))
	// 			default:
	// 				panic(todo(""))
	// 			}
	// 		}
	// 	}
	//
	// 	for {
	// 		p := *(*uintptr)(unsafe.Pointer(path_argv))
	// 		if p == 0 {
	// 			if f == nil {
	// 				return 0
	// 			}
	//
	// 			if compar != 0 {
	// 				panic(todo(""))
	// 			}
	//
	// 			return addObject(f)
	// 		}
	//
	// 		walk(GoString(p))
	// 		path_argv += unsafe.Sizeof(uintptr(0))
	// 	}
}

// FTSENT *fts_read(FTS *ftsp);
func Xfts_read(t *TLS, ftsp uintptr) uintptr {
	return Xfts64_read(t, ftsp)
}

// FTSENT *fts_read(FTS *ftsp);
func Xfts64_read(t *TLS, ftsp uintptr) uintptr {
	panic(todo(""))
	// 	f := winGetObject(ftsp).(*ftstream)
	// 	if f.x == len(f.s) {
	// 		t.setErrno(0)
	// 		return 0
	// 	}
	//
	// 	r := f.s[f.x]
	// 	if e := (*fts.FTSENT)(unsafe.Pointer(r)).Ffts_errno; e != 0 {
	// 		t.setErrno(e)
	// 	}
	// 	f.x++
	// 	return r
}

// int fts_close(FTS *ftsp);
func Xfts_close(t *TLS, ftsp uintptr) int32 {
	return Xfts64_close(t, ftsp)
}

// int fts_close(FTS *ftsp);
func Xfts64_close(t *TLS, ftsp uintptr) int32 {
	panic(todo(""))
	// 	winGetObject(ftsp).(*ftstream).close(t)
	// 	removeObject(ftsp)
	// 	return 0
}

// void tzset (void);
func Xtzset(t *TLS) {
	//TODO
}

var strerrorBuf [256]byte

// char *strerror(int errnum);
func Xstrerror(t *TLS, errnum int32) uintptr {
	copy((*RawMem)(unsafe.Pointer(&strerrorBuf[0]))[:len(strerrorBuf):len(strerrorBuf)], fmt.Sprintf("errno %d\x00", errnum))
	return uintptr(unsafe.Pointer(&strerrorBuf[0]))
}

// void *dlopen(const char *filename, int flags);
func Xdlopen(t *TLS, filename uintptr, flags int32) uintptr {
	panic(todo(""))
}

// char *dlerror(void);
func Xdlerror(t *TLS) uintptr {
	panic(todo(""))
}

// int dlclose(void *handle);
func Xdlclose(t *TLS, handle uintptr) int32 {
	panic(todo(""))
}

// void *dlsym(void *handle, const char *symbol);
func Xdlsym(t *TLS, handle, symbol uintptr) uintptr {
	panic(todo(""))
}

// void perror(const char *s);
func Xperror(t *TLS, s uintptr) {
	panic(todo(""))
}

// int pclose(FILE *stream);
func Xpclose(t *TLS, stream uintptr) int32 {
	panic(todo(""))
}

var gai_strerrorBuf [100]byte

// const char *gai_strerror(int errcode);
func Xgai_strerror(t *TLS, errcode int32) uintptr {
	copy(gai_strerrorBuf[:], fmt.Sprintf("gai error %d\x00", errcode))
	return uintptr(unsafe.Pointer(&gai_strerrorBuf))
}

// int tcgetattr(int fd, struct termios *termios_p);
func Xtcgetattr(t *TLS, fd int32, termios_p uintptr) int32 {
	panic(todo(""))
}

// int tcsetattr(int fd, int optional_actions, const struct termios *termios_p);
func Xtcsetattr(t *TLS, fd, optional_actions int32, termios_p uintptr) int32 {
	panic(todo(""))
}

// // speed_t cfgetospeed(const struct termios *termios_p);
// func Xcfgetospeed(t *TLS, termios_p uintptr) termios.Speed_t {
// 	panic(todo(""))
// }

// int cfsetospeed(struct termios *termios_p, speed_t speed);
func Xcfsetospeed(t *TLS, termios_p uintptr, speed uint32) int32 {
	panic(todo(""))
}

// int cfsetispeed(struct termios *termios_p, speed_t speed);
func Xcfsetispeed(t *TLS, termios_p uintptr, speed uint32) int32 {
	panic(todo(""))
}

// pid_t fork(void);
func Xfork(t *TLS) int32 {
	t.setErrno(errno.ENOSYS)
	return -1
}

// char *setlocale(int category, const char *locale);
func Xsetlocale(t *TLS, category int32, locale uintptr) uintptr {
	return 0 //TODO
}

// // char *nl_langinfo(nl_item item);
// func Xnl_langinfo(t *TLS, item langinfo.Nl_item) uintptr {
// 	panic(todo(""))
// }

// FILE *popen(const char *command, const char *type);
func Xpopen(t *TLS, command, type1 uintptr) uintptr {
	panic(todo(""))
}

// char *realpath(const char *path, char *resolved_path);
func Xrealpath(t *TLS, path, resolved_path uintptr) uintptr {
	s, err := filepath.EvalSymlinks(GoString(path))
	if err != nil {
		if os.IsNotExist(err) {
			if dmesgs {
				dmesg("%v: %q: %v", origin(1), GoString(path), err)
			}
			t.setErrno(errno.ENOENT)
			return 0
		}

		panic(todo("", err))
	}

	if resolved_path == 0 {
		panic(todo(""))
	}

	if len(s) >= limits.PATH_MAX {
		s = s[:limits.PATH_MAX-1]
	}

	copy((*RawMem)(unsafe.Pointer(resolved_path))[:len(s):len(s)], s)
	(*RawMem)(unsafe.Pointer(resolved_path))[len(s)] = 0
	return resolved_path
}

// struct tm *gmtime_r(const time_t *timep, struct tm *result);
func Xgmtime_r(t *TLS, timep, result uintptr) uintptr {
	panic(todo(""))
}

// // char *inet_ntoa(struct in_addr in);
// func Xinet_ntoa(t *TLS, in1 in.In_addr) uintptr {
// 	panic(todo(""))
// }

// func X__ccgo_in6addr_anyp(t *TLS) uintptr {
// 	return uintptr(unsafe.Pointer(&in6_addr_any))
// }

func Xabort(t *TLS) {
	panic(todo(""))
	// 	if dmesgs {
	// 		dmesg("%v:\n%s", origin(1), debug.Stack())
	// 	}
	// 	p := Xmalloc(t, types.Size_t(unsafe.Sizeof(signal.Sigaction{})))
	// 	if p == 0 {
	//		panic("OOM")
	//	}
	//
	// 	*(*signal.Sigaction)(unsafe.Pointer(p)) = signal.Sigaction{
	// 		F__sigaction_handler: struct{ Fsa_handler signal.X__sighandler_t }{Fsa_handler: signal.SIG_DFL},
	// 	}
	// 	Xsigaction(t, signal.SIGABRT, p, 0)
	// 	Xfree(t, p)
	// 	unix.Kill(unix.Getpid(), syscall.Signal(signal.SIGABRT))
	// 	panic(todo("unrechable"))
}

// int fflush(FILE *stream);
func Xfflush(t *TLS, stream uintptr) int32 {
	f, ok := winGetObject(stream).(*file)
	if !ok {
		t.setErrno(errno.EBADF)
		return -1
	}
	err := syscall.FlushFileBuffers(f.Handle)
	if err != nil {
		t.setErrno(err)
		return -1
	}
	return 0
}

// size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
func Xfread(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) types.Size_t {
	f, ok := winGetObject(stream).(*file)
	if !ok {
		t.setErrno(errno.EBADF)
		return 0
	}

	var sz = size * nmemb
	var obuf = ((*RawMem)(unsafe.Pointer(ptr)))[:sz]
	n, err := syscall.Read(f.Handle, obuf)
	if err != nil {
		f.setErr()
		return 0
	}

	if dmesgs {
		// dmesg("%v: %d %#x x %#x: %#x\n%s", origin(1), file(stream).fd(), size, nmemb, types.Size_t(m)/size, hex.Dump(GoBytes(ptr, int(m))))
		dmesg("%v: %d %#x x %#x: %#x\n%s", origin(1), f._fd, size, nmemb, types.Size_t(n)/size)
	}

	return types.Size_t(n) / size

}

// size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
func Xfwrite(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) types.Size_t {
	if ptr == 0 || size == 0 {
		return 0
	}

	f, ok := winGetObject(stream).(*file)
	if !ok {
		t.setErrno(errno.EBADF)
		return 0
	}

	var sz = size * nmemb
	var obuf = ((*RawMem)(unsafe.Pointer(ptr)))[:sz]
	n, err := syscall.Write(f.Handle, obuf)
	if err != nil {
		f.setErr()
		return 0
	}

	if dmesgs {
		// 		// dmesg("%v: %d %#x x %#x: %#x\n%s", origin(1), file(stream).fd(), size, nmemb, types.Size_t(m)/size, hex.Dump(GoBytes(ptr, int(m))))
		dmesg("%v: %d %#x x %#x: %#x\n%s", origin(1), f._fd, size, nmemb, types.Size_t(n)/size)
	}
	return types.Size_t(n) / size
}

// int fclose(FILE *stream);
func Xfclose(t *TLS, stream uintptr) int32 {
	f, ok := winGetObject(stream).(*file)
	if !ok {
		t.setErrno(errno.EBADF)
		return -1
	}
	return f.close(t)
}

// int fputc(int c, FILE *stream);
func Xfputc(t *TLS, c int32, stream uintptr) int32 {
	f, ok := winGetObject(stream).(*file)
	if !ok {
		t.setErrno(errno.EBADF)
		return -1
	}
	if _, err := fwrite(f._fd, []byte{byte(c)}); err != nil {
		return -1
	}
	return int32(byte(c))
}

// int fseek(FILE *stream, long offset, int whence);
func Xfseek(t *TLS, stream uintptr, offset long, whence int32) int32 {
	f, ok := winGetObject(stream).(*file)
	if !ok {
		t.setErrno(errno.EBADF)
		return -1
	}
	if n := Xlseek(t, f._fd, types.Off_t(offset), whence); n < 0 {
		if dmesgs {
			dmesg("%v: fd %v, off %#x, whence %v: %v", origin(1), f._fd, offset, whenceStr(whence), n)
		}
		f.setErr()
		return -1
	}

	if dmesgs {
		dmesg("%v: fd %v, off %#x, whence %v: ok", origin(1), f._fd, offset, whenceStr(whence))
	}
	return 0
}

// long ftell(FILE *stream);
func Xftell(t *TLS, stream uintptr) long {
	f, ok := winGetObject(stream).(*file)
	if !ok {
		t.setErrno(errno.EBADF)
		return -1
	}

	n := Xlseek(t, f._fd, 0, syscall.FILE_CURRENT)
	if n < 0 {
		f.setErr()
		return -1
	}

	if dmesgs {
		dmesg("%v: fd %v, n %#x: ok %#x", origin(1), f._fd, n, long(n))
	}
	return long(n)
}

// int ferror(FILE *stream);
func Xferror(t *TLS, stream uintptr) int32 {
	f, ok := winGetObject(stream).(*file)
	if !ok {
		t.setErrno(errno.EBADF)
		return -1
	}

	return Bool32(f.err())
}

// int getc(FILE *stream);
func Xfgetc(t *TLS, stream uintptr) int32 {
	f, ok := winGetObject(stream).(*file)
	if !ok {
		t.setErrno(errno.EBADF)
		return stdio.EOF
	}

	var buf [1]byte
	if n, _ := syscall.Read(f.Handle, buf[:]); n != 0 {
		return int32(buf[0])
	}

	return stdio.EOF
}

// int ungetc(int c, FILE *stream);
func Xungetc(t *TLS, c int32, stream uintptr) int32 {
	panic(todo(""))
}

// int fscanf(FILE *stream, const char *format, ...);
func Xfscanf(t *TLS, stream, format, va uintptr) int32 {
	panic(todo(""))
}

// int fputs(const char *s, FILE *stream);
func Xfputs(t *TLS, s, stream uintptr) int32 {
	f, ok := winGetObject(stream).(*file)
	if !ok {
		t.setErrno(errno.EBADF)
		return -1
	}
	gS := GoString(s)
	if _, err := fwrite(f._fd, []byte(gS)); err != nil {
		return -1
	}
	return 0
}

// var getservbynameStaticResult netdb.Servent
//
// // struct servent *getservbyname(const char *name, const char *proto);
// func Xgetservbyname(t *TLS, name, proto uintptr) uintptr {
// 	var protoent *gonetdb.Protoent
// 	if proto != 0 {
// 		protoent = gonetdb.GetProtoByName(GoString(proto))
// 	}
// 	servent := gonetdb.GetServByName(GoString(name), protoent)
// 	if servent == nil {
// 		if dmesgs {
// 			dmesg("%q %q: nil (protoent %+v)", GoString(name), GoString(proto), protoent)
// 		}
// 		return 0
// 	}
//
// 	Xfree(t, (*netdb.Servent)(unsafe.Pointer(&getservbynameStaticResult)).Fs_name)
// 	if v := (*netdb.Servent)(unsafe.Pointer(&getservbynameStaticResult)).Fs_aliases; v != 0 {
// 		for {
// 			p := *(*uintptr)(unsafe.Pointer(v))
// 			if p == 0 {
// 				break
// 			}
//
// 			Xfree(t, p)
// 			v += unsafe.Sizeof(uintptr(0))
// 		}
// 		Xfree(t, v)
// 	}
// 	Xfree(t, (*netdb.Servent)(unsafe.Pointer(&getservbynameStaticResult)).Fs_proto)
// 	cname, err := CString(servent.Name)
// 	if err != nil {
// 		getservbynameStaticResult = netdb.Servent{}
// 		return 0
// 	}
//
// 	var protoname uintptr
// 	if protoent != nil {
// 		if protoname, err = CString(protoent.Name); err != nil {
// 			Xfree(t, cname)
// 			getservbynameStaticResult = netdb.Servent{}
// 			return 0
// 		}
// 	}
// 	var a []uintptr
// 	for _, v := range servent.Aliases {
// 		cs, err := CString(v)
// 		if err != nil {
// 			for _, v := range a {
// 				Xfree(t, v)
// 			}
// 			return 0
// 		}
//
// 		a = append(a, cs)
// 	}
// 	v := Xcalloc(t, types.Size_t(len(a)+1), types.Size_t(unsafe.Sizeof(uintptr(0))))
// 	if v == 0 {
// 		Xfree(t, cname)
// 		Xfree(t, protoname)
// 		for _, v := range a {
// 			Xfree(t, v)
// 		}
// 		getservbynameStaticResult = netdb.Servent{}
// 		return 0
// 	}
// 	for _, p := range a {
// 		*(*uintptr)(unsafe.Pointer(v)) = p
// 		v += unsafe.Sizeof(uintptr(0))
// 	}
//
// 	getservbynameStaticResult = netdb.Servent{
// 		Fs_name:    cname,
// 		Fs_aliases: v,
// 		Fs_port:    int32(servent.Port),
// 		Fs_proto:   protoname,
// 	}
// 	return uintptr(unsafe.Pointer(&getservbynameStaticResult))
// }

// func Xreaddir64(t *TLS, dir uintptr) uintptr {
// 	return Xreaddir(t, dir)
// }

// func fcntlCmdStr(cmd int32) string {
// 	switch cmd {
// 	case fcntl.F_GETOWN:
// 		return "F_GETOWN"
// 	case fcntl.F_SETLK:
// 		return "F_SETLK"
// 	case fcntl.F_GETLK:
// 		return "F_GETLK"
// 	case fcntl.F_SETFD:
// 		return "F_SETFD"
// 	case fcntl.F_GETFD:
// 		return "F_GETFD"
// 	default:
// 		return fmt.Sprintf("cmd(%d)", cmd)
// 	}
// }

// _CRTIMP extern int *__cdecl _errno(void); // /usr/share/mingw-w64/include/errno.h:17:
func X_errno(t *TLS) uintptr {
	return t.errnop
}

// int vfscanf(FILE * restrict stream, const char * restrict format, va_list arg);
func X__ms_vfscanf(t *TLS, stream, format, ap uintptr) int32 {
	panic(todo(""))
}

// int vsscanf(const char *str, const char *format, va_list ap);
func X__ms_vsscanf(t *TLS, str, format, ap uintptr) int32 {
	panic(todo(""))
}

// int vscanf(const char *format, va_list ap);
func X__ms_vscanf(t *TLS, format, ap uintptr) int32 {
	panic(todo(""))
}

// int vsnprintf(char *str, size_t size, const char *format, va_list ap);
func X__ms_vsnprintf(t *TLS, str uintptr, size types.Size_t, format, ap uintptr) int32 {
	return Xvsnprintf(t, str, size, format, ap)
}

// int vfwscanf(FILE *stream, const wchar_t *format, va_list argptr;);
func X__ms_vfwscanf(t *TLS, stream uintptr, format, ap uintptr) int32 {
	panic(todo(""))
}

// int vwscanf(const wchar_t * restrict format, va_list arg);
func X__ms_vwscanf(t *TLS, format, ap uintptr) int32 {
	panic(todo(""))
}

// int _vsnwprintf(wchar_t *buffer, size_t count, const wchar_t *format, va_list argptr);
func X_vsnwprintf(t *TLS, buffer uintptr, count types.Size_t, format, ap uintptr) int32 {
	panic(todo(""))
}

// int vswscanf(const wchar_t *buffer, const wchar_t *format, va_list arglist);
func X__ms_vswscanf(t *TLS, stream uintptr, format, ap uintptr) int32 {
	panic(todo(""))
}

// __acrt_iob_func
func X__acrt_iob_func(t *TLS, fd uint32) uintptr {

	f, ok := fdToFile(int32(fd))
	if !ok {
		t.setErrno(EBADF)
		return 0
	}
	return f.t
}

// BOOL SetEvent(
//
//	HANDLE hEvent
//
// );
func XSetEvent(t *TLS, hEvent uintptr) int32 {
	r0, _, err := syscall.Syscall(procSetEvent.Addr(), 1, hEvent, 0, 0)
	if r0 == 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// int _stricmp(
//
//	const char *string1,
//	const char *string2
//
// );
func X_stricmp(t *TLS, string1, string2 uintptr) int32 {
	var s1 = strings.ToLower(GoString(string1))
	var s2 = strings.ToLower(GoString(string2))
	return int32(strings.Compare(s1, s2))
}

// BOOL HeapFree(
//
//	HANDLE                 hHeap,
//	DWORD                  dwFlags,
//	_Frees_ptr_opt_ LPVOID lpMem
//
// );
func XHeapFree(t *TLS, hHeap uintptr, dwFlags uint32, lpMem uintptr) int32 {
	r0, _, err := syscall.Syscall(procHeapFree.Addr(), 3, hHeap, uintptr(dwFlags), lpMem)
	if err != 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// HANDLE GetProcessHeap();
func XGetProcessHeap(t *TLS) uintptr {
	r0, _, err := syscall.Syscall(procGetProcessHeap.Addr(), 0, 0, 0, 0)
	if r0 == 0 {
		t.setErrno(err)
	}
	return r0
}

// LPVOID HeapAlloc(
//
//	HANDLE hHeap,
//	DWORD  dwFlags,
//	SIZE_T dwBytes
//
// );
func XHeapAlloc(t *TLS, hHeap uintptr, dwFlags uint32, dwBytes types.Size_t) uintptr {
	r0, _, err := syscall.Syscall(procHeapAlloc.Addr(), 3, hHeap, uintptr(dwFlags), uintptr(dwBytes))
	if r0 == 0 {
		t.setErrno(err)
	}
	return r0
}

// WCHAR * gai_strerrorW(
//
//	int ecode
//
// );
func Xgai_strerrorW(t *TLS, _ ...interface{}) uintptr {
	panic(todo(""))
}

// servent * getservbyname(
//
//	const char *name,
//	const char *proto
//
// );
func Xgetservbyname(t *TLS, _ ...interface{}) uintptr {
	panic(todo(""))
}

// INT WSAAPI getaddrinfo(
//
//	PCSTR           pNodeName,
//	PCSTR           pServiceName,
//	const ADDRINFOA *pHints,
//	PADDRINFOA      *ppResult
//
// );
func XWspiapiGetAddrInfo(t *TLS, _ ...interface{}) int32 {
	panic(todo(""))
}

// int wcscmp(
//
//	const wchar_t *string1,
//	const wchar_t *string2
//
// );
func Xwcscmp(t *TLS, string1, string2 uintptr) int32 {
	var s1 = goWideString(string1)
	var s2 = goWideString(string2)
	return int32(strings.Compare(s1, s2))
}

// BOOL IsDebuggerPresent();
func XIsDebuggerPresent(t *TLS) int32 {
	panic(todo(""))
}

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

// BOOL GetVersionExW(
//
//	LPOSVERSIONINFOW lpVersionInformation
//
// );
func XGetVersionExW(t *TLS, lpVersionInformation uintptr) int32 {
	r0, _, err := syscall.Syscall(procGetVersionExW.Addr(), 1, lpVersionInformation, 0, 0)
	if r0 == 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// BOOL GetVolumeNameForVolumeMountPointW(
//
//	LPCWSTR lpszVolumeMountPoint,
//	LPWSTR  lpszVolumeName,
//	DWORD   cchBufferLength
//
// );
func XGetVolumeNameForVolumeMountPointW(t *TLS, _ ...interface{}) int32 {
	panic(todo(""))
}

// size_t wcslen(
//
//	const wchar_t *str
//
// );
func Xwcslen(t *TLS, str uintptr) types.Size_t {
	r0, _, _ := syscall.Syscall(procLstrlenW.Addr(), 1, str, 0, 0)
	return types.Size_t(r0)
}

// HANDLE WINAPI GetStdHandle(
//
//	_In_ DWORD nStdHandle
//
// );
func XGetStdHandle(t *TLS, nStdHandle uint32) uintptr {
	h, err := syscall.GetStdHandle(int(nStdHandle))
	if err != nil {
		panic("no console")
	}
	return uintptr(h)
}

// BOOL CloseHandle(
//
//	HANDLE hObject
//
// );
func XCloseHandle(t *TLS, hObject uintptr) int32 {
	r := syscall.CloseHandle(syscall.Handle(hObject))
	if r != nil {
		return errno.EINVAL
	}
	return 1
}

// DWORD GetLastError();
func XGetLastError(t *TLS) uint32 {
	var rv = *(*int32)(unsafe.Pointer(t.errnop))
	return uint32(rv)

	//r1, _, _ := syscall.Syscall(procGetLastError.Addr(), 0, 0, 0, 0)
	//return uint32(r1)
}

// DWORD SetFilePointer(
//
//	HANDLE hFile,
//	LONG   lDistanceToMove,
//	PLONG  lpDistanceToMoveHigh,
//	DWORD  dwMoveMethod
//
// );
func XSetFilePointer(t *TLS, hFile uintptr, lDistanceToMove long, lpDistanceToMoveHigh uintptr, dwMoveMethod uint32) uint32 {
	r0, _, e1 := syscall.Syscall6(procSetFilePointer.Addr(), 4, hFile, uintptr(lDistanceToMove), lpDistanceToMoveHigh, uintptr(dwMoveMethod), 0, 0)
	var uOff = uint32(r0)
	if uOff == 0xffffffff {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
	}
	return uint32(r0)
}

// BOOL SetEndOfFile(
//
//	HANDLE hFile
//
// );
func XSetEndOfFile(t *TLS, hFile uintptr) int32 {
	err := syscall.SetEndOfFile(syscall.Handle(hFile))
	if err != nil {
		t.setErrno(err)
		return 0
	}
	return 1
}

// BOOL ReadFile(
//
//	HANDLE       hFile,
//	LPVOID       lpBuffer,
//	DWORD        nNumberOfBytesToRead,
//	LPDWORD      lpNumberOfBytesRead,
//	LPOVERLAPPED lpOverlapped
//
// );
func XReadFile(t *TLS, hFile, lpBuffer uintptr, nNumberOfBytesToRead uint32, lpNumberOfBytesRead, lpOverlapped uintptr) int32 {
	r1, _, e1 := syscall.Syscall6(procReadFile.Addr(), 5,
		hFile, lpBuffer, uintptr(nNumberOfBytesToRead), uintptr(lpNumberOfBytesRead), uintptr(lpOverlapped), 0)
	if r1 == 0 {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
		return 0
	}
	return int32(r1)
}

// BOOL WriteFile(
//
//	HANDLE       hFile,
//	LPCVOID      lpBuffer,
//	DWORD        nNumberOfBytesToWrite,
//	LPDWORD      lpNumberOfBytesWritten,
//	LPOVERLAPPED lpOverlapped
//
// );
func XWriteFile(t *TLS, hFile, lpBuffer uintptr, nNumberOfBytesToWrite uint32, lpNumberOfBytesWritten, lpOverlapped uintptr) int32 {
	r1, _, e1 := syscall.Syscall6(procWriteFile.Addr(), 5,
		hFile, lpBuffer, uintptr(nNumberOfBytesToWrite), lpNumberOfBytesWritten, lpOverlapped, 0)
	if r1 == 0 {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
		return 0
	}
	return int32(r1)
}

// DWORD GetFileAttributesW(
//
//	LPCWSTR lpFileName
//
// );
func XGetFileAttributesW(t *TLS, lpFileName uintptr) uint32 {
	attrs, err := syscall.GetFileAttributes((*uint16)(unsafe.Pointer(lpFileName)))
	if attrs == syscall.INVALID_FILE_ATTRIBUTES {
		if err != nil {
			t.setErrno(err)
		} else {
			t.setErrno(errno.EINVAL)
		}
	}
	return attrs
}

// HANDLE CreateFileW(
//
//	LPCWSTR               lpFileName,
//	DWORD                 dwDesiredAccess,
//	DWORD                 dwShareMode,
//	LPSECURITY_ATTRIBUTES lpSecurityAttributes,
//	DWORD                 dwCreationDisposition,
//	DWORD                 dwFlagsAndAttributes,
//	HANDLE                hTemplateFile
//
// );
func XCreateFileW(t *TLS, lpFileName uintptr, dwDesiredAccess, dwShareMode uint32, lpSecurityAttributes uintptr, dwCreationDisposition, dwFlagsAndAttributes uint32, hTemplateFile uintptr) uintptr {

	r0, _, e1 := syscall.Syscall9(procCreateFileW.Addr(), 7, lpFileName, uintptr(dwDesiredAccess), uintptr(dwShareMode), lpSecurityAttributes,
		uintptr(dwCreationDisposition), uintptr(dwFlagsAndAttributes), hTemplateFile, 0, 0)
	h := syscall.Handle(r0)
	if h == syscall.InvalidHandle {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
		return r0
	}
	return uintptr(h)
}

// BOOL DuplicateHandle(
//
//	HANDLE   hSourceProcessHandle,
//	HANDLE   hSourceHandle,
//	HANDLE   hTargetProcessHandle,
//	LPHANDLE lpTargetHandle,
//	DWORD    dwDesiredAccess,
//	BOOL     bInheritHandle,
//	DWORD    dwOptions
//
// );
func XDuplicateHandle(t *TLS, hSourceProcessHandle, hSourceHandle, hTargetProcessHandle, lpTargetHandle uintptr, dwDesiredAccess uint32, bInheritHandle int32, dwOptions uint32) int32 {
	r0, _, err := syscall.Syscall9(procDuplicateHandle.Addr(), 7, hSourceProcessHandle, hSourceHandle, hTargetProcessHandle,
		lpTargetHandle, uintptr(dwDesiredAccess), uintptr(bInheritHandle), uintptr(dwOptions), 0, 0)
	if r0 == 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// HANDLE GetCurrentProcess();
func XGetCurrentProcess(t *TLS) uintptr {
	r0, _, e1 := syscall.Syscall(procGetCurrentProcess.Addr(), 0, 0, 0, 0)
	if r0 == 0 {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
	}
	return r0
}

// BOOL FlushFileBuffers(
//
//	HANDLE hFile
//
// );
func XFlushFileBuffers(t *TLS, hFile uintptr) int32 {
	err := syscall.FlushFileBuffers(syscall.Handle(hFile))
	if err != nil {
		t.setErrno(err)
		return -1
	}
	return 1

}

// DWORD GetFileType(
//
//	HANDLE hFile
//
// );
func XGetFileType(t *TLS, hFile uintptr) uint32 {
	n, err := syscall.GetFileType(syscall.Handle(hFile))
	if err != nil {
		t.setErrno(err)
	}
	return n
}

// BOOL WINAPI GetConsoleMode(
//
//	_In_  HANDLE  hConsoleHandle,
//	_Out_ LPDWORD lpMode
//
// );
func XGetConsoleMode(t *TLS, hConsoleHandle, lpMode uintptr) int32 {
	err := syscall.GetConsoleMode(syscall.Handle(hConsoleHandle), (*uint32)(unsafe.Pointer(lpMode)))
	if err != nil {
		t.setErrno(err)
		return 0
	}
	return 1
}

// BOOL GetCommState(
//
//	HANDLE hFile,
//	LPDCB  lpDCB
//
// );
func XGetCommState(t *TLS, hFile, lpDCB uintptr) int32 {
	r1, _, err := syscall.Syscall(procGetCommState.Addr(), 2, hFile, lpDCB, 0)
	if r1 == 0 {
		t.setErrno(err)
		return 0
	}
	return int32(r1)
}

// int _wcsnicmp(
//
//	const wchar_t *string1,
//	const wchar_t *string2,
//	size_t count
//
// );
func X_wcsnicmp(t *TLS, string1, string2 uintptr, count types.Size_t) int32 {

	var s1 = strings.ToLower(goWideString(string1))
	var l1 = len(s1)
	var s2 = strings.ToLower(goWideString(string2))
	var l2 = len(s2)

	// shorter is lesser
	if l1 < l2 {
		return -1
	}
	if l2 > l1 {
		return 1
	}

	// compare at most count
	var cmpLen = count
	if types.Size_t(l1) < cmpLen {
		cmpLen = types.Size_t(l1)
	}
	return int32(strings.Compare(s1[:cmpLen], s2[:cmpLen]))
}

// BOOL WINAPI ReadConsole(
//
//	_In_     HANDLE  hConsoleInput,
//	_Out_    LPVOID  lpBuffer,
//	_In_     DWORD   nNumberOfCharsToRead,
//	_Out_    LPDWORD lpNumberOfCharsRead,
//	_In_opt_ LPVOID  pInputControl
//
// );
func XReadConsoleW(t *TLS, hConsoleInput, lpBuffer uintptr, nNumberOfCharsToRead uint32, lpNumberOfCharsRead, pInputControl uintptr) int32 {

	rv, _, err := syscall.Syscall6(procReadConsoleW.Addr(), 5, hConsoleInput,
		lpBuffer, uintptr(nNumberOfCharsToRead), lpNumberOfCharsRead, pInputControl, 0)
	if rv == 0 {
		t.setErrno(err)
	}

	return int32(rv)
}

// BOOL WINAPI WriteConsoleW(
//
//	_In_             HANDLE  hConsoleOutput,
//	_In_       const VOID    *lpBuffer,
//	_In_             DWORD   nNumberOfCharsToWrite,
//	_Out_opt_        LPDWORD lpNumberOfCharsWritten,
//	_Reserved_       LPVOID  lpReserved
//
// );
func XWriteConsoleW(t *TLS, hConsoleOutput, lpBuffer uintptr, nNumberOfCharsToWrite uint32, lpNumberOfCharsWritten, lpReserved uintptr) int32 {
	rv, _, err := syscall.Syscall6(procWriteConsoleW.Addr(), 5, hConsoleOutput,
		lpBuffer, uintptr(nNumberOfCharsToWrite), lpNumberOfCharsWritten, lpReserved, 0)
	if rv == 0 {
		t.setErrno(err)
	}
	return int32(rv)
}

// DWORD WaitForSingleObject(
//
//	HANDLE hHandle,
//	DWORD  dwMilliseconds
//
// );
func XWaitForSingleObject(t *TLS, hHandle uintptr, dwMilliseconds uint32) uint32 {
	rv, err := syscall.WaitForSingleObject(syscall.Handle(hHandle), dwMilliseconds)
	if err != nil {
		t.setErrno(err)
	}
	return rv
}

// BOOL ResetEvent(
//
//	HANDLE hEvent
//
// );
func XResetEvent(t *TLS, hEvent uintptr) int32 {
	rv, _, err := syscall.Syscall(procResetEvent.Addr(), 1, hEvent, 0, 0)
	if rv == 0 {
		t.setErrno(err)
	}
	return int32(rv)
}

// BOOL WINAPI PeekConsoleInput(
//
//	_In_  HANDLE        hConsoleInput,
//	_Out_ PINPUT_RECORD lpBuffer,
//	_In_  DWORD         nLength,
//	_Out_ LPDWORD       lpNumberOfEventsRead
//
// );
func XPeekConsoleInputW(t *TLS, hConsoleInput, lpBuffer uintptr, nLength uint32, lpNumberOfEventsRead uintptr) int32 {
	r0, _, err := syscall.Syscall6(procPeekConsoleInputW.Addr(), 4, hConsoleInput, lpBuffer, uintptr(nLength), lpNumberOfEventsRead, 0, 0)
	if r0 == 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// int WINAPIV wsprintfA(
//
//	LPSTR  ,
//	LPCSTR ,
//	...
//
// );
func XwsprintfA(t *TLS, buf, format, args uintptr) int32 {
	return Xsprintf(t, buf, format, args)
}

// UINT WINAPI GetConsoleCP(void);
func XGetConsoleCP(t *TLS) uint32 {
	r0, _, err := syscall.Syscall(procGetConsoleCP.Addr(), 0, 0, 0, 0)
	if r0 == 0 {
		t.setErrno(err)
	}
	return uint32(r0)
}

// UINT WINAPI SetConsoleCP(UNIT);
//func setConsoleCP(cp uint32) uint32 {
//
//	r0, _, _ := syscall.Syscall(procSetConsoleCP.Addr(), 1, uintptr(cp), 0, 0)
//	if r0 == 0 {
//		panic("setcp failed")
//	}
//	return uint32(r0)
//}

// HANDLE CreateEventW(
//
//	LPSECURITY_ATTRIBUTES lpEventAttributes,
//	BOOL                  bManualReset,
//	BOOL                  bInitialState,
//	LPCWSTR               lpName
//
// );
func XCreateEventW(t *TLS, lpEventAttributes uintptr, bManualReset, bInitialState int32, lpName uintptr) uintptr {
	r0, _, err := syscall.Syscall6(procCreateEventW.Addr(), 4, lpEventAttributes, uintptr(bManualReset),
		uintptr(bInitialState), lpName, 0, 0)
	if r0 == 0 {
		t.setErrno(err)
	}
	return r0
}

type ThreadAdapter struct {
	token      uintptr
	tls        *TLS
	param      uintptr
	threadFunc func(*TLS, uintptr) uint32
}

func (ta *ThreadAdapter) run() uintptr {
	r := ta.threadFunc(ta.tls, ta.param)
	ta.tls.Close()
	removeObject(ta.token)
	return uintptr(r)
}

func ThreadProc(p uintptr) uintptr {
	adp, ok := winGetObject(p).(*ThreadAdapter)
	if !ok {
		panic("invalid thread")
	}
	return adp.run()
}

// HANDLE CreateThread(
//
//	LPSECURITY_ATTRIBUTES   lpThreadAttributes,
//	SIZE_T                  dwStackSize,
//	LPTHREAD_START_ROUTINE  lpStartAddress,
//	__drv_aliasesMem LPVOID lpParameter,
//	DWORD                   dwCreationFlags,
//	LPDWORD                 lpThreadId
//
// );
func XCreateThread(t *TLS, lpThreadAttributes uintptr, dwStackSize types.Size_t, lpStartAddress, lpParameter uintptr, dwCreationFlags uint32, lpThreadId uintptr) uintptr {
	f := (*struct{ f func(*TLS, uintptr) uint32 })(unsafe.Pointer(&struct{ uintptr }{lpStartAddress})).f
	var tAdp = ThreadAdapter{threadFunc: f, tls: NewTLS(), param: lpParameter}
	tAdp.token = addObject(&tAdp)

	r0, _, err := syscall.Syscall6(procCreateThread.Addr(), 6, lpThreadAttributes, uintptr(dwStackSize),
		threadCallback, tAdp.token, uintptr(dwCreationFlags), lpThreadId)
	if r0 == 0 {
		t.setErrno(err)
	}
	return r0
}

// BOOL SetThreadPriority(
//
//	HANDLE hThread,
//	int    nPriority
//
// );
func XSetThreadPriority(t *TLS, hThread uintptr, nPriority int32) int32 {

	//r0, _, err := syscall.Syscall(procSetThreadPriority.Addr(), 2, hThread, uintptr(nPriority), 0)
	//if r0 == 0 {
	//	t.setErrno(err)
	//}
	//return int32(r0)
	return 1
}

// BOOL WINAPI SetConsoleMode(
//
//	_In_ HANDLE hConsoleHandle,
//	_In_ DWORD  dwMode
//
// );
func XSetConsoleMode(t *TLS, hConsoleHandle uintptr, dwMode uint32) int32 {
	rv, _, err := syscall.Syscall(procSetConsoleMode.Addr(), 2, hConsoleHandle, uintptr(dwMode), 0)
	if rv == 0 {
		t.setErrno(err)
	}
	return int32(rv)
}

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

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

// void DeleteCriticalSection(
//
//	LPCRITICAL_SECTION lpCriticalSection
//
// );
func XDeleteCriticalSection(t *TLS, lpCriticalSection uintptr) {
	syscall.Syscall(procDeleteCriticalSection.Addr(), 1, lpCriticalSection, 0, 0)
}

// void EnterCriticalSection(
//
//	LPCRITICAL_SECTION lpCriticalSection
//
// );
func XEnterCriticalSection(t *TLS, lpCriticalSection uintptr) {
	syscall.Syscall(procEnterCriticalSection.Addr(), 1, lpCriticalSection, 0, 0)
}

// void LeaveCriticalSection(
//
//	LPCRITICAL_SECTION lpCriticalSection
//
// );
func XLeaveCriticalSection(t *TLS, lpCriticalSection uintptr) {
	syscall.Syscall(procLeaveCriticalSection.Addr(), 1, lpCriticalSection, 0, 0)
}

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

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

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

// void InitializeCriticalSection(
//
//	LPCRITICAL_SECTION lpCriticalSection
//
// );
func XInitializeCriticalSection(t *TLS, lpCriticalSection uintptr) {
	// InitializeCriticalSection always succeeds, even in low memory situations.
	syscall.Syscall(procInitializeCriticalSection.Addr(), 1, lpCriticalSection, 0, 0)
}

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

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

func X_strnicmp(t *TLS, _ ...interface{}) int32 {
	panic(todo(""))
}

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

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

// BOOL MoveFileW(
//
//	LPCWSTR lpExistingFileName,
//	LPCWSTR lpNewFileName
//
// );
func XMoveFileW(t *TLS, lpExistingFileName, lpNewFileName uintptr) int32 {
	r0, _, err := syscall.Syscall(procMoveFileW.Addr(), 2, lpExistingFileName, lpNewFileName, 0)
	if err != 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// DWORD GetFullPathNameW(
//
//	LPCWSTR lpFileName,
//	DWORD   nBufferLength,
//	LPWSTR  lpBuffer,
//	LPWSTR  *lpFilePart
//
// );
func XGetFullPathNameW(t *TLS, lpFileName uintptr, nBufferLength uint32, lpBuffer, lpFilePart uintptr) uint32 {
	r0, _, e1 := syscall.Syscall6(procGetFullPathNameW.Addr(), 4, lpFileName, uintptr(nBufferLength), uintptr(lpBuffer), uintptr(lpFilePart), 0, 0)
	n := uint32(r0)
	if n == 0 {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
	}
	return n
}

// LPWSTR CharLowerW(
//
//	LPWSTR lpsz
//
// );
func XCharLowerW(t *TLS, lpsz uintptr) uintptr {
	panic(todo(""))
}

// BOOL CreateDirectoryW(
//
//	LPCWSTR                lpPathName,
//	LPSECURITY_ATTRIBUTES lpSecurityAttributes
//
// );
func XCreateDirectoryW(t *TLS, lpPathName, lpSecurityAttributes uintptr) int32 {
	err := syscall.CreateDirectory((*uint16)(unsafe.Pointer(lpPathName)),
		(*syscall.SecurityAttributes)(unsafe.Pointer(lpSecurityAttributes)))
	if err != nil {
		t.setErrno(err)
		return 0
	}
	return 1
}

// BOOL SetFileAttributesW(
//
//	LPCWSTR lpFileName,
//	DWORD   dwFileAttributes
//
// );
func XSetFileAttributesW(t *TLS, lpFileName uintptr, dwFileAttributes uint32) int32 {
	err := syscall.SetFileAttributes((*uint16)(unsafe.Pointer(lpFileName)), dwFileAttributes)
	if err != nil {
		t.setErrno(err)
		return 0
	}
	return 1
}

// UINT GetTempFileNameW(
//
//	LPCWSTR lpPathName,
//	LPCWSTR lpPrefixString,
//	UINT    uUnique,
//	LPWSTR  lpTempFileName
//
// );
func XGetTempFileNameW(t *TLS, lpPathName, lpPrefixString uintptr, uUnique uint32, lpTempFileName uintptr) uint32 {
	r0, _, e1 := syscall.Syscall6(procGetTempFileNameW.Addr(), 4, lpPathName, lpPrefixString, uintptr(uUnique), lpTempFileName, 0, 0)
	if r0 == 0 {
		t.setErrno(e1)
	}
	return uint32(r0)
}

// BOOL CopyFileW(
//
//	LPCWSTR lpExistingFileName,
//	LPCWSTR lpNewFileName,
//	BOOL    bFailIfExists
//
// );
func XCopyFileW(t *TLS, lpExistingFileName, lpNewFileName uintptr, bFailIfExists int32) int32 {
	r0, _, e1 := syscall.Syscall(procCopyFileW.Addr(), 3, lpExistingFileName, lpNewFileName, uintptr(bFailIfExists))
	if r0 == 0 {
		t.setErrno(e1)
	}
	return int32(r0)
}

// BOOL DeleteFileW(
//
//	LPCWSTR lpFileName
//
// );
func XDeleteFileW(t *TLS, lpFileName uintptr) int32 {
	err := syscall.DeleteFile((*uint16)(unsafe.Pointer(lpFileName)))
	if err != nil {
		t.setErrno(err)
		return 0
	}
	return 1
}

// BOOL RemoveDirectoryW(
//
//	LPCWSTR lpPathName
//
// );
func XRemoveDirectoryW(t *TLS, lpPathName uintptr) int32 {
	err := syscall.RemoveDirectory((*uint16)(unsafe.Pointer(lpPathName)))
	if err != nil {
		t.setErrno(err)
		return 0
	}
	return 1
}

// HANDLE FindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData);
func XFindFirstFileW(t *TLS, lpFileName, lpFindFileData uintptr) uintptr {
	r0, _, e1 := syscall.Syscall(procFindFirstFileW.Addr(), 2, lpFileName, lpFindFileData, 0)
	handle := syscall.Handle(r0)
	if handle == syscall.InvalidHandle {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
	}
	return r0
}

// HANDLE FindFirstFileExW(
//
//	LPCWSTR            lpFileName,
//	FINDEX_INFO_LEVELS fInfoLevelId,
//	LPVOID             lpFindFileData,
//	FINDEX_SEARCH_OPS  fSearchOp,
//	LPVOID             lpSearchFilter,
//	DWORD              dwAdditionalFlags
//
// );
func XFindFirstFileExW(t *TLS, lpFileName uintptr, fInfoLevelId int32, lpFindFileData uintptr, fSearchOp int32, lpSearchFilter uintptr, dwAdditionalFlags uint32) uintptr {
	r0, _, e1 := syscall.Syscall6(procFindFirstFileExW.Addr(), 6, lpFileName, uintptr(fInfoLevelId), lpFindFileData, uintptr(fSearchOp), lpSearchFilter, uintptr(dwAdditionalFlags))
	handle := syscall.Handle(r0)
	if handle == syscall.InvalidHandle {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
	}
	return r0
}

// BOOL FindClose(HANDLE hFindFile);
func XFindClose(t *TLS, hFindFile uintptr) int32 {
	r0, _, e1 := syscall.Syscall(procFindClose.Addr(), 1, hFindFile, 0, 0)
	if r0 == 0 {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
	}
	return int32(r0)
}

// BOOL FindNextFileW(
//
//	HANDLE             hFindFile,
//	LPWIN32_FIND_DATAW lpFindFileData
//
// );
func XFindNextFileW(t *TLS, hFindFile, lpFindFileData uintptr) int32 {
	r0, _, e1 := syscall.Syscall(procFindNextFileW.Addr(), 2, hFindFile, lpFindFileData, 0)
	if r0 == 0 {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
	}
	return int32(r0)
}

// DWORD GetLogicalDriveStringsA(
//
//	DWORD nBufferLength,
//	LPSTR lpBuffer
//
// );
func XGetLogicalDriveStringsA(t *TLS, nBufferLength uint32, lpBuffer uintptr) uint32 {
	r0, _, err := syscall.Syscall(procGetLogicalDriveStringsA.Addr(), 2, uintptr(nBufferLength), lpBuffer, 0)
	if err != 0 {
		t.setErrno(err)
	}
	return uint32(r0)
}

// BOOL GetVolumeInformationA(
//
//	LPCSTR  lpRootPathName,
//	LPSTR   lpVolumeNameBuffer,
//	DWORD   nVolumeNameSize,
//	LPDWORD lpVolumeSerialNumber,
//	LPDWORD lpMaximumComponentLength,
//	LPDWORD lpFileSystemFlags,
//	LPSTR   lpFileSystemNameBuffer,
//	DWORD   nFileSystemNameSize
//
// );
func XGetVolumeInformationA(t *TLS, lpRootPathName, lpVolumeNameBuffer uintptr, nVolumeNameSize uint32, lpVolumeSerialNumber, lpMaximumComponentLength, lpFileSystemFlags, lpFileSystemNameBuffer uintptr, nFileSystemNameSize uint32) int32 {
	r0, _, err := syscall.Syscall9(procGetVolumeInformationA.Addr(), 8,
		lpRootPathName,
		lpVolumeNameBuffer,
		uintptr(nVolumeNameSize),
		lpVolumeSerialNumber,
		lpMaximumComponentLength,
		lpFileSystemFlags,
		lpFileSystemNameBuffer,
		uintptr(nFileSystemNameSize),
		0,
	)
	if err != 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// BOOL CreateHardLinkW(
//
//	LPCWSTR               lpFileName,
//	LPCWSTR               lpExistingFileName,
//	LPSECURITY_ATTRIBUTES lpSecurityAttributes
//
// );
func XCreateHardLinkW(t *TLS, lpFileName, lpExistingFileName, lpSecurityAttributes uintptr) int32 {
	r0, _, err := syscall.Syscall(procCreateHardLinkW.Addr(), 1, lpFileName, lpExistingFileName, lpSecurityAttributes)
	if err != 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// BOOL DeviceIoControl(
//
//	HANDLE       hDevice,
//	DWORD        dwIoControlCode,
//	LPVOID       lpInBuffer,
//	DWORD        nInBufferSize,
//	LPVOID       lpOutBuffer,
//	DWORD        nOutBufferSize,
//	LPDWORD      lpBytesReturned,
//	LPOVERLAPPED lpOverlapped
//
// );
func XDeviceIoControl(t *TLS, hDevice uintptr, dwIoControlCode uint32, lpInBuffer uintptr, nInBufferSize uint32, lpOutBuffer uintptr, nOutBufferSize uint32, lpBytesReturned, lpOverlapped uintptr) int32 {
	r0, _, err := syscall.Syscall9(procDeviceIoControl.Addr(), 8, hDevice, uintptr(dwIoControlCode), lpInBuffer,
		uintptr(nInBufferSize), lpOutBuffer, uintptr(nOutBufferSize), lpBytesReturned, lpOverlapped, 0)
	if r0 == 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// int wcsncmp(
//
//	const wchar_t *string1,
//	const wchar_t *string2,
//	size_t count
//
// );
func Xwcsncmp(t *TLS, string1, string2 uintptr, count types.Size_t) int32 {
	var s1 = goWideString(string1)
	var l1 = len(s1)
	var s2 = goWideString(string2)
	var l2 = len(s2)

	// shorter is lesser
	if l1 < l2 {
		return -1
	}
	if l2 > l1 {
		return 1
	}

	// compare at most count
	var cmpLen = count
	if types.Size_t(l1) < cmpLen {
		cmpLen = types.Size_t(l1)
	}
	return int32(strings.Compare(s1[:cmpLen], s2[:cmpLen]))
}

// int MultiByteToWideChar(
//
//	UINT                              CodePage,
//	DWORD                             dwFlags,
//	_In_NLS_string_(cbMultiByte)LPCCH lpMultiByteStr,
//	int                               cbMultiByte,
//	LPWSTR                            lpWideCharStr,
//	int                               cchWideChar
//
// );
func XMultiByteToWideChar(t *TLS, CodePage uint32, dwFlags uint32, lpMultiByteStr uintptr, cbMultiByte int32, lpWideCharStr uintptr, cchWideChar int32) int32 {
	r1, _, _ := syscall.Syscall6(procMultiByteToWideChar.Addr(), 6,
		uintptr(CodePage), uintptr(dwFlags), uintptr(lpMultiByteStr),
		uintptr(cbMultiByte), uintptr(lpWideCharStr), uintptr(cchWideChar))
	return (int32(r1))
}

// void OutputDebugStringW(
//
//	LPCWSTR lpOutputString
//
// );
func XOutputDebugStringW(t *TLS, lpOutputString uintptr) {
	panic(todo(""))
}

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

//====

// long _InterlockedCompareExchange(
//
//	long volatile * Destination,
//	long Exchange,
//	long Comparand
//
// );
func X_InterlockedCompareExchange(t *TLS, Destination uintptr, Exchange, Comparand long) long {

	// The function returns the initial value of the Destination parameter.
	var v = *(*int32)(unsafe.Pointer(Destination))
	_ = atomic.CompareAndSwapInt32((*int32)(unsafe.Pointer(Destination)), Comparand, Exchange)
	return long(v)
}

// int rename(const char *oldpath, const char *newpath);
func Xrename(t *TLS, oldpath, newpath uintptr) int32 {
	panic(todo(""))
}

// BOOL AreFileApisANSI();
func XAreFileApisANSI(t *TLS) int32 {

	r0, _, _ := syscall.Syscall(procAreFileApisANSI.Addr(), 0, 0, 0, 0)
	return int32(r0)
}

// HANDLE CreateFileA(
//
//	LPCSTR                lpFileName,
//	DWORD                 dwDesiredAccess,
//	DWORD                 dwShareMode,
//	LPSECURITY_ATTRIBUTES lpSecurityAttributes,
//	DWORD                 dwCreationDisposition,
//	DWORD                 dwFlagsAndAttributes,
//	HANDLE                hTemplateFile
//
// );
func XCreateFileA(t *TLS, lpFileName uintptr, dwDesiredAccess, dwShareMode uint32,
	lpSecurityAttributes uintptr, dwCreationDisposition, dwFlagsAndAttributes uint32, hTemplateFile uintptr) uintptr {

	r0, _, e1 := syscall.Syscall9(procCreateFileA.Addr(), 7, lpFileName, uintptr(dwDesiredAccess), uintptr(dwShareMode), lpSecurityAttributes,
		uintptr(dwCreationDisposition), uintptr(dwFlagsAndAttributes), hTemplateFile, 0, 0)
	h := syscall.Handle(r0)
	if h == syscall.InvalidHandle {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
		return r0
	}
	return uintptr(h)

}

// HANDLE CreateFileMappingA(
//
//	HANDLE                hFile,
//	LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
//	DWORD                 flProtect,
//	DWORD                 dwMaximumSizeHigh,
//	DWORD                 dwMaximumSizeLow,
//	LPCSTR                lpName
//
// );
func XCreateFileMappingA(t *TLS, hFile, lpFileMappingAttributes uintptr, flProtect, dwMaximumSizeHigh, dwMaximumSizeLow uint32, lpName uintptr) uintptr {
	panic(todo(""))
}

// HANDLE CreateFileMappingW(
//
//	HANDLE                hFile,
//	LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
//	DWORD                 flProtect,
//	DWORD                 dwMaximumSizeHigh,
//	DWORD                 dwMaximumSizeLow,
//	LPCWSTR               lpName
//
// );
func XCreateFileMappingW(t *TLS, hFile, lpFileMappingAttributes uintptr, flProtect, dwMaximumSizeHigh, dwMaximumSizeLow uint32, lpName uintptr) uintptr {
	h, _, e1 := syscall.Syscall6(procCreateFileMappingW.Addr(), 6, hFile, lpFileMappingAttributes, uintptr(flProtect),
		uintptr(dwMaximumSizeHigh), uintptr(dwMaximumSizeLow), lpName)
	if h == 0 {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
	}
	return h
}

// HANDLE CreateMutexW(
//
//	LPSECURITY_ATTRIBUTES lpMutexAttributes,
//	BOOL                  bInitialOwner,
//	LPCWSTR               lpName
//
// );
func XCreateMutexW(t *TLS, lpMutexAttributes uintptr, bInitialOwner int32, lpName uintptr) uintptr {
	panic(todo(""))
}

// BOOL DeleteFileA(
//
//	LPCSTR lpFileName
//
// );
func XDeleteFileA(t *TLS, lpFileName uintptr) int32 {
	panic(todo(""))
}

// DWORD FormatMessageA(
//
//	DWORD   dwFlags,
//	LPCVOID lpSource,
//	DWORD   dwMessageId,
//	DWORD   dwLanguageId,
//	LPSTR   lpBuffer,
//	DWORD   nSize,
//	va_list *Arguments
//
// );
func XFormatMessageA(t *TLS, dwFlagsAndAttributes uint32, lpSource uintptr, dwMessageId, dwLanguageId uint32, lpBuffer uintptr, nSize uint32, Arguments uintptr) uint32 {
	panic(todo(""))
}

// DWORD FormatMessageW(
//
//	DWORD   dwFlags,
//	LPCVOID lpSource,
//	DWORD   dwMessageId,
//	DWORD   dwLanguageId,
//	LPWSTR  lpBuffer,
//	DWORD   nSize,
//	va_list *Arguments
//
// );
func XFormatMessageW(t *TLS, dwFlags uint32, lpSource uintptr, dwMessageId, dwLanguageId uint32, lpBuffer uintptr, nSize uint32, Arguments uintptr) uint32 {
	r0, _, e1 := syscall.Syscall9(procFormatMessageW.Addr(), 7,
		uintptr(dwFlags), lpSource, uintptr(dwMessageId), uintptr(dwLanguageId),
		lpBuffer, uintptr(nSize), Arguments, 0, 0)
	n := uint32(r0)
	if n == 0 {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
	}
	return n
}

// BOOL FreeLibrary(HMODULE hLibModule);
func XFreeLibrary(t *TLS, hLibModule uintptr) int32 {
	panic(todo(""))
}

// DWORD GetCurrentProcessId();
func XGetCurrentProcessId(t *TLS) uint32 {
	r0, _, _ := syscall.Syscall(procGetCurrentProcessId.Addr(), 0, 0, 0, 0)
	pid := uint32(r0)
	return pid
}

// BOOL GetDiskFreeSpaceA(
//
//	LPCSTR  lpRootPathName,
//	LPDWORD lpSectorsPerCluster,
//	LPDWORD lpBytesPerSector,
//	LPDWORD lpNumberOfFreeClusters,
//	LPDWORD lpTotalNumberOfClusters
//
// );
func XGetDiskFreeSpaceA(t *TLS, lpRootPathName, lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters uintptr) int32 {
	panic(todo(""))
}

// BOOL GetDiskFreeSpaceW(
//
//	LPCWSTR lpRootPathName,
//	LPDWORD lpSectorsPerCluster,
//	LPDWORD lpBytesPerSector,
//	LPDWORD lpNumberOfFreeClusters,
//	LPDWORD lpTotalNumberOfClusters
//
// );
func XGetDiskFreeSpaceW(t *TLS, lpRootPathName, lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters uintptr) int32 {
	panic(todo(""))
}

// DWORD GetFileAttributesA(
//
//	LPCSTR lpFileName
//
// );
func XGetFileAttributesA(t *TLS, lpFileName uintptr) uint32 {
	r0, _, err := syscall.Syscall(procGetFileAttributesA.Addr(), 1, lpFileName, 0, 0)
	if err != 0 {
		t.setErrno(err)
	}
	return uint32(r0)
}

// BOOL GetFileAttributesExW(
//
//	LPCWSTR                lpFileName,
//	GET_FILEEX_INFO_LEVELS fInfoLevelId,
//	LPVOID                 lpFileInformation
//
// );
func XGetFileAttributesExW(t *TLS, lpFileName uintptr, fInfoLevelId uint32, lpFileInformation uintptr) int32 {
	r1, _, e1 := syscall.Syscall(procGetFileAttributesExW.Addr(), 3, lpFileName, uintptr(fInfoLevelId), lpFileInformation)
	if r1 == 0 {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
		return 0
	}
	return int32(r1)
}

// DWORD GetFileSize(
//
//	HANDLE  hFile,
//	LPDWORD lpFileSizeHigh
//
// );
func XGetFileSize(t *TLS, hFile, lpFileSizeHigh uintptr) uint32 {
	r1, _, e1 := syscall.Syscall(procGetFileSize.Addr(), 2, hFile, lpFileSizeHigh, 0)
	if r1 == math.MaxUint32 {
		if lpFileSizeHigh == 0 {
			// If the function fails and lpFileSizeHigh is NULL, the return value is INVALID_FILE_SIZE.
			// Note that if the return value is INVALID_FILE_SIZE (0xffffffff),
			// an application must call GetLastError to determine whether the function has succeeded or failed.
			t.setErrno(e1)
			return math.MaxUint32
		} else {
			// If the function fails and lpFileSizeHigh is non-NULL, the return value is INVALID_FILE_SIZE
			// and GetLastError will return a value other than NO_ERROR.
			t.setErrno(e1)
			return math.MaxUint32
		}
	}
	return uint32(r1)
}

// DWORD GetFullPathNameA(
//
//	LPCSTR lpFileName,
//	DWORD  nBufferLength,
//	LPSTR  lpBuffer,
//	LPSTR  *lpFilePart
//
// );
func XGetFullPathNameA(t *TLS, lpFileName uintptr, nBufferLength uint32, lpBuffer, lpFilePart uintptr) uint32 {
	panic(todo(""))
}

// FARPROC GetProcAddress(HMODULE hModule, LPCSTR  lpProcName);
func XGetProcAddress(t *TLS, hModule, lpProcName uintptr) uintptr {

	return 0

	//panic(todo(GoString(lpProcName)))
	//
	//r0, _, err := syscall.Syscall(procGetProcAddress.Addr(), 2, hModule, lpProcName, 0)
	//if r0 == 0 {
	//	t.setErrno(err)
	//}
	//return r0
}

// NTSYSAPI NTSTATUS RtlGetVersion( // ntdll.dll
//
//	PRTL_OSVERSIONINFOW lpVersionInformation
//
// );
func XRtlGetVersion(t *TLS, lpVersionInformation uintptr) uintptr {
	panic(todo(""))
}

// void GetSystemInfo(
//
//	LPSYSTEM_INFO lpSystemInfo
//
// );
func XGetSystemInfo(t *TLS, lpSystemInfo uintptr) {
	syscall.Syscall(procGetSystemInfo.Addr(), 1, lpSystemInfo, 0, 0)
}

// void GetSystemTime(LPSYSTEMTIME lpSystemTime);
func XGetSystemTime(t *TLS, lpSystemTime uintptr) {
	syscall.Syscall(procGetSystemTime.Addr(), 1, lpSystemTime, 0, 0)
}

// void GetSystemTimeAsFileTime(
//
//	LPFILETIME lpSystemTimeAsFileTime
//
// );
func XGetSystemTimeAsFileTime(t *TLS, lpSystemTimeAsFileTime uintptr) {
	syscall.Syscall(procGetSystemTimeAsFileTime.Addr(), 1, lpSystemTimeAsFileTime, 0, 0)
}

// DWORD GetTempPathA(
//
//	DWORD nBufferLength,
//	LPSTR lpBuffer
//
// );
func XGetTempPathA(t *TLS, nBufferLength uint32, lpBuffer uintptr) uint32 {
	panic(todo(""))
}

// DWORD GetTempPathW(
//
//	DWORD  nBufferLength,
//	LPWSTR lpBuffer
//
// );
func XGetTempPathW(t *TLS, nBufferLength uint32, lpBuffer uintptr) uint32 {
	rv, err := syscall.GetTempPath(nBufferLength, (*uint16)(unsafe.Pointer(lpBuffer)))
	if err != nil {
		t.setErrno(err)
	}
	return rv
}

// DWORD GetTickCount();
func XGetTickCount(t *TLS) uint32 {
	r0, _, _ := syscall.Syscall(procGetTickCount.Addr(), 0, 0, 0, 0)
	return uint32(r0)
}

// BOOL GetVersionExA(
//
//	LPOSVERSIONINFOA lpVersionInformation
//
// );
func XGetVersionExA(t *TLS, lpVersionInformation uintptr) int32 {
	r0, _, err := syscall.Syscall(procGetVersionExA.Addr(), 1, lpVersionInformation, 0, 0)
	if r0 == 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// HANDLE HeapCreate(
//
//	DWORD  flOptions,
//	SIZE_T dwInitialSize,
//	SIZE_T dwMaximumSize
//
// );
func XHeapCreate(t *TLS, flOptions uint32, dwInitialSize, dwMaximumSize types.Size_t) uintptr {
	panic(todo(""))
}

// BOOL HeapDestroy(
//
//	HANDLE hHeap
//
// );
func XHeapDestroy(t *TLS, hHeap uintptr) int32 {
	panic(todo(""))
}

// LPVOID HeapReAlloc(
//
//	HANDLE                 hHeap,
//	DWORD                  dwFlags,
//	_Frees_ptr_opt_ LPVOID lpMem,
//	SIZE_T                 dwBytes
//
// );
func XHeapReAlloc(t *TLS, hHeap uintptr, dwFlags uint32, lpMem uintptr, dwBytes types.Size_t) uintptr {
	panic(todo(""))
}

// SIZE_T HeapSize(
//
//	HANDLE  hHeap,
//	DWORD   dwFlags,
//	LPCVOID lpMem
//
// );
func XHeapSize(t *TLS, hHeap uintptr, dwFlags uint32, lpMem uintptr) types.Size_t {
	panic(todo(""))
}

// BOOL HeapValidate(
//
//	HANDLE  hHeap,
//	DWORD   dwFlags,
//	LPCVOID lpMem
//
// );
func XHeapValidate(t *TLS, hHeap uintptr, dwFlags uint32, lpMem uintptr) int32 {
	panic(todo(""))
}

// SIZE_T HeapCompact(
//
//	HANDLE hHeap,
//	DWORD  dwFlags
//
// );
func XHeapCompact(t *TLS, hHeap uintptr, dwFlags uint32) types.Size_t {
	panic(todo(""))
}

// HMODULE LoadLibraryA(LPCSTR lpLibFileName);
func XLoadLibraryA(t *TLS, lpLibFileName uintptr) uintptr {
	panic(todo(""))
}

// HMODULE LoadLibraryW(
//
//	LPCWSTR lpLibFileName
//
// );
func XLoadLibraryW(t *TLS, lpLibFileName uintptr) uintptr {
	panic(todo(""))
}

// HLOCAL LocalFree(
//
//	HLOCAL hMem
//
// );
func XLocalFree(t *TLS, hMem uintptr) uintptr {
	h, err := syscall.LocalFree(syscall.Handle(hMem))
	if h != 0 {
		if err != nil {
			t.setErrno(err)
		} else {
			t.setErrno(errno.EINVAL)
		}
		return uintptr(h)
	}
	return 0
}

// BOOL LockFile(
//
//	HANDLE hFile,
//	DWORD  dwFileOffsetLow,
//	DWORD  dwFileOffsetHigh,
//	DWORD  nNumberOfBytesToLockLow,
//	DWORD  nNumberOfBytesToLockHigh
//
// );
func XLockFile(t *TLS, hFile uintptr, dwFileOffsetLow, dwFileOffsetHigh, nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh uint32) int32 {

	r1, _, e1 := syscall.Syscall6(procLockFile.Addr(), 5,
		hFile, uintptr(dwFileOffsetLow), uintptr(dwFileOffsetHigh), uintptr(nNumberOfBytesToLockLow), uintptr(nNumberOfBytesToLockHigh), 0)
	if r1 == 0 {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
		return 0
	}
	return int32(r1)

}

// BOOL LockFileEx(
//
//	HANDLE       hFile,
//	DWORD        dwFlags,
//	DWORD        dwReserved,
//	DWORD        nNumberOfBytesToLockLow,
//	DWORD        nNumberOfBytesToLockHigh,
//	LPOVERLAPPED lpOverlapped
//
// );
func XLockFileEx(t *TLS, hFile uintptr, dwFlags, dwReserved, nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh uint32, lpOverlapped uintptr) int32 {
	r1, _, e1 := syscall.Syscall6(procLockFileEx.Addr(), 6,
		hFile, uintptr(dwFlags), uintptr(dwReserved), uintptr(nNumberOfBytesToLockLow), uintptr(nNumberOfBytesToLockHigh), lpOverlapped)
	if r1 == 0 {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
		return 0
	}
	return int32(r1)
}

// LPVOID MapViewOfFile(
//
//	HANDLE hFileMappingObject,
//	DWORD  dwDesiredAccess,
//	DWORD  dwFileOffsetHigh,
//	DWORD  dwFileOffsetLow,
//	SIZE_T dwNumberOfBytesToMap
//
// );
func XMapViewOfFile(t *TLS, hFileMappingObject uintptr, dwDesiredAccess, dwFileOffsetHigh, dwFileOffsetLow uint32, dwNumberOfBytesToMap types.Size_t) uintptr {
	h, _, e1 := syscall.Syscall6(procMapViewOfFile.Addr(), 5, hFileMappingObject, uintptr(dwDesiredAccess),
		uintptr(dwFileOffsetHigh), uintptr(dwFileOffsetLow), uintptr(dwNumberOfBytesToMap), 0)
	if h == 0 {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
	}
	return h
}

// BOOL QueryPerformanceCounter(
//
//	LARGE_INTEGER *lpPerformanceCount
//
// );
func XQueryPerformanceCounter(t *TLS, lpPerformanceCount uintptr) int32 {
	r0, _, _ := syscall.Syscall(procQueryPerformanceCounter.Addr(), 1, lpPerformanceCount, 0, 0)
	return int32(r0)
}

// void Sleep(
//
//	DWORD dwMilliseconds
//
// );
func XSleep(t *TLS, dwMilliseconds uint32) {
	gotime.Sleep(gotime.Duration(dwMilliseconds) * gotime.Millisecond)
}

// BOOL SystemTimeToFileTime(const SYSTEMTIME *lpSystemTime, LPFILETIME lpFileTime);
func XSystemTimeToFileTime(t *TLS, lpSystemTime, lpFileTime uintptr) int32 {
	r0, _, _ := syscall.Syscall(procSystemTimeToFileTime.Addr(), 2, lpSystemTime, lpFileTime, 0)
	return int32(r0)
}

// BOOL UnlockFile(
//
//	HANDLE hFile,
//	DWORD  dwFileOffsetLow,
//	DWORD  dwFileOffsetHigh,
//	DWORD  nNumberOfBytesToUnlockLow,
//	DWORD  nNumberOfBytesToUnlockHigh
//
// );
func XUnlockFile(t *TLS, hFile uintptr, dwFileOffsetLow, dwFileOffsetHigh, nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh uint32) int32 {
	r1, _, e1 := syscall.Syscall6(procUnlockFile.Addr(), 5,
		hFile, uintptr(dwFileOffsetLow), uintptr(dwFileOffsetHigh), uintptr(nNumberOfBytesToUnlockLow), uintptr(nNumberOfBytesToUnlockHigh), 0)
	if r1 == 0 {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
		return 0
	}
	return int32(r1)
}

// BOOL UnlockFileEx(
//
//	HANDLE       hFile,
//	DWORD        dwReserved,
//	DWORD        nNumberOfBytesToUnlockLow,
//	DWORD        nNumberOfBytesToUnlockHigh,
//	LPOVERLAPPED lpOverlapped
//
// );
func XUnlockFileEx(t *TLS, hFile uintptr, dwReserved, nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh uint32, lpOverlapped uintptr) int32 {
	r1, _, e1 := syscall.Syscall6(procUnlockFileEx.Addr(), 5,
		hFile, uintptr(dwReserved), uintptr(nNumberOfBytesToUnlockLow), uintptr(nNumberOfBytesToUnlockHigh), lpOverlapped, 0)
	if r1 == 0 {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
		return 0
	}
	return int32(r1)
}

// BOOL UnmapViewOfFile(
//
//	LPCVOID lpBaseAddress
//
// );
func XUnmapViewOfFile(t *TLS, lpBaseAddress uintptr) int32 {
	err := syscall.UnmapViewOfFile(lpBaseAddress)
	if err != nil {
		t.setErrno(err)
		return 0
	}
	return 1
}

// int WideCharToMultiByte(
//
//	UINT                               CodePage,
//	DWORD                              dwFlags,
//	_In_NLS_string_(cchWideChar)LPCWCH lpWideCharStr,
//	int                                cchWideChar,
//	LPSTR                              lpMultiByteStr,
//	int                                cbMultiByte,
//	LPCCH                              lpDefaultChar,
//	LPBOOL                             lpUsedDefaultChar
//
// );
func XWideCharToMultiByte(t *TLS, CodePage uint32, dwFlags uint32, lpWideCharStr uintptr, cchWideChar int32, lpMultiByteStr uintptr, cbMultiByte int32, lpDefaultChar, lpUsedDefaultChar uintptr) int32 {
	r1, _, _ := syscall.Syscall9(procWideCharToMultiByte.Addr(), 8,
		uintptr(CodePage), uintptr(dwFlags), lpWideCharStr,
		uintptr(cchWideChar), lpMultiByteStr, uintptr(cbMultiByte),
		lpDefaultChar, lpUsedDefaultChar, 0)
	return (int32(r1))
}

// void OutputDebugStringA(
//
//	LPCSTR lpOutputString
//
// )
func XOutputDebugStringA(t *TLS, lpOutputString uintptr) {
	panic(todo(""))
}

// BOOL FlushViewOfFile(
//
//	LPCVOID lpBaseAddress,
//	SIZE_T  dwNumberOfBytesToFlush
//
// );
func XFlushViewOfFile(t *TLS, lpBaseAddress uintptr, dwNumberOfBytesToFlush types.Size_t) int32 {
	err := syscall.FlushViewOfFile(lpBaseAddress, uintptr(dwNumberOfBytesToFlush))
	if err != nil {
		t.setErrno(err)
		return 0
	}
	return 1
}

type _ino_t = uint16 /* types.h:43:24 */
type _dev_t = uint32 /* types.h:51:22 */
type _stat64 = struct {
	Fst_dev   _dev_t
	Fst_ino   _ino_t
	Fst_mode  uint16
	Fst_nlink int16
	Fst_uid   int16
	Fst_gid   int16
	_         [2]byte
	Fst_rdev  _dev_t
	_         [4]byte
	Fst_size  int64
	Fst_atime int64
	Fst_mtime int64
	Fst_ctime int64
} /* _mingw_stat64.h:83:3 */

var (
	Windows_Tick   int64 = 10000000
	SecToUnixEpoch int64 = 11644473600
)

func WindowsTickToUnixSeconds(windowsTicks int64) int64 {
	return (windowsTicks/Windows_Tick - SecToUnixEpoch)
}

// int _stat64(const char *path, struct __stat64 *buffer);
func X_stat64(t *TLS, path, buffer uintptr) int32 {

	var fa syscall.Win32FileAttributeData
	r1, _, e1 := syscall.Syscall(procGetFileAttributesExA.Addr(), 3, path, syscall.GetFileExInfoStandard, (uintptr)(unsafe.Pointer(&fa)))
	if r1 == 0 {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
		return -1
	}

	var bStat64 = (*_stat64)(unsafe.Pointer(buffer))
	var accessTime = int64(fa.LastAccessTime.HighDateTime)<<32 + int64(fa.LastAccessTime.LowDateTime)
	bStat64.Fst_atime = WindowsTickToUnixSeconds(accessTime)
	var modTime = int64(fa.LastWriteTime.HighDateTime)<<32 + int64(fa.LastWriteTime.LowDateTime)
	bStat64.Fst_mtime = WindowsTickToUnixSeconds(modTime)
	var crTime = int64(fa.CreationTime.HighDateTime)<<32 + int64(fa.CreationTime.LowDateTime)
	bStat64.Fst_ctime = WindowsTickToUnixSeconds(crTime)
	var fSz = int64(fa.FileSizeHigh)<<32 + int64(fa.FileSizeLow)
	bStat64.Fst_size = fSz
	bStat64.Fst_mode = WindowsAttrbiutesToStat(fa.FileAttributes)

	return 0
}

func WindowsAttrbiutesToStat(fa uint32) uint16 {
	var src_mode = fa & 0xff
	var st_mode uint16
	if (src_mode & syscall.FILE_ATTRIBUTE_DIRECTORY) != 0 {
		st_mode = syscall.S_IFDIR
	} else {
		st_mode = syscall.S_IFREG
	}

	if src_mode&syscall.FILE_ATTRIBUTE_READONLY != 0 {
		st_mode = st_mode | syscall.S_IRUSR
	} else {
		st_mode = st_mode | syscall.S_IRUSR | syscall.S_IWUSR
	}
	// fill group fields
	st_mode = st_mode | (st_mode&0x700)>>3
	st_mode = st_mode | (st_mode&0x700)>>6
	return st_mode
}

// int _chsize(
//
//	int fd,
//	long size
//
// );
func X_chsize(t *TLS, fd int32, size long) int32 {

	f, ok := fdToFile(fd)
	if !ok {
		t.setErrno(EBADF)
		return -1
	}

	err := syscall.Ftruncate(f.Handle, int64(size))
	if err != nil {
		t.setErrno(err)
		return -1
	}

	return 0
}

// int _snprintf(char *str, size_t size, const char *format, ...);
func X_snprintf(t *TLS, str uintptr, size types.Size_t, format, args uintptr) int32 {
	return Xsnprintf(t, str, size, format, args)
}

const wErr_ERROR_INSUFFICIENT_BUFFER = 122

func win32FindDataToFileInfo(t *TLS, fdata *stat.X_finddata64i32_t, wfd *syscall.Win32finddata) int32 {
	// t64 = 64-bit time value
	var accessTime = int64(wfd.LastAccessTime.HighDateTime)<<32 + int64(wfd.LastAccessTime.LowDateTime)
	fdata.Ftime_access = WindowsTickToUnixSeconds(accessTime)
	var modTime = int64(wfd.LastWriteTime.HighDateTime)<<32 + int64(wfd.LastWriteTime.LowDateTime)
	fdata.Ftime_write = WindowsTickToUnixSeconds(modTime)
	var crTime = int64(wfd.CreationTime.HighDateTime)<<32 + int64(wfd.CreationTime.LowDateTime)
	fdata.Ftime_create = WindowsTickToUnixSeconds(crTime)
	// i32 = 32-bit size
	fdata.Fsize = wfd.FileSizeLow
	fdata.Fattrib = wfd.FileAttributes

	var cp = XGetConsoleCP(t)
	var wcFn = (uintptr)(unsafe.Pointer(&wfd.FileName[0]))
	var mbcsFn = (uintptr)(unsafe.Pointer(&fdata.Fname[0]))
	rv := XWideCharToMultiByte(t, cp, 0, wcFn, -1, mbcsFn, 260, 0, 0)
	if rv == wErr_ERROR_INSUFFICIENT_BUFFER {
		t.setErrno(errno.ENOMEM)
		return -1
	}
	return 0
}

// intptr_t _findfirst64i32(
//
//	const char *filespec,
//	struct _finddata64i32_t *fileinfo
//
// );
func X_findfirst64i32(t *TLS, filespec, fileinfo uintptr) types.Intptr_t {

	// Note: this is the 'narrow' character findfirst -- expects output
	// as mbcs -- conversion below -- via ToFileInfo

	var gsFileSpec = GoString(filespec)
	namep, err := syscall.UTF16PtrFromString(gsFileSpec)
	if err != nil {
		t.setErrno(err)
		return types.Intptr_t(-1)
	}

	var fdata = (*stat.X_finddata64i32_t)(unsafe.Pointer(fileinfo))
	var wfd syscall.Win32finddata
	h, err := syscall.FindFirstFile((*uint16)(unsafe.Pointer(namep)), &wfd)
	if err != nil {
		t.setErrno(err)
		return types.Intptr_t(-1)
	}
	rv := win32FindDataToFileInfo(t, fdata, &wfd)
	if rv != 0 {
		if h != 0 {
			syscall.FindClose(h)
		}
		return types.Intptr_t(-1)
	}
	return types.Intptr_t(h)
}

// int _findnext64i32(
//
//	intptr_t handle,
//	struct _finddata64i32_t *fileinfo
//
// );
func X_findnext64i32(t *TLS, handle types.Intptr_t, fileinfo uintptr) int32 {

	var fdata = (*stat.X_finddata64i32_t)(unsafe.Pointer(fileinfo))
	var wfd syscall.Win32finddata

	err := syscall.FindNextFile(syscall.Handle(handle), &wfd)
	if err != nil {
		t.setErrno(err)
		return -1
	}

	rv := win32FindDataToFileInfo(t, fdata, &wfd)
	if rv != 0 {
		return -1
	}
	return 0
}

// int _findclose(
//
//	intptr_t handle
//
// );
func X_findclose(t *TLS, handle types.Intptr_t) int32 {

	err := syscall.FindClose(syscall.Handle(handle))
	if err != nil {
		t.setErrno(err)
		return -1
	}
	return 0
}

// DWORD GetEnvironmentVariableA(
//
//	LPCSTR lpName,
//	LPSTR  lpBuffer,
//	DWORD  nSize
//
// );
func XGetEnvironmentVariableA(t *TLS, lpName, lpBuffer uintptr, nSize uint32) uint32 {
	r0, _, e1 := syscall.Syscall(procGetEnvironmentVariableA.Addr(), 3, lpName, lpBuffer, uintptr(nSize))
	n := uint32(r0)
	if n == 0 {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
	}
	return n
}

// int _fstat64(
//
//	int fd,
//	struct __stat64 *buffer
//
// );
func X_fstat64(t *TLS, fd int32, buffer uintptr) int32 {

	f, ok := fdToFile(fd)
	if !ok {
		t.setErrno(EBADF)
		return -1
	}

	var d syscall.ByHandleFileInformation
	err := syscall.GetFileInformationByHandle(f.Handle, &d)
	if err != nil {
		t.setErrno(EBADF)
		return -1
	}

	var bStat64 = (*_stat64)(unsafe.Pointer(buffer))
	var accessTime = int64(d.LastAccessTime.HighDateTime)<<32 + int64(d.LastAccessTime.LowDateTime)
	bStat64.Fst_atime = WindowsTickToUnixSeconds(accessTime)
	var modTime = int64(d.LastWriteTime.HighDateTime)<<32 + int64(d.LastWriteTime.LowDateTime)
	bStat64.Fst_mtime = WindowsTickToUnixSeconds(modTime)
	var crTime = int64(d.CreationTime.HighDateTime)<<32 + int64(d.CreationTime.LowDateTime)
	bStat64.Fst_ctime = WindowsTickToUnixSeconds(crTime)
	var fSz = int64(d.FileSizeHigh)<<32 + int64(d.FileSizeLow)
	bStat64.Fst_size = fSz
	bStat64.Fst_mode = WindowsAttrbiutesToStat(d.FileAttributes)

	return 0
}

// HANDLE CreateEventA(
//
//	LPSECURITY_ATTRIBUTES lpEventAttributes,
//	BOOL                  bManualReset,
//	BOOL                  bInitialState,
//	LPCSTR                lpName
//
// );
func XCreateEventA(t *TLS, lpEventAttributes uintptr, bManualReset, bInitialState int32, lpName uintptr) uintptr {
	r0, _, err := syscall.Syscall6(procCreateEventA.Addr(), 4, lpEventAttributes, uintptr(bManualReset),
		uintptr(bInitialState), lpName, 0, 0)
	if r0 == 0 {
		t.setErrno(err)
	}
	return r0
}

// BOOL WINAPI CancelSynchronousIo(
//
//	_In_ HANDLE hThread
//
// );
func XCancelSynchronousIo(t *TLS, hThread uintptr) int32 {
	panic(todo(""))
}

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

// 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_beginthread(t *TLS, procAddr uintptr, stack_sz uint32, args uintptr) int32 {
	f := (*struct{ f func(*TLS, uintptr) uint32 })(unsafe.Pointer(&struct{ uintptr }{procAddr})).f
	var tAdp = ThreadAdapter{threadFunc: f, tls: NewTLS(), param: args}
	tAdp.token = addObject(&tAdp)

	r0, _, err := syscall.Syscall6(procCreateThread.Addr(), 6, 0, uintptr(stack_sz),
		threadCallback, tAdp.token, 0, 0)
	if r0 == 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// uintptr_t _beginthreadex( // NATIVE CODE
//
//	void *security,
//	unsigned stack_size,
//	unsigned ( __stdcall *start_address )( void * ),
//	void *arglist,
//	unsigned initflag,
//	unsigned *thrdaddr
//
// );
func X_beginthreadex(t *TLS, _ uintptr, stack_sz uint32, procAddr uintptr, args uintptr, initf uint32, thAddr uintptr) int32 {
	f := (*struct{ f func(*TLS, uintptr) uint32 })(unsafe.Pointer(&struct{ uintptr }{procAddr})).f
	var tAdp = ThreadAdapter{threadFunc: f, tls: NewTLS(), param: args}
	tAdp.token = addObject(&tAdp)

	r0, _, err := syscall.Syscall6(procCreateThread.Addr(), 6, 0, uintptr(stack_sz),
		threadCallback, tAdp.token, uintptr(initf), thAddr)
	if r0 == 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// DWORD GetCurrentThreadId();
func XGetCurrentThreadId(t *TLS) uint32 {
	r0, _, _ := syscall.Syscall(procGetCurrentThreadId.Addr(), 0, 0, 0, 0)
	return uint32(r0)
	//return uint32(t.ID)
}

// BOOL GetExitCodeThread(
//
//	HANDLE  hThread,
//	LPDWORD lpExitCode
//
// );
func XGetExitCodeThread(t *TLS, hThread, lpExitCode uintptr) int32 {
	r0, _, _ := syscall.Syscall(procGetExitCodeThread.Addr(), 2, hThread, lpExitCode, 0)
	return int32(r0)
}

// DWORD WaitForSingleObjectEx(
//
//	HANDLE hHandle,
//	DWORD  dwMilliseconds,
//	BOOL   bAlertable
//
// );
func XWaitForSingleObjectEx(t *TLS, hHandle uintptr, dwMilliseconds uint32, bAlertable int32) uint32 {
	rv, _, _ := syscall.Syscall(procWaitForSingleObjectEx.Addr(), 3, hHandle, uintptr(dwMilliseconds), uintptr(bAlertable))
	return uint32(rv)
}

// DWORD MsgWaitForMultipleObjectsEx(
//
//	DWORD        nCount,
//	const HANDLE *pHandles,
//	DWORD        dwMilliseconds,
//	DWORD        dwWakeMask,
//	DWORD        dwFlags
//
// );
func XMsgWaitForMultipleObjectsEx(t *TLS, nCount uint32, pHandles uintptr, dwMilliseconds, dwWakeMask, dwFlags uint32) uint32 {
	r0, _, err := syscall.Syscall6(procMsgWaitForMultipleObjectsEx.Addr(), 5,
		uintptr(nCount),
		pHandles,
		uintptr(dwMilliseconds),
		uintptr(dwWakeMask),
		uintptr(dwFlags),
		0,
	)
	if err != 0 {
		t.setErrno(err)
	}
	return uint32(r0)
}

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

// DWORD GetModuleFileNameW(
//
//	HMODULE hModule,
//	LPWSTR  lpFileName,
//	DWORD   nSize
//
// );
func XGetModuleFileNameW(t *TLS, hModule, lpFileName uintptr, nSize uint32) uint32 {
	r0, _, err := syscall.Syscall(procGetModuleFileNameW.Addr(), 3, hModule, lpFileName, uintptr(nSize))
	if r0 == 0 {
		t.setErrno(err)
	}
	return uint32(r0)
}

// NET_API_STATUS NET_API_FUNCTION NetGetDCName(
//
//	LPCWSTR ServerName,
//	LPCWSTR DomainName,
//	LPBYTE  *Buffer
//
// );
func XNetGetDCName(t *TLS, ServerName, DomainName, Buffer uintptr) int32 {
	r0, _, err := syscall.Syscall(procNetGetDCName.Addr(), 3, ServerName, DomainName, Buffer)
	if err != 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// NET_API_STATUS NET_API_FUNCTION NetUserGetInfo(
//
//	LPCWSTR servername,
//	LPCWSTR username,
//	DWORD   level,
//	LPBYTE  *bufptr
//
// );
func XNetUserGetInfo(t *TLS, servername, username uintptr, level uint32, bufptr uintptr) uint32 {
	r0, _, err := syscall.Syscall6(procNetUserGetInfo.Addr(), 4,
		servername,
		username,
		uintptr(level),
		bufptr,
		0,
		0,
	)
	if err != 0 {
		t.setErrno(err)
	}
	return uint32(r0)
}

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

// USERENVAPI BOOL GetProfilesDirectoryW(
//
//	[out]     LPWSTR  lpProfileDir,
//	[in, out] LPDWORD lpcchSize
//
// );
func XGetProfilesDirectoryW(t *TLS, lpProfileDir, lpcchSize uintptr) int32 {
	r0, _, err := syscall.Syscall(procGetProfilesDirectoryW.Addr(), 2, lpProfileDir, lpcchSize, 0)
	if err != 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

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

// DWORD GetPrivateProfileStringA(
//
//	LPCSTR lpAppName,
//	LPCSTR lpKeyName,
//	LPCSTR lpDefault,
//	LPSTR  lpReturnedString,
//	DWORD  nSize,
//	LPCSTR lpFileName
//
// );
func XGetPrivateProfileStringA(t *TLS, lpAppName, lpKeyName, lpDefault, lpReturnedString uintptr, nSize uint32, lpFileName uintptr) uint32 {
	r0, _, err := syscall.Syscall6(procGetPrivateProfileStringA.Addr(), 4,
		lpAppName,
		lpKeyName,
		lpDefault,
		lpReturnedString,
		uintptr(nSize),
		lpFileName,
	)
	if err != 0 {
		t.setErrno(0x02)
	}
	return uint32(r0)
}

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

// BOOL GetFileSecurityW(
//
//	LPCSTR               lpFileName,
//	SECURITY_INFORMATION RequestedInformation,
//	PSECURITY_DESCRIPTOR pSecurityDescriptor,
//	DWORD                nLength,
//	LPDWORD              lpnLengthNeeded
//
// );
func XGetFileSecurityW(t *TLS, lpFileName uintptr, RequestedInformation uint32, pSecurityDescriptor uintptr, nLength uint32, lpnLengthNeeded uintptr) int32 {
	r0, _, err := syscall.Syscall6(procGetFileSecurityW.Addr(), 5, lpFileName, uintptr(RequestedInformation), pSecurityDescriptor, uintptr(nLength), lpnLengthNeeded, 0)
	if err != 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// BOOL GetSecurityDescriptorOwner(
//
//	PSECURITY_DESCRIPTOR pSecurityDescriptor,
//	PSID                 *pOwner,
//	LPBOOL               lpbOwnerDefaulted
//
// );
func XGetSecurityDescriptorOwner(t *TLS, pSecurityDescriptor, pOwner, lpbOwnerDefaulted uintptr) int32 {
	r0, _, err := syscall.Syscall(procGetSecurityDescriptorOwner.Addr(), 3, pSecurityDescriptor, pOwner, lpbOwnerDefaulted)
	if err != 0 {
		t.setErrno(err)
	}
	return int32(r0)

}

// PSID_IDENTIFIER_AUTHORITY GetSidIdentifierAuthority(
//
//	PSID pSid
//
// );
func XGetSidIdentifierAuthority(t *TLS, pSid uintptr) uintptr {
	r0, _, err := syscall.Syscall(procGetSidIdentifierAuthority.Addr(), 1, pSid, 0, 0)
	if err != 0 {
		t.setErrno(err)
	}
	return r0
}

// BOOL ImpersonateSelf(
//
//	SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
//
// );
func XImpersonateSelf(t *TLS, ImpersonationLevel int32) int32 {
	r0, _, err := syscall.Syscall(procImpersonateSelf.Addr(), 1, uintptr(ImpersonationLevel), 0, 0)
	if err != 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// BOOL OpenThreadToken(
//
//	HANDLE  ThreadHandle,
//	DWORD   DesiredAccess,
//	BOOL    OpenAsSelf,
//	PHANDLE TokenHandle
//
// );
func XOpenThreadToken(t *TLS, ThreadHandle uintptr, DesiredAccess uint32, OpenAsSelf int32, TokenHandle uintptr) int32 {
	r0, _, err := syscall.Syscall6(procOpenThreadToken.Addr(), 4, ThreadHandle, uintptr(DesiredAccess), uintptr(OpenAsSelf), TokenHandle, 0, 0)
	if err != 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// HANDLE GetCurrentThread();
func XGetCurrentThread(t *TLS) uintptr {
	r0, _, err := syscall.Syscall(procGetCurrentThread.Addr(), 0, 0, 0, 0)
	if err != 0 {
		t.setErrno(err)
	}
	return r0
}

// BOOL RevertToSelf();
func XRevertToSelf(t *TLS) int32 {
	r0, _, err := syscall.Syscall(procRevertToSelf.Addr(), 0, 0, 0, 0)
	if err != 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// BOOL AccessCheck(
//
//	PSECURITY_DESCRIPTOR pSecurityDescriptor,
//	HANDLE               ClientToken,
//	DWORD                DesiredAccess,
//	PGENERIC_MAPPING     GenericMapping,
//	PPRIVILEGE_SET       PrivilegeSet,
//	LPDWORD              PrivilegeSetLength,
//	LPDWORD              GrantedAccess,
//	LPBOOL               AccessStatus
//
// );
func XAccessCheck(t *TLS, pSecurityDescriptor, ClientToken uintptr, DesiredAccess uint32, GenericMapping, PrivilegeSet, PrivilegeSetLength, GrantedAccess, AccessStatus uintptr) int32 {
	r0, _, err := syscall.Syscall9(procAccessCheck.Addr(), 8,
		pSecurityDescriptor,
		ClientToken,
		uintptr(DesiredAccess),
		GenericMapping,
		PrivilegeSet,
		PrivilegeSetLength,
		GrantedAccess,
		AccessStatus,
		0,
	)
	if err != 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// int _wcsicmp(
//
//	const wchar_t *string1,
//	const wchar_t *string2
//
// );
func Xwcsicmp(t *TLS, string1, string2 uintptr) int32 {
	var s1 = strings.ToLower(goWideString(string1))
	var s2 = strings.ToLower(goWideString(string2))
	return int32(strings.Compare(s1, s2))
}

// BOOL SetCurrentDirectoryW(
//
//	LPCTSTR lpPathName
//
// );
func XSetCurrentDirectoryW(t *TLS, lpPathName uintptr) int32 {
	err := syscall.SetCurrentDirectory((*uint16)(unsafe.Pointer(lpPathName)))
	if err != nil {
		t.setErrno(err)
		return 0
	}
	return 1
}

// DWORD GetCurrentDirectory(
//
//	DWORD  nBufferLength,
//	LPWTSTR lpBuffer
//
// );
func XGetCurrentDirectoryW(t *TLS, nBufferLength uint32, lpBuffer uintptr) uint32 {
	n, err := syscall.GetCurrentDirectory(nBufferLength, (*uint16)(unsafe.Pointer(lpBuffer)))
	if err != nil {
		t.setErrno(err)
	}
	return n
}

// BOOL GetFileInformationByHandle(
//
//	HANDLE                       hFile,
//	LPBY_HANDLE_FILE_INFORMATION lpFileInformation
//
// );
func XGetFileInformationByHandle(t *TLS, hFile, lpFileInformation uintptr) int32 {
	r1, _, e1 := syscall.Syscall(procGetFileInformationByHandle.Addr(), 2, hFile, lpFileInformation, 0)
	if r1 == 0 {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
	}
	return int32(r1)
}

// BOOL GetVolumeInformationW(
//
//	LPCWSTR lpRootPathName,
//	LPWSTR  lpVolumeNameBuffer,
//	DWORD   nVolumeNameSize,
//	LPDWORD lpVolumeSerialNumber,
//	LPDWORD lpMaximumComponentLength,
//	LPDWORD lpFileSystemFlags,
//	LPWSTR  lpFileSystemNameBuffer,
//	DWORD   nFileSystemNameSize
//
// );
func XGetVolumeInformationW(t *TLS, lpRootPathName, lpVolumeNameBuffer uintptr, nVolumeNameSize uint32, lpVolumeSerialNumber, lpMaximumComponentLength, lpFileSystemFlags, lpFileSystemNameBuffer uintptr, nFileSystemNameSize uint32) int32 {
	r0, _, err := syscall.Syscall9(procGetVolumeInformationW.Addr(), 8,
		lpRootPathName,
		lpVolumeNameBuffer,
		uintptr(nVolumeNameSize),
		lpVolumeSerialNumber,
		lpMaximumComponentLength,
		lpFileSystemFlags,
		lpFileSystemNameBuffer,
		uintptr(nFileSystemNameSize),
		0,
	)
	if err != 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// wchar_t *wcschr(
//
//	const wchar_t *str,
//	wchar_t c
//
// );
func Xwcschr(t *TLS, str uintptr, c wchar_t) uintptr {
	var source = str
	for {
		var buf = *(*uint16)(unsafe.Pointer(source))
		if buf == 0 {
			return 0
		}
		if buf == c {
			return source
		}
		// wchar_t = 2 bytes
		source++
		source++
	}
}

// BOOL SetFileTime(
//
//	HANDLE         hFile,
//	const FILETIME *lpCreationTime,
//	const FILETIME *lpLastAccessTime,
//	const FILETIME *lpLastWriteTime
//
// );
func XSetFileTime(t *TLS, hFile uintptr, lpCreationTime, lpLastAccessTime, lpLastWriteTime uintptr) int32 {
	panic(todo(""))
}

// DWORD GetNamedSecurityInfoW(
//
//	LPCWSTR              pObjectName,
//	SE_OBJECT_TYPE       ObjectType,
//	SECURITY_INFORMATION SecurityInfo,
//	PSID                 *ppsidOwner,
//	PSID                 *ppsidGroup,
//	PACL                 *ppDacl,
//	PACL                 *ppSacl,
//	PSECURITY_DESCRIPTOR *ppSecurityDescriptor
//
// );
func XGetNamedSecurityInfoW(t *TLS, pObjectName uintptr, ObjectType, SecurityInfo uint32, ppsidOwner, ppsidGroup, ppDacl, ppSacl, ppSecurityDescriptor uintptr) uint32 {
	panic(todo(""))
}

// BOOL OpenProcessToken(
//
//	HANDLE  ProcessHandle,
//	DWORD   DesiredAccess,
//	PHANDLE TokenHandle
//
// );
func XOpenProcessToken(t *TLS, ProcessHandle uintptr, DesiredAccess uint32, TokenHandle uintptr) int32 {
	panic(todo(""))
}

// BOOL GetTokenInformation(
//
//	HANDLE                  TokenHandle,
//	TOKEN_INFORMATION_CLASS TokenInformationClass,
//	LPVOID                  TokenInformation,
//	DWORD                   TokenInformationLength,
//	PDWORD                  ReturnLength
//
// );
func XGetTokenInformation(t *TLS, TokenHandle uintptr, TokenInformationClass uint32, TokenInformation uintptr, TokenInformationLength uint32, ReturnLength uintptr) int32 {
	panic(todo(""))
}

// BOOL EqualSid(
//
//	PSID pSid1,
//	PSID pSid2
//
// );
func XEqualSid(t *TLS, pSid1, pSid2 uintptr) int32 {
	panic(todo(""))
}

// int WSAStartup(
//
//	WORD      wVersionRequired,
//	LPWSADATA lpWSAData
//
// );
func XWSAStartup(t *TLS, wVersionRequired uint16, lpWSAData uintptr) int32 {
	r0, _, _ := syscall.Syscall(procWSAStartup.Addr(), 2, uintptr(wVersionRequired), lpWSAData, 0)
	if r0 != 0 {
		t.setErrno(r0)
	}
	return int32(r0)
}

// HMODULE GetModuleHandleA(LPCSTR lpModuleName);
func XGetModuleHandleA(t *TLS, lpModuleName uintptr) uintptr {
	r0, _, err := syscall.Syscall(procGetModuleHandleA.Addr(), 1, lpModuleName, 0, 0)
	if r0 == 0 {
		t.setErrno(err)
	}
	return r0
}

// HMODULE GetModuleHandleW(
//
//	LPCWSTR lpModuleName
//
// );
func XGetModuleHandleW(t *TLS, lpModuleName uintptr) uintptr {
	r0, _, err := syscall.Syscall(procGetModuleHandleW.Addr(), 1, lpModuleName, 0, 0)
	if r0 == 0 {
		t.setErrno(err)
	}
	return r0
}

// DWORD GetEnvironmentVariableW(
//
//	LPCWSTR lpName,
//	LPWSTR  lpBuffer,
//	DWORD   nSize
//
// );
func XGetEnvironmentVariableW(t *TLS, lpName, lpBuffer uintptr, nSize uint32) uint32 {
	r0, _, e1 := syscall.Syscall(procGetEnvironmentVariableW.Addr(), 3, lpName, lpBuffer, uintptr(nSize))
	n := uint32(r0)
	if n == 0 {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
	}
	return n
}

// int lstrcmpiA(
//
//	LPCSTR lpString1,
//	LPCSTR lpString2
//
// );
func XlstrcmpiA(t *TLS, lpString1, lpString2 uintptr) int32 {
	var s1 = strings.ToLower(GoString(lpString1))
	var s2 = strings.ToLower(GoString(lpString2))
	return int32(strings.Compare(s1, s2))
}

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

// UINT GetACP();
func XGetACP(t *TLS) uint32 {
	r0, _, _ := syscall.Syscall(procGetACP.Addr(), 0, 0, 0, 0)
	return uint32(r0)
}

// BOOL GetUserNameW(
//
//	LPWSTR  lpBuffer,
//	LPDWORD pcbBuffer
//
// );
func XGetUserNameW(t *TLS, lpBuffer, pcbBuffer uintptr) int32 {
	u, err := user.Current()
	if err != nil {
		panic(todo(""))
		return 0
	}

	wcnt := *(*uint16)(unsafe.Pointer(pcbBuffer))
	s := utf16.Encode([]rune(u.Username))
	if len(s)+1 > int(wcnt) {
		panic(todo(""))
	}

	*(*uint16)(unsafe.Pointer(pcbBuffer)) = uint16(len(s) + 1)
	for _, v := range s {
		*(*uint16)(unsafe.Pointer(lpBuffer)) = v
		lpBuffer += 2
	}
	return 1
}

// HMODULE LoadLibraryExW(
//
//	LPCWSTR lpLibFileName,
//	HANDLE  hFile,
//	DWORD   dwFlags
//
// );
func XLoadLibraryExW(t *TLS, lpLibFileName, hFile uintptr, dwFlags uint32) uintptr {
	return 0 // If the function fails, the return value is NULL.
}

// wchar_t *wcscpy(
//
//	wchar_t *strDestination,
//	const wchar_t *strSource
//
// );
func Xwcscpy(t *TLS, strDestination, strSource uintptr) uintptr {
	if strSource == 0 {
		return 0
	}

	d := strDestination
	for {
		c := *(*uint16)(unsafe.Pointer(strSource))
		strSource += 2
		*(*uint16)(unsafe.Pointer(d)) = c
		d += 2
		if c == 0 {
			return strDestination
		}
	}
}

func XwsprintfW(t *TLS, _ ...interface{}) int32 {
	panic(todo(""))
}

// ATOM RegisterClassW(
//
//	const WNDCLASSW *lpWndClass
//
// );
func XRegisterClassW(t *TLS, lpWndClass uintptr) int32 {
	r0, _, err := syscall.Syscall(procRegisterClassW.Addr(), 1, lpWndClass, 0, 0)
	if r0 == 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

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

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

// BOOL UnregisterClassW(
//
//	LPCWSTR   lpClassName,
//	HINSTANCE hInstance
//
// );
func XUnregisterClassW(t *TLS, lpClassName, hInstance uintptr) int32 {
	r0, _, err := syscall.Syscall(procUnregisterClassW.Addr(), 2, lpClassName, hInstance, 0)
	if r0 == 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

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

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

// 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 XCreateWindowExW(t *TLS, dwExStyle uint32, lpClassName, lpWindowName uintptr, dwStyle uint32, x, y, nWidth, nHeight int32, hWndParent, hMenu, hInstance, lpParam uintptr) uintptr {
	r0, _, err := syscall.Syscall12(procCreateWindowExW.Addr(), 12,
		uintptr(dwExStyle),
		lpClassName,
		lpWindowName,
		uintptr(dwStyle),
		uintptr(x),
		uintptr(y),
		uintptr(nWidth),
		uintptr(nHeight),
		hWndParent,
		hMenu,
		hInstance,
		lpParam,
	)
	if err != 0 {
		t.setErrno(err)
	}
	return r0
}

// BOOL PeekMessageW(
//
//	LPMSG lpMsg,
//	HWND  hWnd,
//	UINT  wMsgFilterMin,
//	UINT  wMsgFilterMax,
//	UINT  wRemoveMsg
//
// );
func XPeekMessageW(t *TLS, lpMsg, hWnd uintptr, wMsgFilterMin, wMsgFilterMax, wRemoveMsg uint32) int32 {
	r0, _, err := syscall.Syscall6(procPeekMessageW.Addr(), 5,
		lpMsg,
		hWnd,
		uintptr(wMsgFilterMin),
		uintptr(wMsgFilterMax),
		uintptr(wRemoveMsg),
		0,
	)
	if err != 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

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

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

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

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

// DWORD SleepEx(
//
//	DWORD dwMilliseconds,
//	BOOL  bAlertable
//
// );
func XSleepEx(t *TLS, dwMilliseconds uint32, bAlertable int32) uint32 {
	r0, _, _ := syscall.Syscall(procSleepEx.Addr(), 2, uintptr(dwMilliseconds), uintptr(bAlertable), 0)
	return uint32(r0)
}

// BOOL CreatePipe(
//
//	PHANDLE               hReadPipe,
//	PHANDLE               hWritePipe,
//	LPSECURITY_ATTRIBUTES lpPipeAttributes,
//	DWORD                 nSize
//
// );
func XCreatePipe(t *TLS, hReadPipe, hWritePipe, lpPipeAttributes uintptr, nSize uint32) int32 {
	r0, _, err := syscall.Syscall6(procCreatePipe.Addr(), 4, hReadPipe, hWritePipe, lpPipeAttributes, uintptr(nSize), 0, 0)
	if r0 == 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// 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 XCreateProcessW(t *TLS, lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes uintptr, bInheritHandles int32, dwCreationFlags uint32,
	lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation uintptr) int32 {

	r1, _, e1 := syscall.Syscall12(procCreateProcessW.Addr(), 10, lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes,
		uintptr(bInheritHandles), uintptr(dwCreationFlags), lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation, 0, 0)
	if r1 == 0 {
		if e1 != 0 {
			t.setErrno(e1)
		} else {
			t.setErrno(errno.EINVAL)
		}
	}

	return int32(r1)
}

// DWORD WaitForInputIdle(
//
//	HANDLE hProcess,
//	DWORD  dwMilliseconds
//
// );
func XWaitForInputIdle(t *TLS, hProcess uintptr, dwMilliseconds uint32) int32 {
	r0, _, _ := syscall.Syscall(procWaitForInputIdle.Addr(), 2, hProcess, uintptr(dwMilliseconds), 0)
	return int32(r0)
}

// DWORD SearchPathW(
//
//	LPCWSTR lpPath,
//	LPCWSTR lpFileName,
//	LPCWSTR lpExtension,
//	DWORD   nBufferLength,
//	LPWSTR  lpBuffer,
//	LPWSTR  *lpFilePart
//
// );
func XSearchPathW(t *TLS, lpPath, lpFileName, lpExtension uintptr, nBufferLength uint32, lpBuffer, lpFilePart uintptr) int32 {
	r0, _, err := syscall.Syscall6(procSearchPathW.Addr(), 6, lpPath, lpFileName, lpExtension, uintptr(nBufferLength), lpBuffer, lpFilePart)
	if r0 == 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

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

// BOOL GetExitCodeProcess(
//
//	HANDLE  hProcess,
//	LPDWORD lpExitCode
//
// );
func XGetExitCodeProcess(t *TLS, hProcess, lpExitCode uintptr) int32 {
	r0, _, err := syscall.Syscall(procGetExitCodeProcess.Addr(), 2, hProcess, lpExitCode, 0)
	if r0 == 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// BOOL PeekNamedPipe(
//
//	HANDLE  hNamedPipe,
//	LPVOID  lpBuffer,
//	DWORD   nBufferSize,
//	LPDWORD lpBytesRead,
//	LPDWORD lpTotalBytesAvail,
//	LPDWORD lpBytesLeftThisMessage
//
// );
func XPeekNamedPipe(t *TLS, hNamedPipe, lpBuffer uintptr, nBufferSize uint32, lpBytesRead, lpTotalBytesAvail, lpBytesLeftThisMessage uintptr) int32 {
	r0, _, err := syscall.Syscall6(procPeekNamedPipe.Addr(), 6, hNamedPipe, lpBuffer, uintptr(nBufferSize), lpBytesRead, lpTotalBytesAvail, lpBytesLeftThisMessage)
	if r0 == 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// long _InterlockedExchange(
//
//	long volatile * Target,
//	long Value
//
// );
func X_InterlockedExchange(t *TLS, Target uintptr, Value long) long {
	old := atomic.SwapInt32((*int32)(unsafe.Pointer(Target)), Value)
	return old
}

// BOOL TerminateThread(
//
//	[in, out] HANDLE hThread,
//	[in]      DWORD  dwExitCode
//
// );
func XTerminateThread(t *TLS, hThread uintptr, dwExitCode uint32) int32 {
	r0, _, err := syscall.Syscall(procTerminateThread.Addr(), 2, hThread, uintptr(dwExitCode), 0)
	if err != 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// BOOL GetComputerNameW(
//
//	LPWSTR  lpBuffer,
//	LPDWORD nSize
//
// );
func XGetComputerNameW(t *TLS, lpBuffer, nSize uintptr) int32 {
	panic(todo(""))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// BOOL QueryPerformanceFrequency(
//
//	LARGE_INTEGER *lpFrequency
//
// );
func XQueryPerformanceFrequency(t *TLS, lpFrequency uintptr) int32 {

	r1, _, err := syscall.Syscall(procQueryPerformanceFrequency.Addr(), 1, lpFrequency, 0, 0)
	if r1 == 0 {
		t.setErrno(err)
		return 0
	}
	return int32(r1)
}

func inDST(t gotime.Time) bool {

	jan1st := gotime.Date(t.Year(), 1, 1, 0, 0, 0, 0, t.Location()) // January 1st is always outside DST window

	_, off1 := t.Zone()
	_, off2 := jan1st.Zone()

	return off1 != off2
}

// void _ftime( struct _timeb *timeptr );
func X_ftime(t *TLS, timeptr uintptr) {
	var tm = gotime.Now()
	var tPtr = (*time.X__timeb64)(unsafe.Pointer(timeptr))
	tPtr.Ftime = tm.Unix()
	tPtr.Fmillitm = uint16(gotime.Duration(tm.Nanosecond()) / gotime.Millisecond)
	if inDST(tm) {
		tPtr.Fdstflag = 1
	}
	_, offset := tm.Zone()
	tPtr.Ftimezone = int16(offset)
}

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

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

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

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

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

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

// int _wcsicmp(
//
//	const wchar_t *string1,
//	const wchar_t *string2
//
// );
func X_wcsicmp(t *TLS, string1, string2 uintptr) int32 {
	return Xwcsicmp(t, string1, string2)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// HDDEDATA DdeClientTransaction(
//
//	LPBYTE  pData,
//	DWORD   cbData,
//	HCONV   hConv,
//	HSZ     hszItem,
//	UINT    wFmt,
//	UINT    wType,
//	DWORD   dwTimeout,
//	LPDWORD pdwResult
//
// );
func XDdeClientTransaction(t *TLS, pData uintptr, cbData uint32, hConv uintptr, hszItem uintptr, wFmt, wType, dwTimeout uint32, pdwResult uintptr) uintptr {
	panic(todo(""))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// int _vsnwprintf(
//
//	wchar_t *buffer,
//	size_t count,
//	const wchar_t *format,
//	va_list argptr
//
// );
func X__mingw_vsnwprintf(t *TLS, buffer uintptr, count types.Size_t, format, va uintptr) int32 {
	panic(todo(""))
}

// int vprintf(const char *format, va_list ap);
func X__mingw_vprintf(t *TLS, s, ap uintptr) int32 { return Xvprintf(t, s, ap) }

// int vfscanf(FILE * restrict stream, const char * restrict format, va_list arg);
func X__mingw_vfscanf(t *TLS, stream, format, ap uintptr) int32 {
	panic(todo(""))
}

// int vsscanf(const char *str, const char *format, va_list ap);
func X__mingw_vsscanf(t *TLS, str, format, ap uintptr) int32 {
	return Xsscanf(t, str, format, ap)
}

// int vfprintf(FILE * restrict stream, const char * restrict format, va_list arg);
func X__mingw_vfprintf(t *TLS, f uintptr, format, va uintptr) int32 {
	return Xvfprintf(t, f, format, va)
}

// int vsprintf(char * restrict s, const char * restrict format, va_list arg);
func X__mingw_vsprintf(t *TLS, s, format, ap uintptr) int32 {
	return Xvsprintf(t, s, format, ap)
}

// int vsnprintf(char *str, size_t size, const char *format, va_list ap);
func X__mingw_vsnprintf(t *TLS, str uintptr, size types.Size_t, format, ap uintptr) int32 {
	panic(todo(""))
}

// int putchar(int char)
func X_putchar(t *TLS, c int32) int32 {
	if _, err := fwrite(unistd.STDOUT_FILENO, []byte{byte(c)}); err != nil {
		return -1
	}
	return int32(byte(c))
}

// int vfwscanf(FILE *stream, const wchar_t *format, va_list argptr;);
func X__mingw_vfwscanf(t *TLS, stream uintptr, format, ap uintptr) int32 {
	panic(todo(""))
}

// int vswscanf(const wchar_t *buffer, const wchar_t *format, va_list arglist);
func X__mingw_vswscanf(t *TLS, stream uintptr, format, ap uintptr) int32 {
	panic(todo(""))
}

// int vfwprintf(FILE * restrict stream, const wchar_t * restrict format, va_list arg);
func X__mingw_vfwprintf(t *TLS, stream, format, ap uintptr) int32 {
	panic(todo(""))
}

// int putchar(int c);
func Xputchar(t *TLS, c int32) int32 {
	panic(todo(""))
}

// void _assert(
//
//	char const* message,
//	char const* filename,
//	unsigned line
//
// );
func X_assert(t *TLS, message, filename uintptr, line uint32) {
	panic(todo(""))
}

// char *strdup(const char *s);
func X_strdup(t *TLS, s uintptr) uintptr {
	panic(todo(""))
}

// int _access(
//
//	const char *path,
//	int mode
//
// );
func X_access(t *TLS, pathname uintptr, mode int32) int32 {

	var path = GoString(pathname)

	info, err := os.Stat(path)
	if err != nil {
		// doesn't exist
		return errno.ENOENT
	}

	switch mode {
	case 0:
		// exists
		return 0
	case 2:
		// write-only
		// Check if the user bit is enabled in file permission
		if info.Mode().Perm()&(1<<(uint(7))) == 1 {
			// write-able
			return 0
		}
	case 4:
		// read-only
		// Check if the user bit is enabled in file permission
		if info.Mode().Perm()&(1<<(uint(7))) == 0 {
			// not set, so read-only
			return 0
		}
	case 6:
		// r/w
		if info.Mode().Perm()&(1<<(uint(7))) == 1 {
			// write-able
			return 0
		}
	}

	return errno.EACCES

}

// BOOL WINAPI SetConsoleCtrlHandler(
//
//	_In_opt_ PHANDLER_ROUTINE HandlerRoutine,
//	_In_     BOOL             Add
//
// );
func XSetConsoleCtrlHandler(t *TLS, HandlerRoutine uintptr, Add int32) int32 {

	//var fcc = &struct {
	//	f func(*TLS, uint32) int32
	//}{}
	//fcc = (*struct{ f func(*TLS, uint32) int32 })(unsafe.Pointer(HandlerRoutine))
	//var hdlr = fcc.f
	//
	//_, _, err := procSetConsoleCtrlHandler.Call(
	//syscall.NewCallback(func(controlType uint) uint {
	//		return uint( hdlr(t, uint32(controlType)) )
	//	}), 1)
	//
	//if err != nil {
	//	panic("failed: SetConsoleCtrlHandler")
	//}

	return 0
}

// DebugBreak
func XDebugBreak(t *TLS) {
	panic(todo(""))
}

// int _isatty( int fd );
func X_isatty(t *TLS, fd int32) int32 {

	f, ok := fdToFile(fd)
	if !ok {
		t.setErrno(errno.EBADF)
		return 0
	}

	if fd == unistd.STDOUT_FILENO ||
		fd == unistd.STDIN_FILENO ||
		fd == unistd.STDERR_FILENO {
		var mode uint32
		err := syscall.GetConsoleMode(f.Handle, &mode)
		if err != nil {
			t.setErrno(errno.EINVAL)
			return 0
		}
		// is console
		return 1
	}

	return 0
}

// BOOL WINAPI SetConsoleTextAttribute(
//
//	_In_ HANDLE hConsoleOutput,
//	_In_ WORD   wAttributes
//
// );
func XSetConsoleTextAttribute(t *TLS, hConsoleOutput uintptr, wAttributes uint16) int32 {
	r1, _, _ := syscall.Syscall(procSetConsoleTextAttribute.Addr(), 2, hConsoleOutput, uintptr(wAttributes), 0)
	return int32(r1)
}

// BOOL WINAPI GetConsoleScreenBufferInfo(
//
//	_In_  HANDLE                      hConsoleOutput,
//	_Out_ PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo
//
// );
func XGetConsoleScreenBufferInfo(t *TLS, hConsoleOutput, lpConsoleScreenBufferInfo uintptr) int32 {
	r1, _, _ := syscall.Syscall(procGetConsoleScreenBufferInfo.Addr(), 2, hConsoleOutput, lpConsoleScreenBufferInfo, 0)
	return int32(r1)
}

// FILE *_popen(
//
//	const char *command,
//	const char *mode
//
// );
func X_popen(t *TLS, command, mode uintptr) uintptr {
	panic(todo(""))
}

// int _wunlink(
//
//	const wchar_t *filename
//
// );
func X_wunlink(t *TLS, filename uintptr) int32 {
	panic(todo(""))
}

func Xclosedir(tls *TLS, dir uintptr) int32 {
	panic(todo(""))
}

func Xopendir(tls *TLS, name uintptr) uintptr {
	panic(todo(""))
}

func Xreaddir(tls *TLS, dir uintptr) uintptr {
	panic(todo(""))
}

// int _unlink(
//
//	const char *filename
//
// );
func X_unlink(t *TLS, filename uintptr) int32 {
	panic(todo(""))
}

// int pclose(FILE *stream);
func X_pclose(t *TLS, stream uintptr) int32 {
	panic(todo(""))
}

// int setmode (int fd, int mode);
func Xsetmode(t *TLS, fd, mode int32) int32 {
	return X_setmode(t, fd, mode)
}

// int _setmode (int fd, int mode);
func X_setmode(t *TLS, fd, mode int32) int32 {

	_, ok := fdToFile(fd)
	if !ok {
		t.setErrno(errno.EBADF)
		return -1
	}

	// we're always in binary mode.
	// at least for now.

	if mode == fcntl.O_BINARY {
		return fcntl.O_BINARY
	} else {
		t.setErrno(errno.EINVAL)
		return -1
	}
}

// int _mkdir(const char *dirname);
func X_mkdir(t *TLS, dirname uintptr) int32 {
	panic(todo(""))
}

// int _chmod( const char *filename, int pmode );
func X_chmod(t *TLS, filename uintptr, pmode int32) int32 {
	panic(todo(""))
}

// int _fileno(FILE *stream);
func X_fileno(t *TLS, stream uintptr) int32 {
	f, ok := winGetObject(stream).(*file)
	if !ok {
		t.setErrno(errno.EBADF)
		return -1
	}
	return f._fd
}

// void rewind(FILE *stream);
func Xrewind(t *TLS, stream uintptr) {
	Xfseek(t, stream, 0, unistd.SEEK_SET)
}

// __atomic_load_n
func X__atomic_load_n(t *TLS) {
	panic(todo(""))
}

// __atomic_store_n
func X__atomic_store_n(t *TLS, _ ...interface{}) int32 {
	panic(todo(""))
}

// __builtin_add_overflow
func X__builtin_add_overflow(t *TLS) {
	panic(todo(""))
}

// __builtin_mul_overflow
func X__builtin_mul_overflow(t *TLS) {
	panic(todo(""))
}

// __builtin_sub_overflow
func X__builtin_sub_overflow(t *TLS) {
	panic(todo(""))
}

func goWideBytes(p uintptr, n int) []uint16 {
	b := GoBytes(p, 2*n)
	var w []uint16
	for i := 0; i < len(b); i += 2 {
		w = append(w, *(*uint16)(unsafe.Pointer(&b[i])))
	}
	return w
}

// This version does include the zero terminator in the returned Go string.
func goWideString(p uintptr) string {
	if p == 0 {
		return ""
	}
	var w []uint16
	var raw = (*RawMem)(unsafe.Pointer(p))
	var i = 0
	for {
		wc := *(*uint16)(unsafe.Pointer(&raw[i]))
		w = append(w, wc)
		// append until U0000
		if wc == 0 {
			break
		}
		i = i + 2
	}
	s := utf16.Decode(w)
	return string(s)
}

func goWideStringN(p uintptr, n int) string {
	panic(todo(""))
}

// This version does not include the zero terminator in the returned Go string.
func goWideStringNZ(p uintptr) string {
	if p == 0 {
		return ""
	}

	var w []uint16
	var raw = (*RawMem)(unsafe.Pointer(p))
	var i = 0
	for {
		wc := *(*uint16)(unsafe.Pointer(&raw[i]))
		if wc == 0 {
			break
		}

		w = append(w, wc)
		i = i + 2
	}
	s := utf16.Decode(w)
	return string(s)
}

// LPWSTR GetCommandLineW();
func XGetCommandLineW(t *TLS) uintptr {
	return uintptr(unsafe.Pointer(syscall.GetCommandLine()))
}

// BOOL AddAccessDeniedAce(
//
//	PACL  pAcl,
//	DWORD dwAceRevision,
//	DWORD AccessMask,
//	PSID  pSid
//
// );
func XAddAccessDeniedAce(t *TLS, pAcl uintptr, dwAceRevision, AccessMask uint32, pSid uintptr) int32 {
	panic(todo(""))
}

// BOOL AddAce(
//
//	PACL   pAcl,
//	DWORD  dwAceRevision,
//	DWORD  dwStartingAceIndex,
//	LPVOID pAceList,
//	DWORD  nAceListLength
//
// );
func XAddAce(t *TLS, pAcl uintptr, dwAceRevision, dwStartingAceIndex uint32, pAceList uintptr, nAceListLength uint32) int32 {
	panic(todo(""))
}

// BOOL GetAce(
//
//	PACL   pAcl,
//	DWORD  dwAceIndex,
//	LPVOID *pAce
//
// );
func XGetAce(t *TLS, pAcl uintptr, dwAceIndex uint32, pAce uintptr) int32 {
	panic(todo(""))
}

// BOOL GetAclInformation(
//
//	PACL                  pAcl,
//	LPVOID                pAclInformation,
//	DWORD                 nAclInformationLength,
//	ACL_INFORMATION_CLASS dwAclInformationClass
//
// );
func XGetAclInformation(t *TLS, pAcl, pAclInformation uintptr, nAclInformationLength, dwAclInformationClass uint32) int32 {
	r0, _, err := syscall.Syscall6(procGetAclInformation.Addr(), 4,
		pAclInformation,
		pAclInformation,
		uintptr(nAclInformationLength),
		uintptr(dwAclInformationClass),
		0,
		0,
	)
	if err != 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// BOOL GetFileSecurityA(
//
//	LPCSTR               lpFileName,
//	SECURITY_INFORMATION RequestedInformation,
//	PSECURITY_DESCRIPTOR pSecurityDescriptor,
//	DWORD                nLength,
//	LPDWORD              lpnLengthNeeded
//
// );
func XGetFileSecurityA(t *TLS, lpFileName uintptr, RequestedInformation uint32, pSecurityDescriptor uintptr, nLength uint32, lpnLengthNeeded uintptr) int32 {
	r0, _, err := syscall.Syscall6(procGetFileSecurityA.Addr(), 5,
		lpFileName,
		uintptr(RequestedInformation),
		pSecurityDescriptor,
		uintptr(nLength),
		lpnLengthNeeded,
		0,
	)
	if err != 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// DWORD GetLengthSid(
//
//	PSID pSid
//
// );
func XGetLengthSid(t *TLS, pSid uintptr) uint32 {
	panic(todo(""))
}

// BOOL GetSecurityDescriptorDacl(
//
//	PSECURITY_DESCRIPTOR pSecurityDescriptor,
//	LPBOOL               lpbDaclPresent,
//	PACL                 *pDacl,
//	LPBOOL               lpbDaclDefaulted
//
// );
func XGetSecurityDescriptorDacl(t *TLS, pSecurityDescriptor, lpbDaclPresent, pDacl, lpbDaclDefaulted uintptr) int32 {
	r0, _, err := syscall.Syscall6(procGetSecurityDescriptorDacl.Addr(), 4,
		pSecurityDescriptor,
		lpbDaclPresent,
		pDacl,
		lpbDaclDefaulted,
		0,
		0,
	)
	if err != 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// DWORD GetSidLengthRequired(
//
//	UCHAR nSubAuthorityCount
//
// );
func XGetSidLengthRequired(t *TLS, nSubAuthorityCount uint8) int32 {
	r0, _, err := syscall.Syscall(procGetSidLengthRequired.Addr(), 1, uintptr(nSubAuthorityCount), 0, 0)
	if err != 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// PDWORD GetSidSubAuthority(
//
//	PSID  pSid,
//	DWORD nSubAuthority
//
// );
func XGetSidSubAuthority(t *TLS, pSid uintptr, nSubAuthority uint32) uintptr {
	r0, _, err := syscall.Syscall(procGetSidSubAuthority.Addr(), 2, pSid, uintptr(nSubAuthority), 0)
	if err != 0 {
		t.setErrno(err)
	}
	return r0
}

// BOOL InitializeAcl(
//
//	PACL  pAcl,
//	DWORD nAclLength,
//	DWORD dwAclRevision
//
// );
func XInitializeAcl(t *TLS, pAcl uintptr, nAclLength, dwAclRevision uint32) int32 {
	panic(todo(""))
}

// BOOL InitializeSid(
//
//	PSID                      Sid,
//	PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
//	BYTE                      nSubAuthorityCount
//
// );
func XInitializeSid(t *TLS, Sid, pIdentifierAuthority uintptr, nSubAuthorityCount uint8) int32 {
	r0, _, err := syscall.Syscall(procInitializeSid.Addr(), 3, Sid, pIdentifierAuthority, uintptr(nSubAuthorityCount))
	if err != 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// VOID RaiseException(
//
//	DWORD           dwExceptionCode,
//	DWORD           dwExceptionFlags,
//	DWORD           nNumberOfArguments,
//	const ULONG_PTR *lpArguments
//
// );
func XRaiseException(t *TLS, dwExceptionCode, dwExceptionFlags, nNumberOfArguments uint32, lpArguments uintptr) {
	panic(todo(""))
}

// UINT SetErrorMode(
//
//	UINT uMode
//
// );
func XSetErrorMode(t *TLS, uMode uint32) int32 {
	panic(todo(""))
}

// DWORD SetNamedSecurityInfoA(
//
//	LPSTR                pObjectName,
//	SE_OBJECT_TYPE       ObjectType,
//	SECURITY_INFORMATION SecurityInfo,
//	PSID                 psidOwner,
//	PSID                 psidGroup,
//	PACL                 pDacl,
//	PACL                 pSacl
//
// );
func XSetNamedSecurityInfoA(t *TLS, pObjectName uintptr, ObjectType, SecurityInfo uint32, psidOwner, psidGroup, pDacl, pSacl uintptr) uint32 {
	panic(todo(""))
}

// 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 XCreateProcessA(t *TLS, lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes uintptr, bInheritHandles int32,
	dwCreationFlags uint32, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation uintptr) int32 {
	r1, _, err := syscall.Syscall12(procCreateProcessA.Addr(), 10, lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes,
		uintptr(bInheritHandles), uintptr(dwCreationFlags), lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation, 0, 0)
	if r1 == 0 {
		if err != 0 {
			t.setErrno(err)
		} else {
			t.setErrno(errno.EINVAL)
		}
	}
	return int32(r1)
}

// unsigned int _set_abort_behavior(
//
//	unsigned int flags,
//	unsigned int mask
//
// );
func X_set_abort_behavior(t *TLS, _ ...interface{}) uint32 {
	panic(todo(""))
}

// HANDLE OpenEventA(
//
//	DWORD  dwDesiredAccess,
//	BOOL   bInheritHandle,
//	LPCSTR lpName
//
// );
func XOpenEventA(t *TLS, dwDesiredAccess uint32, bInheritHandle uint32, lpName uintptr) uintptr {
	r0, _, err := syscall.Syscall(procOpenEventA.Addr(), 3, uintptr(dwDesiredAccess), uintptr(bInheritHandle), lpName)
	if r0 == 0 {
		t.setErrno(err)
	}
	return r0
}

// size_t _msize(
//
//	void *memblock
//
// );
func X_msize(t *TLS, memblock uintptr) types.Size_t {
	return types.Size_t(UsableSize(memblock))
}

// unsigned long _byteswap_ulong ( unsigned long val );
func X_byteswap_ulong(t *TLS, val ulong) ulong {
	return X__builtin_bswap32(t, val)
}

// unsigned __int64 _byteswap_uint64 ( unsigned __int64 val );
func X_byteswap_uint64(t *TLS, val uint64) uint64 {
	return X__builtin_bswap64(t, val)
}

// int _commit(
//
//	int fd
//
// );
func X_commit(t *TLS, fd int32) int32 {
	return Xfsync(t, fd)
}

// int _stati64(
//
//	const char *path,
//	struct _stati64 *buffer
//
// );
func X_stati64(t *TLS, path, buffer uintptr) int32 {
	panic(todo(""))
}

// int _fstati64(
//
//	int fd,
//	struct _stati64 *buffer
//
// );
func X_fstati64(t *TLS, fd int32, buffer uintptr) int32 {
	panic(todo(""))
}

// int _findnext32(
//
//	intptr_t handle,
//	struct _finddata32_t *fileinfo
//
// );
func X_findnext32(t *TLS, handle types.Intptr_t, buffer uintptr) int32 {
	panic(todo(""))
}

// intptr_t _findfirst32(
//
//	const char *filespec,
//	struct _finddata32_t *fileinfo
//
// );
func X_findfirst32(t *TLS, filespec, fileinfo uintptr) types.Intptr_t {
	panic(todo(""))
}

/*-
 * Copyright (c) 1990 The Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

// long strtol(const char *nptr, char **endptr, int base);
func Xstrtol(t *TLS, nptr, endptr uintptr, base int32) long {

	var s uintptr = nptr
	var acc ulong
	var c byte
	var cutoff ulong
	var neg int32
	var any int32
	var cutlim int32

	/*
	 * Skip white space and pick up leading +/- sign if any.
	 * If base is 0, allow 0x for hex and 0 for octal, else
	 * assume decimal; if base is already 16, allow 0x.
	 */
	for {
		c = *(*byte)(unsafe.Pointer(s))
		PostIncUintptr(&s, 1)
		var sp = strings.TrimSpace(string(c))
		if len(sp) > 0 {
			break
		}
	}

	if c == '-' {
		neg = 1
		c = *(*byte)(unsafe.Pointer(s))
		PostIncUintptr(&s, 1)
	} else if c == '+' {
		c = *(*byte)(unsafe.Pointer(s))
		PostIncUintptr(&s, 1)
	}

	sp := *(*byte)(unsafe.Pointer(s))

	if (base == 0 || base == 16) &&
		c == '0' && (sp == 'x' || sp == 'X') {
		PostIncUintptr(&s, 1)
		c = *(*byte)(unsafe.Pointer(s)) //s[1];
		PostIncUintptr(&s, 1)
		base = 16
	}
	if base == 0 {
		if c == '0' {
			base = 0
		} else {
			base = 10
		}
	}
	/*
	 * Compute the cutoff value between legal numbers and illegal
	 * numbers.  That is the largest legal value, divided by the
	 * base.  An input number that is greater than this value, if
	 * followed by a legal input character, is too big.  One that
	 * is equal to this value may be valid or not; the limit
	 * between valid and invalid numbers is then based on the last
	 * digit.  For instance, if the range for longs is
	 * [-2147483648..2147483647] and the input base is 10,
	 * cutoff will be set to 214748364 and cutlim to either
	 * 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated
	 * a value > 214748364, or equal but the next digit is > 7 (or 8),
	 * the number is too big, and we will return a range error.
	 *
	 * Set any if any `digits' consumed; make it negative to indicate
	 * overflow.
	 */
	var ULONG_MAX ulong = 0xFFFFFFFF
	var LONG_MAX long = long(ULONG_MAX >> 1)
	var LONG_MIN long = ^LONG_MAX

	if neg == 1 {
		cutoff = ulong(-1 * LONG_MIN)
	} else {
		cutoff = ulong(LONG_MAX)
	}
	cutlim = int32(cutoff % ulong(base))
	cutoff = cutoff / ulong(base)

	acc = 0
	any = 0

	for {
		var cs = string(c)
		if unicode.IsDigit([]rune(cs)[0]) {
			c -= '0'
		} else if unicode.IsLetter([]rune(cs)[0]) {
			if unicode.IsUpper([]rune(cs)[0]) {
				c -= 'A' - 10
			} else {
				c -= 'a' - 10
			}
		} else {
			break
		}

		if int32(c) >= base {
			break
		}
		if any < 0 || acc > cutoff || (acc == cutoff && int32(c) > cutlim) {
			any = -1

		} else {
			any = 1
			acc *= ulong(base)
			acc += ulong(c)
		}

		c = *(*byte)(unsafe.Pointer(s))
		PostIncUintptr(&s, 1)
	}

	if any < 0 {
		if neg == 1 {
			acc = ulong(LONG_MIN)
		} else {
			acc = ulong(LONG_MAX)
		}
		t.setErrno(errno.ERANGE)
	} else if neg == 1 {
		acc = -acc
	}

	if endptr != 0 {
		if any == 1 {
			PostDecUintptr(&s, 1)
			AssignPtrUintptr(endptr, s)
		} else {
			AssignPtrUintptr(endptr, nptr)
		}
	}
	return long(acc)
}

// unsigned long int strtoul(const char *nptr, char **endptr, int base);
func Xstrtoul(t *TLS, nptr, endptr uintptr, base int32) ulong {
	var s uintptr = nptr
	var acc ulong
	var c byte
	var cutoff ulong
	var neg int32
	var any int32
	var cutlim int32

	/*
	 * Skip white space and pick up leading +/- sign if any.
	 * If base is 0, allow 0x for hex and 0 for octal, else
	 * assume decimal; if base is already 16, allow 0x.
	 */
	for {
		c = *(*byte)(unsafe.Pointer(s))
		PostIncUintptr(&s, 1)
		var sp = strings.TrimSpace(string(c))
		if len(sp) > 0 {
			break
		}
	}

	if c == '-' {
		neg = 1
		c = *(*byte)(unsafe.Pointer(s))
		PostIncUintptr(&s, 1)
	} else if c == '+' {
		c = *(*byte)(unsafe.Pointer(s))
		PostIncUintptr(&s, 1)
	}

	sp := *(*byte)(unsafe.Pointer(s))

	if (base == 0 || base == 16) &&
		c == '0' && (sp == 'x' || sp == 'X') {
		PostIncUintptr(&s, 1)
		c = *(*byte)(unsafe.Pointer(s)) //s[1];
		PostIncUintptr(&s, 1)
		base = 16
	}
	if base == 0 {
		if c == '0' {
			base = 0
		} else {
			base = 10
		}
	}
	var ULONG_MAX ulong = 0xFFFFFFFF

	cutoff = ULONG_MAX / ulong(base)
	cutlim = int32(ULONG_MAX % ulong(base))

	acc = 0
	any = 0

	for {
		var cs = string(c)
		if unicode.IsDigit([]rune(cs)[0]) {
			c -= '0'
		} else if unicode.IsLetter([]rune(cs)[0]) {
			if unicode.IsUpper([]rune(cs)[0]) {
				c -= 'A' - 10
			} else {
				c -= 'a' - 10
			}
		} else {
			break
		}

		if int32(c) >= base {
			break
		}
		if any < 0 || acc > cutoff || (acc == cutoff && int32(c) > cutlim) {
			any = -1

		} else {
			any = 1
			acc *= ulong(base)
			acc += ulong(c)
		}

		c = *(*byte)(unsafe.Pointer(s))
		PostIncUintptr(&s, 1)
	}

	if any < 0 {
		acc = ULONG_MAX
		t.setErrno(errno.ERANGE)
	} else if neg == 1 {
		acc = -acc
	}

	if endptr != 0 {
		if any == 1 {
			PostDecUintptr(&s, 1)
			AssignPtrUintptr(endptr, s)
		} else {
			AssignPtrUintptr(endptr, nptr)
		}
	}
	return acc
}

// int __isoc99_sscanf(const char *str, const char *format, ...);
func X__isoc99_sscanf(t *TLS, str, format, va uintptr) int32 {
	r := scanf(strings.NewReader(GoString(str)), format, va)
	// if dmesgs {
	// 	dmesg("%v: %q %q: %d", origin(1), GoString(str), GoString(format), r)
	// }
	return r
}

// int sscanf(const char *str, const char *format, ...);
func Xsscanf(t *TLS, str, format, va uintptr) int32 {
	r := scanf(strings.NewReader(GoString(str)), format, va)
	// if dmesgs {
	// 	dmesg("%v: %q %q: %d", origin(1), GoString(str), GoString(format), r)
	// }
	return r
}

func Xstrtod(tls *TLS, s uintptr, p uintptr) float64 { /* strtod.c:22:8: */
	panic(todo(""))
}

func Xrint(tls *TLS, x float64) float64 {
	switch {
	case x == 0: // also +0 and -0
		return 0
	case math.IsInf(x, 0), math.IsNaN(x):
		return x
	case x >= math.MinInt64 && x <= math.MaxInt64 && float64(int64(x)) == x:
		return x
	case x >= 0:
		return math.Floor(x + 0.5)
	default:
		return math.Ceil(x - 0.5)
	}
}

// FILE *fdopen(int fd, const char *mode);
func Xfdopen(t *TLS, fd int32, mode uintptr) uintptr {
	panic(todo(""))
}

// struct tm *_gmtime64( const __time64_t *sourceTime );
func X_gmtime64(t *TLS, sourceTime uintptr) uintptr {
	panic(todo(""))
}

// __time64_t _mktime64(struct tm *timeptr);
func X_mktime64(t *TLS, timeptr uintptr) time.X__time64_t {
	return time.X__time64_t(Xmktime(t, timeptr))
}

// char * gai_strerrorA(int ecode);
func Xgai_strerrorA(t *TLS, ecode int32) uintptr {
	panic(todo(""))
}

// https://github.com/Alexpux/mingw-w64/blob/master/mingw-w64-headers/crt/sys/timeb.h#L69
//
// struct __timeb64 {
//     __time64_t time;
//     unsigned short millitm;
//     short timezone;
//     short dstflag;
//   };

type __timeb64 struct {
	time     types.X__time64_t
	millitm  uint32
	timezone int16
	dstflag  int16
}

// void _ftime64( struct __timeb64 *timeptr );
func X_ftime64(t *TLS, timeptr uintptr) {
	tm := gotime.Now()
	(*__timeb64)(unsafe.Pointer(timeptr)).time = types.X__time64_t(tm.Unix())

	//TODO When Go 1.16 is no more supported
	// (*__timeb64)(unsafe.Pointer(timeptr)).millitm = uint32(tm.UnixMilli() % 1000)

	(*__timeb64)(unsafe.Pointer(timeptr)).millitm = uint32(int64(tm.Nanosecond()) / 1e6)
}

func X__ccgo_getMutexType(tls *TLS, m uintptr) int32 { /* pthread_mutex_lock.c:3:5: */
	return *(*int32)(unsafe.Pointer(m)) & 15
}

func X__ccgo_pthreadAttrGetDetachState(tls *TLS, a uintptr) int32 { /* pthread_attr_get.c:3:5: */
	return *(*int32)(unsafe.Pointer(a))
}

func X__ccgo_pthreadMutexattrGettype(tls *TLS, a uintptr) int32 { /* pthread_attr_get.c:93:5: */
	return *(*int32)(unsafe.Pointer(a)) & int32(3)
}

func Xchmod(t *TLS, pathname uintptr, mode int32) int32 {
	panic(todo("%q %#o", GoString(pathname), mode))
}

// typedef enum _COMPUTER_NAME_FORMAT {
//   ComputerNameNetBIOS,
//   ComputerNameDnsHostname,
//   ComputerNameDnsDomain,
//   ComputerNameDnsFullyQualified,
//   ComputerNamePhysicalNetBIOS,
//   ComputerNamePhysicalDnsHostname,
//   ComputerNamePhysicalDnsDomain,
//   ComputerNamePhysicalDnsFullyQualified,
//   ComputerNameMax
// } COMPUTER_NAME_FORMAT;

// BOOL GetComputerNameExW(
//
//	[in]      COMPUTER_NAME_FORMAT NameType,
//	[out]     LPWSTR               lpBuffer,
//	[in, out] LPDWORD              nSize
//
// );
func XGetComputerNameExW(t *TLS, nameType int32, lpBuffer, nSize uintptr) int32 {
	r0, _, err := syscall.Syscall(procGetComputerNameExW.Addr(), 3, uintptr(nameType), lpBuffer, nSize)
	if err != 0 {
		t.setErrno(err)
	}
	return int32(r0)
}

// double _copysign(
//
//	double x,
//	double y
//
// );
func X_copysign(t *TLS, x, y float64) float64 { return Xcopysign(t, x, y) }

// int _wtoi(
//
//	const wchar_t *str
//
// );
func X_wtoi(t *TLS, str uintptr) int32 {
	panic(todo(""))
}

func allocW(t *TLS, v string) (r uintptr) {
	s := utf16.Encode([]rune(v))
	p := Xcalloc(t, types.Size_t(len(s)+1), 2)
	if p == 0 {
		panic(todo(""))
	}

	r = p
	for _, v := range s {
		*(*uint16)(unsafe.Pointer(p)) = v
		p += 2
	}
	return r
}

// wchar_t *_wgetenv(
//
//	const wchar_t *varname
//
// );
func X_wgetenv(t *TLS, varname uintptr) uintptr {
	if !wenvValid {
		bootWinEnviron(t)
	}
	k := strings.ToLower(goWideStringNZ(varname))
	for _, v := range winEnviron[:len(winEnviron)-1] {
		s := strings.ToLower(goWideStringNZ(v))
		x := strings.IndexByte(s, '=')
		if s[:x] == k {
			// trc("%v: %q -> %q", origin(1), goWideStringNZ(varname), goWideStringNZ(v))
			return v
		}
	}

	// trc("%v: %q -> %q", origin(1), goWideStringNZ(varname), "")
	return 0
}

// int _wputenv(
//
//	const wchar_t *envstring
//
// );
func X_wputenv(t *TLS, envstring uintptr) int32 {
	if !wenvValid {
		bootWinEnviron(t)
	}
	s0 := goWideStringNZ(envstring)
	s := strings.ToLower(s0)
	x := strings.IndexByte(s, '=')
	k := s[:x]
	for i, v := range winEnviron[:len(winEnviron)-1] {
		s2 := strings.ToLower(goWideStringNZ(v))
		x := strings.IndexByte(s2, '=')
		if s2[:x] == k {
			Xfree(t, v)
			winEnviron[i] = allocW(t, s0)
			return 0
		}
	}

	np := allocW(t, s0)
	winEnviron = winEnviron[:len(winEnviron)-1]
	winEnviron = append(winEnviron, np, 0)
	wenviron = uintptr(unsafe.Pointer(&winEnviron[0]))
	return 0
}

func bootWinEnviron(t *TLS) {
	winEnviron = winEnviron[:0]
	p := Environ()
	for {
		q := *(*uintptr)(unsafe.Pointer(p))
		p += unsafe.Sizeof(uintptr(0))
		if q == 0 {
			break
		}

		s := GoString(q)
		// trc("%v: %q", origin(1), s)
		r := allocW(t, s)
		winEnviron = append(winEnviron, r)
	}
	wenviron = uintptr(unsafe.Pointer(&winEnviron[0]))
	wenvValid = true
}

func Xfabsl(t *TLS, x float64) float64 { return math.Abs(x) }

func X__stdio_common_vfprintf(t *TLS, args ...interface{}) int32     { panic("TODO") }
func X__stdio_common_vfprintf_p(t *TLS, args ...interface{}) int32   { panic("TODO") }
func X__stdio_common_vfprintf_s(t *TLS, args ...interface{}) int32   { panic("TODO") }
func X__stdio_common_vfscanf(t *TLS, args ...interface{}) int32      { panic("TODO") }
func X__stdio_common_vfwprintf_s(t *TLS, args ...interface{}) int32  { panic("TODO") }
func X__stdio_common_vfwscanf(t *TLS, args ...interface{}) int32     { panic("TODO") }
func X__stdio_common_vsnprintf_s(t *TLS, args ...interface{}) int32  { panic("TODO") }
func X__stdio_common_vsnwprintf_s(t *TLS, args ...interface{}) int32 { panic("TODO") }
func X__stdio_common_vsprintf(t *TLS, args ...interface{}) int32     { panic("TODO") }
func X__stdio_common_vsprintf_p(t *TLS, args ...interface{}) int32   { panic("TODO") }
func X__stdio_common_vsprintf_s(t *TLS, args ...interface{}) int32   { panic("TODO") }
func X__stdio_common_vsscanf(t *TLS, args ...interface{}) int32      { panic("TODO") }
func X__stdio_common_vswprintf(t *TLS, args ...interface{}) int32    { panic("TODO") }
func X__stdio_common_vswprintf_s(t *TLS, args ...interface{}) int32  { panic("TODO") }
func X__stdio_common_vswscanf(t *TLS, args ...interface{}) int32     { panic("TODO") }