Difference between revisions of "Unit Ultibo"

procedure UltiboInit;

function GetVersion:DWORD;

function GetVersionEx(lpVersionInformation:LPOSVERSIONINFOA):BOOL;

function GetVersionExA(lpVersionInformation:LPOSVERSIONINFOA):BOOL;

function GetVersionExW(lpVersionInformation:LPOSVERSIONINFOW):BOOL;

procedure GetSystemInfo(var lpSystemInfo:SYSTEM_INFO);

procedure GetNativeSystemInfo(lpSystemInfo:LPSYSTEM_INFO);

function GetLargePageMinimum:SIZE_T;

function GetComputerName(lpBuffer:LPSTR; var nSize:DWORD):BOOL;

function GetComputerNameA(lpBuffer:LPSTR; var nSize:DWORD):BOOL;

function GetComputerNameW(lpBuffer:LPWSTR; var nSize:DWORD):BOOL;

function SetComputerName(lpComputerName:LPCSTR):BOOL;

function SetComputerNameA(lpComputerName:LPCSTR):BOOL;

function SetComputerNameW(lpComputerName:LPCWSTR):BOOL;

function GetComputerNameEx(NameType:COMPUTER_NAME_FORMAT; lpBuffer:LPSTR; var nSize:DWORD):BOOL;

function GetComputerNameExA(NameType:COMPUTER_NAME_FORMAT; lpBuffer:LPSTR; var nSize:DWORD):BOOL;

function GetComputerNameExW(NameType:COMPUTER_NAME_FORMAT; lpBuffer:LPWSTR; var nSize:DWORD):BOOL;

function SetComputerNameEx(NameType:COMPUTER_NAME_FORMAT; lpBuffer:LPCSTR):BOOL;

function SetComputerNameExA(NameType:COMPUTER_NAME_FORMAT; lpBuffer:LPCSTR):BOOL;

function SetComputerNameExW(NameType:COMPUTER_NAME_FORMAT; lpBuffer:LPCWSTR):BOOL;

function ExitUltibo(dwReserved:DWORD; uReserved:UINT):BOOL;

function ExitUltiboEx(uFlags:UINT; dwReserved:DWORD):BOOL;

function RestartComputer(Delay:LongWord):Boolean;

function ShutdownComputer(Delay:LongWord):Boolean;

function Uptime:TFileTime;

function GetTickCount:DWORD;

function GetTickCount64:ULONGLONG;

procedure GetSystemTime(var lpSystemTime:SYSTEMTIME);

procedure GetSystemTimeAsFileTime(var lpSystemTimeAsFileTime:FILETIME);

function SetSystemTime(var lpSystemTime:SYSTEMTIME):BOOL;

procedure GetLocalTime(var lpSystemTime:SYSTEMTIME);

function SetLocalTime(var lpSystemTime:SYSTEMTIME):BOOL;

function SystemTimeToTzSpecificLocalTime(lpTimeZoneInformation:LPTIME_ZONE_INFORMATION; var lpUniversalTime,lpLocalTime:SYSTEMTIME):BOOL;

function TzSpecificLocalTimeToSystemTime(const lpTimeZoneInformation:TIME_ZONE_INFORMATION; const lpLocalTime:SYSTEMTIME; var lpUniversalTime:SYSTEMTIME):BOOL;

function GetTimeZoneInformation(var lpTimeZoneInformation:TIME_ZONE_INFORMATION):DWORD;

function SetTimeZoneInformation(const lpTimeZoneInformation:TIME_ZONE_INFORMATION):BOOL;

function SystemTimeToFileTime(const lpSystemTime:SYSTEMTIME; var lpFileTime:FILETIME):BOOL;

function FileTimeToSystemTime(const lpFileTime:FILETIME; var lpSystemTime:SYSTEMTIME):BOOL;

function FileTimeToLocalFileTime(const lpFileTime:FILETIME; var lpLocalFileTime:FILETIME):BOOL;

function LocalFileTimeToFileTime(const lpLocalFileTime:FILETIME; var lpFileTime:FILETIME):BOOL;

function CompareFileTime(const lpFileTime1,lpFileTime2:FILETIME):LONG;

function FileTimeToDosDateTime(const lpFileTime:FILETIME; var lpFatDate,lpFatTime:WORD):BOOL;

function DosDateTimeToFileTime(wFatDate,wFatTime:WORD; var lpFileTime:FILETIME):BOOL;

function GetCurrentTime:TFileTime;

procedure SetCurrentTime(const ATime:TFileTime);

function GetTimeAdjust:LongInt;

procedure SetTimeAdjust(AAdjust:LongInt);

function GetCurrentTimezone:String;

function SetCurrentTimezone(const AName:String):Boolean;

function GetTimezoneActiveOffset:LongInt;

function GetTimezoneStandardOffset:LongInt;

procedure SetTimezoneStandardOffset(AOffset:LongInt);

function GetTimezoneDaylightOffset:LongInt;

procedure SetTimezoneDaylightOffset(AOffset:LongInt);

function GetTimezoneStandardStart:String;

function GetTimezoneDaylightStart:String;

function GetTimezoneStandardDate:TDateTime;

function GetTimezoneDaylightDate:TDateTime;

function FileTimeToDateTime(const AFileTime:TFileTime):TDateTime;

function DateTimeToFileTime(ADateTime:TDateTime):TFileTime;

function LocalFileTimeToDateTime(const AFileTime:TFileTime):TDateTime;

function DateTimeToLocalFileTime(ADateTime:TDateTime):TFileTime;

function SystemFileTimeToDateTime(const AFileTime:TFileTime):TDateTime;

function DateTimeToSystemFileTime(ADateTime:TDateTime):TFileTime;

function FileTimeToUnixTime(const AFileTime:TFileTime):LongInt;

function UnixTimeToFileTime(AUnixTime:LongInt):TFileTime;

function UnixTimeToDateTime(AUnixTime:LongInt):TDateTime;

function DateTimeToUnixTime(ADateTime:TDateTime):LongInt;

function FileTimeToFileDate(const AFileTime:TFileTime):Integer;

function FileDateToFileTime(AFileDate:Integer):TFileTime;

function FileTimeToAdjustedTime(const AFileTime:TFileTime):TFileTime;

function AdjustedTimeToFileTime(const AFileTime:TFileTime):TFileTime;

function RoundFileTime(const AFileTime:TFileTime):TFileTime;

function ConvertFileTime(const AFileTime:TFileTime; AOffset:Integer; ALocal:Boolean):TFileTime;

function ConvertDateTime(ADateTime:TDateTime; AOffset:Integer; ALocal:Boolean):TDateTime;

function GetDiskType(lpRootPathName:LPCSTR):UINT;

function GetDriveTypeA(lpRootPathName:LPCSTR):UINT;

function GetDriveTypeW(lpRootPathName:LPCWSTR):UINT;

function GetLogicalDrives:DWORD;

function GetLogicalDriveStrings(nBufferLength:DWORD; lpBuffer:LPSTR):DWORD;

function GetLogicalDriveStringsA(nBufferLength:DWORD; lpBuffer:LPSTR):DWORD;

function GetLogicalDriveStringsW(nBufferLength:DWORD; lpBuffer:LPWSTR):DWORD;

function DefineDosDevice(dwFlags:DWORD; lpDeviceName,lpTargetPath:LPCSTR):BOOL;

function DefineDosDeviceA(dwFlags:DWORD; lpDeviceName,lpTargetPath:LPCSTR):BOOL;

function DefineDosDeviceW(dwFlags:DWORD; lpDeviceName,lpTargetPath:LPCWSTR):BOOL;

function QueryDosDevice(lpDeviceName,lpTargetPath:LPSTR; ucchMax:DWORD):DWORD;

function QueryDosDeviceA(lpDeviceName,lpTargetPath:LPSTR; ucchMax:DWORD):DWORD;

function QueryDosDeviceW(lpDeviceName,lpTargetPath:LPWSTR; ucchMax:DWORD):DWORD;

function SetVolumeLabel(lpRootPathName,lpVolumeName:LPCSTR):BOOL;

function SetVolumeLabelA(lpRootPathName,lpVolumeName:LPCSTR):BOOL;

function SetVolumeLabelW(lpRootPathName,lpVolumeName:LPCWSTR):BOOL;

function GetVolumeInformation(lpRootPathName:LPCSTR; lpVolumeNameBuffer:LPSTR; nVolumeNameSize:DWORD; lpVolumeSerialNumber:LPDWORD; var lpMaximumComponentLength,lpFileSystemFlags:DWORD; lpFileSystemNameBuffer:LPSTR; nFileSystemNameSize:DWORD):BOOL;

function GetVolumeInformationA(lpRootPathName:LPCSTR; lpVolumeNameBuffer:LPSTR; nVolumeNameSize:DWORD; lpVolumeSerialNumber:LPDWORD; var lpMaximumComponentLength,lpFileSystemFlags:DWORD;lpFileSystemNameBuffer:LPSTR; nFileSystemNameSize:DWORD):BOOL;

function GetVolumeInformationW(lpRootPathName:LPCWSTR; lpVolumeNameBuffer:LPWSTR; nVolumeNameSize:DWORD; lpVolumeSerialNumber:LPDWORD; var lpMaximumComponentLength,lpFileSystemFlags:DWORD;lpFileSystemNameBuffer:LPWSTR; nFileSystemNameSize:DWORD):BOOL;

function GetDiskFreeSpace(lpRootPathName:LPCSTR; var lpSectorsPerCluster,lpBytesPerSector,lpNumberOfFreeClusters,lpTotalNumberOfClusters:DWORD):BOOL;

function GetDiskFreeSpaceA(lpRootPathName:LPCSTR; var lpSectorsPerCluster,lpBytesPerSector,lpNumberOfFreeClusters,lpTotalNumberOfClusters:DWORD):BOOL;

function GetDiskFreeSpaceW(lpRootPathName:LPCWSTR; var lpSectorsPerCluster,lpBytesPerSector,lpNumberOfFreeClusters,lpTotalNumberOfClusters:DWORD):BOOL;

function GetDiskFreeSpaceEx(lpDirectoryName:LPCSTR; var lpFreeBytesAvailableToCaller,lpTotalNumberOfBytes:ULARGE_INTEGER; lpTotalNumberOfFreeBytes:PULARGE_INTEGER):BOOL;

function GetPathDrive(const APath:String):Byte;

function GetDriveType(ADrive:Byte):TDriveType;

function GetDriveData(ADrive:Byte):TDriveData;

function GetDriveAttr(ADrive:Byte):LongWord;

function GetDriveLabel(ADrive:Byte):String;

function SetDriveLabel(ADrive:Byte; const ALabel:String):Boolean;

function GetDriveSerial(ADrive:Byte):LongWord;

function SetDriveSerial(ADrive:Byte; ASerial:LongWord):Boolean;

function IsDriveValid(ADrive:Byte):Boolean;

function GetValidDrives:LongWord;

function GetValidDriveNames:String;

function GetDriveFreeSpace(ADrive:Byte):LongWord;

function GetDriveFreeSpaceEx(ADrive:Byte):Int64;

function GetDriveTotalSpace(ADrive:Byte):LongWord;

function GetDriveTotalSpaceEx(ADrive:Byte):Int64;

function GetCurrentDrive:Byte;

function SetCurrentDrive(const ADrive:String):Boolean;

function AreFileApisANSI:BOOL;

procedure SetFileApisToOEM;

procedure SetFileApisToANSI;

function CreateFile(lpFileName:LPCSTR; dwDesiredAccess,dwShareMode:DWORD; lpSecurityAttributes:LPSECURITY_ATTRIBUTES; dwCreationDisposition:DWORD; dwFlagsAndAttributes:DWORD; hTemplateFile:HANDLE):HANDLE;

function CreateFileA(lpFileName:LPCSTR; dwDesiredAccess,dwShareMode:DWORD; lpSecurityAttributes:LPSECURITY_ATTRIBUTES; dwCreationDisposition:DWORD; dwFlagsAndAttributes:DWORD; hTemplateFile:HANDLE):HANDLE;

function CreateFileW(lpFileName:LPCWSTR; dwDesiredAccess,dwShareMode:DWORD; lpSecurityAttributes:LPSECURITY_ATTRIBUTES; dwCreationDisposition:DWORD; dwFlagsAndAttributes:DWORD; hTemplateFile:HANDLE):HANDLE;

function SetFileAttributes(lpFileName:LPCSTR; dwFileAttributes:DWORD):BOOL;

function SetFileAttributesA(lpFileName:LPCSTR; dwFileAttributes:DWORD):BOOL;

function SetFileAttributesW(lpFileName:LPCWSTR; dwFileAttributes:DWORD):BOOL;

function GetFileAttributes(lpFileName:LPCSTR):DWORD;

function GetFileAttributesA(lpFileName:LPCSTR):DWORD;

function GetFileAttributesW(lpFileName:LPCWSTR):DWORD;

function DeleteFile(lpFileName:LPCSTR):BOOL;

function DeleteFileA(lpFileName:LPCSTR):BOOL;

function DeleteFileW(lpFileName:LPCWSTR):BOOL;

function MoveFile(lpExistingFileName,lpNewFileName:LPCSTR):BOOL;

function MoveFileA(lpExistingFileName,lpNewFileName:LPCSTR):BOOL;

function MoveFileW(lpExistingFileName,lpNewFileName:LPCWSTR):BOOL;

function FindFirstFile(lpFileName:LPCSTR; var lpFindFileData:WIN32_FIND_DATAA):HANDLE;

function FindFirstFileA(lpFileName:LPCSTR; var lpFindFileData:WIN32_FIND_DATAA):HANDLE;

function FindFirstFileW(lpFileName:LPCWSTR; var lpFindFileData:WIN32_FIND_DATAW):HANDLE;

function FindNextFile(hFindFile:HANDLE; var lpFindFileData:WIN32_FIND_DATAA):BOOL;

function FindNextFileA(hFindFile:HANDLE; var lpFindFileData:WIN32_FIND_DATAA):BOOL;

function FindNextFileW(hFindFile:HANDLE; var lpFindFileData:WIN32_FIND_DATAW):BOOL;

function FindCloseFile(hFindFile:HANDLE):BOOL;

function GetFileSize(hFile:HANDLE;lpFileSizeHigh:LPDWORD):DWORD;

function GetFileSizeEx(hFile:HANDLE; var lpFileSize:LARGE_INTEGER):BOOL;

function GetFileTime(hFile:HANDLE; lpCreationTime,lpLastAccessTime,lpLastWriteTime:PFILETIME):BOOL;

function SetFileTime(hFile:HANDLE; lpCreationTime,lpLastAccessTime,lpLastWriteTime:PFILETIME):BOOL;

function ReadFile(hFile:HANDLE; lpBuffer:LPVOID; nNumberOfBytesToRead:DWORD; lpNumberOfBytesRead:LPDWORD; lpOverlapped:LPOVERLAPPED):BOOL;

function WriteFile(hFile:HANDLE; lpBuffer:LPCVOID; nNumberOfBytesToWrite:DWORD; lpNumberOfBytesWritten:LPDWORD; lpOverlapped:LPOVERLAPPED):BOOL;

function SetEndOfFile(hFile:HANDLE):BOOL;

function SetFilePointer(hFile:HANDLE; lDistanceToMove:LONG; lpDistanceToMoveHigh:PLONG; dwMoveMethod:DWORD):DWORD;

function SetFilePointerEx(hFile:HANDLE; liDistanceToMove:LARGE_INTEGER; lpNewFilePointer:PLARGE_INTEGER; dwMoveMethod:DWORD):BOOL;

function FlushFileBuffers(hFile:HANDLE):BOOL;

function CopyFile(lpExistingFileName,lpNewFileName:LPCSTR; bFailIfExists:BOOL):BOOL;

function CopyFileA(lpExistingFileName,lpNewFileName:LPCSTR; bFailIfExists:BOOL):BOOL;

function CopyFileW(lpExistingFileName,lpNewFileName:LPCWSTR; bFailIfExists:BOOL):BOOL;

function SetFileShortName(hFile:HANDLE; lpShortName:LPCSTR):BOOL;

function SetFileShortNameA(hFile:HANDLE; lpShortName:LPCSTR):BOOL;

function SetFileShortNameW(hFile:HANDLE; lpShortName:LPCWSTR):BOOL;

function CreateHardLink(lpFileName,lpExistingFileName:LPCSTR; lpSecurityAttributes:LPSECURITY_ATTRIBUTES):BOOL;

function CreateHardLinkA(lpFileName,lpExistingFileName:LPCSTR; lpSecurityAttributes:LPSECURITY_ATTRIBUTES):BOOL;

function CreateHardLinkW(lpFileName,lpExistingFileName:LPCWSTR; lpSecurityAttributes:LPSECURITY_ATTRIBUTES):BOOL;

function CreateSymbolicLink(lpSymlinkFileName,lpTargetFileName:LPCSTR; dwFlags:DWORD):BOOL;

function CreateSymbolicLinkA(lpSymlinkFileName,lpTargetFileName:LPCSTR; dwFlags:DWORD):BOOL;

function CreateSymbolicLinkW(lpSymlinkFileName,lpTargetFileName:LPCWSTR; dwFlags:DWORD):BOOL;

function CreateDirectory(lpPathName:LPCSTR; lpSecurityAttributes:LPSECURITY_ATTRIBUTES):BOOL;

function CreateDirectoryA(lpPathName:LPCSTR; lpSecurityAttributes:LPSECURITY_ATTRIBUTES):BOOL;

function CreateDirectoryW(lpPathName:LPCWSTR; lpSecurityAttributes:LPSECURITY_ATTRIBUTES):BOOL;

function RemoveDirectory(lpPathName:LPCSTR):BOOL;

function RemoveDirectoryA(lpPathName:LPCSTR):BOOL;

function RemoveDirectoryW(lpPathName:LPCWSTR):BOOL;

function SetCurrentDirectory(lpPathName:LPCSTR):BOOL;

function SetCurrentDirectoryA(lpPathName:LPCSTR):BOOL;

function SetCurrentDirectoryW(lpPathName:LPCWSTR):BOOL;

function GetCurrentDirectory(nBufferLength:DWORD; lpBuffer:LPSTR):DWORD;

function GetCurrentDirectoryA(nBufferLength:DWORD; lpBuffer:LPSTR):DWORD;

function GetCurrentDirectoryW(nBufferLength:DWORD; lpBuffer:LPWSTR):DWORD;

function GetLongPathName(lpszShortPath:LPCSTR; lpszLongPath:LPSTR; cchBuffer:DWORD):DWORD;

function GetLongPathNameA(lpszShortPath:LPCSTR; lpszLongPath:LPSTR; cchBuffer:DWORD):DWORD;

function GetLongPathNameW(lpszShortPath:LPCWSTR; lpszLongPath:LPWSTR; cchBuffer:DWORD):DWORD;

function GetShortPathName(lpszLongPath:LPCSTR; lpszShortPath:LPSTR; cchBuffer:DWORD):DWORD;

function GetShortPathNameA(lpszLongPath:LPCSTR; lpszShortPath:LPSTR; cchBuffer:DWORD):DWORD;

function GetShortPathNameW(lpszLongPath:LPCWSTR; lpszShortPath:LPWSTR; cchBuffer:DWORD):DWORD;

function GetFullPathName(lpFileName:LPCSTR; nBufferLength:DWORD; lpBuffer:LPSTR; var lpFilePart:LPSTR):DWORD;

function GetFullPathNameA(lpFileName:LPCSTR; nBufferLength:DWORD; lpBuffer:LPSTR; var lpFilePart:LPSTR):DWORD;

function GetFullPathNameW(lpFileName:LPCWSTR; nBufferLength:DWORD; lpBuffer:LPWSTR; var lpFilePart:LPWSTR):DWORD;

function SysParamCount:LongInt;

function SysParamStr(Index:LongInt):String;

function GetCommandLine:LPSTR;

function GetCommandLineA:LPSTR;

function GetCommandLineW:LPWSTR;

function IsParamPresent(const AParam:String):Boolean;

function GetParamIndex(const AParam:String):Integer;

function GetParamValue(const AParam:String):String;

function GetEnvironmentStrings:LPSTR;

function GetEnvironmentStringsA:LPSTR;

function GetEnvironmentStringsW:LPWSTR;

function FreeEnvironmentStrings(pstr:LPSTR):BOOL;

function FreeEnvironmentStringsA(pstr:LPSTR):BOOL;

function FreeEnvironmentStringsW(pstr:LPWSTR):BOOL;

function GetEnvironmentVariable(lpName:LPCSTR; lpBuffer:LPSTR; nSize:DWORD):DWORD;

function GetEnvironmentVariableA(lpName:LPCSTR; lpBuffer:LPSTR; nSize:DWORD):DWORD;

function GetEnvironmentVariableW(lpName:LPCWSTR; lpBuffer:LPWSTR; nSize:DWORD):DWORD;

function SetEnvironmentVariable(lpName,lpValue:LPCSTR):BOOL;

function SetEnvironmentVariableA(lpName,lpValue:LPCSTR):BOOL;

function SetEnvironmentVariableW(lpName,lpValue:LPCWSTR):BOOL;

function ExpandEnvironmentStrings(lpSrc:LPCSTR; lpDst:LPSTR; nSize:DWORD):DWORD;

function ExpandEnvironmentStringsA(lpSrc:LPCSTR; lpDst:LPSTR; nSize:DWORD):DWORD;

function ExpandEnvironmentStringsW(lpSrc:LPCWSTR; lpDst:LPWSTR; nSize:DWORD):DWORD;

function GetLastError:DWORD;

procedure SetLastError(dwErrCode:DWORD);

function CreateGUID:TGUID;

function GUIDToString(const Value:TGUID):String;

function StringToGUID(const Value:String):TGUID;

function HexChar(Value:Char):Byte;

function HexByte(Value:PChar):Byte;

function NullGUID(const GUID:TGUID):Boolean;

function CompareGUID(const GUID1,GUID2:TGUID):Boolean;

function SIDToString(ASID:PSID):String;

function StringToSID(const Value:String):PSID;

function Min(A,B:Integer):Integer; inline;

function Max(A,B:Integer):Integer; inline;

function MinEx(A,B:LongWord):LongWord; inline;

function MaxEx(A,B:LongWord):LongWord; inline;

function Min64(const A,B:Int64):Int64; inline;

function Max64(const A,B:Int64):Int64; inline;

function Or64(const Value1,Value2:Int64):Int64; inline;

function And64(const Value1,Value2:Int64):Int64; inline;

function Xor64(const Value1,Value2:Int64):Int64; inline;

function Not64(const Value:Int64):Int64; inline;

function Rol32(Value:LongWord; Count:Byte):LongWord; inline;

function Ror32(Value:LongWord; Count:Byte):LongWord; inline;

function WordSwap(AValue:Word):Word; inline;

function LongSwap(AValue:LongWord):LongWord; inline;

function Int64Swap(const AValue:Int64):Int64; inline;

function BufferSwap(ABuffer:Pointer; ASize:LongWord):Boolean;

function GenerateNameHash(const Name:String; Size:Integer):LongWord;

function GeneratePasswordHash(const Password:String):LongWord;

function IsValidLocale(LocaleID:LCID; dwFlags:DWORD):BOOL; inline;

function GetSystemDefaultLCID:LCID; inline;

function GetUserDefaultLCID:LCID; inline;

function GetThreadLocale:LCID; 

function SetThreadLocale(LocaleID:LCID):BOOL; 

function SetSystemDefaultLCID(LocaleID:LCID):BOOL; inline;

function WideCharToString(ABuffer:PWideChar):String;

function WideCharLenToString(ABuffer:PWideChar; ALength:Integer):String;

function StringToWideChar(const AString:String; ABuffer:PWideChar; ASize:Integer):Boolean;

function IsValidCodePage(CodePage:UINT):BOOL; inline; 

function GetACP:UINT; inline;

function GetOEMCP:UINT; inline;

function GetConsoleCP:UINT; inline;

function SetConsoleCP(wCodePageID:UINT):BOOL; inline;

function GetConsoleOutputCP:UINT; inline;

function SetConsoleOutputCP(wCodePageID:UINT):BOOL; inline;

function GetCPInfo(CodePage:UINT; var lpCPInfo:TCPInfo):BOOL; inline;

function GetCPInfoEx(CodePage:UINT; dwFlags:DWORD; var lpCPInfoEx:CPINFOEXA):BOOL; inline;

function GetCPInfoExA(CodePage:UINT; dwFlags:DWORD; var lpCPInfoEx:CPINFOEXA):BOOL; inline;

function GetCPInfoExW(CodePage:UINT; dwFlags:DWORD; var lpCPInfoEx:CPINFOEXW):BOOL; inline;

function SetACP(CodePage:UINT):BOOL; inline;

function SetOEMCP(CodePage:UINT):BOOL; inline;

function MultiByteToWideChar(CodePage:UINT; dwFlags:DWORD; lpMultiByteStr:LPCSTR; cbMultiByte:Integer; lpWideCharStr:LPWSTR; cchWideChar:Integer):Integer; inline;

function WideCharToMultiByte(CodePage:UINT; dwFlags:DWORD; lpWideCharStr:LPCWSTR; cchWideChar:Integer; lpMultiByteStr:LPSTR; cbMultiByte:Integer; lpDefaultChar:LPCSTR; lpUsedDefaultChar:LPBOOL):Integer; inline;

function CompareString(Locale:LCID; dwCmpFlags:DWORD; lpString1:LPCSTR; cchCount1:Integer; lpString2:LPCSTR; cchCount2:Integer):Integer; inline;

function CompareStringA(Locale:LCID; dwCmpFlags:DWORD; lpString1:LPCSTR; cchCount1:Integer; lpString2:LPCSTR; cchCount2:Integer):Integer; inline;

function CompareStringW(Locale:LCID; dwCmpFlags:DWORD; lpString1:LPCWSTR; cchCount1:Integer; lpString2:LPCWSTR; cchCount2:Integer):Integer; inline;

function CharUpper(lpsz:LPSTR):LPSTR; inline;

function CharUpperA(lpsz:LPSTR):LPSTR; inline;

function CharUpperW(lpsz:LPWSTR):LPWSTR; inline;

function CharUpperBuff(lpsz:LPSTR; cchLength:DWORD):DWORD; inline;

function CharUpperBuffA(lpsz:LPSTR; cchLength:DWORD):DWORD; inline;

function CharUpperBuffW(lpsz:LPWSTR; cchLength:DWORD):DWORD; inline;

function CharLower(lpsz:LPSTR):LPSTR; inline;

function CharLowerA(lpsz:LPSTR):LPSTR; inline;

function CharLowerW(lpsz:LPWSTR):LPWSTR; inline;

function CharLowerBuff(lpsz:LPSTR; cchLength:DWORD):DWORD; inline;

function CharLowerBuffA(lpsz:LPSTR; cchLength:DWORD):DWORD; inline;

function CharLowerBuffW(lpsz:LPWSTR; cchLength:DWORD):DWORD; inline;

function AnsiToOem(lpszSrc:LPCSTR; lpszDst:LPSTR):BOOL; inline;

function AnsiToOemBuff(lpszSrc:LPCSTR; lpszDst:LPSTR; cchDstLength:DWORD):BOOL; inline;

function OemToAnsi(lpszSrc:LPCSTR; lpszDst:LPSTR):BOOL; inline;

function OemToAnsiBuff(lpszSrc:LPCSTR; lpszDst:LPSTR; cchDstLength:DWORD):BOOL; inline;

function CharToOem(lpszSrc:LPCSTR; lpszDst:LPSTR):BOOL; inline; 

function CharToOemA(lpszSrc:LPCSTR; lpszDst:LPSTR):BOOL; inline;

function CharToOemW(lpszSrc:LPCWSTR; lpszDst:LPSTR):BOOL; inline;

function OemToChar(lpszSrc:LPCSTR; lpszDst:LPSTR):BOOL; inline;

function OemToCharA(lpszSrc:LPCSTR; lpszDst:LPSTR):BOOL; inline;

function OemToCharW(lpszSrc:LPCSTR; lpszDst:LPWSTR):BOOL; inline;

function CharToOemBuff(lpszSrc:LPCSTR; lpszDst:LPSTR; cchDstLength:DWORD):BOOL; inline;

function CharToOemBuffA(lpszSrc:LPCSTR; lpszDst:LPSTR; cchDstLength:DWORD):BOOL; inline;

function CharToOemBuffW(lpszSrc:LPCWSTR; lpszDst:LPSTR; cchDstLength:DWORD):BOOL; inline;

function OemToCharBuff(lpszSrc:LPCSTR; lpszDst:LPSTR; cchDstLength:DWORD):BOOL; inline;

function OemToCharBuffA(lpszSrc:LPCSTR; lpszDst:LPSTR; cchDstLength:DWORD):BOOL; inline;

function OemToCharBuffW(lpszSrc:LPCSTR; lpszDst:LPWSTR; cchDstLength:DWORD):BOOL; inline;

function CloseHandle(hObject:HANDLE):BOOL;

function DuplicateHandle(hSourceProcessHandle:HANDLE; hSourceHandle:HANDLE; hTargetProcessHandle:HANDLE; lpTargetHandle:LPHANDLE; dwDesiredAccess:DWORD; bInheritHandle:BOOL; dwOptions:DWORD):BOOL;

function GetHandleInformation(hObject:HANDLE; var lpdwFlags:DWORD):BOOL;

function SetHandleInformation(hObject:HANDLE; dwMask:DWORD; dwFlags:DWORD):BOOL;

procedure MoveMemory(Destination,Source:PVOID; Length:SIZE_T); inline;

procedure CopyMemory(Destination,Source:PVOID; Length:SIZE_T); inline;

procedure FillMemory(Destination:PVOID; Length:SIZE_T;Fill:BYTE); inline;

procedure ZeroMemory(Destination:PVOID; Length:SIZE_T); inline;

function GlobalAlloc(uFlags:UINT; dwBytes:SIZE_T):HGLOBAL;

function GlobalReAlloc(hMem:HGLOBAL; dwBytes:SIZE_T; uFlags:UINT):HGLOBAL;

function GlobalFree(hMem:HGLOBAL):HGLOBAL;

function GlobalSize(hMem:HGLOBAL):SIZE_T;

function GlobalFlags(hMem:HGLOBAL):UINT;

function GlobalLock(hMem:HGLOBAL):LPVOID;

function GlobalUnlock(hMem:HGLOBAL):BOOL;

function GlobalHandle(pMem:LPCVOID):HGLOBAL;

procedure GlobalMemoryStatus(var lpBuffer:MEMORYSTATUS);

function GlobalMemoryStatusEx(var lpBuffer:MEMORYSTATUSEX):BOOL;

function LocalAlloc(uFlags:UINT; uBytes:SIZE_T):HLOCAL;

function LocalReAlloc(hMem:HLOCAL; uBytes:SIZE_T; uFlags:UINT):HLOCAL;

function LocalFree(hMem:HLOCAL):HLOCAL;

function LocalSize(hMem:HLOCAL):SIZE_T;

function LocalFlags(hMem:HLOCAL):UINT;

function LocalLock(hMem:HLOCAL):LPVOID;

function LocalUnlock(hMem:HLOCAL):BOOL;

function LocalHandle(pMem:LPCVOID):HLOCAL;

function VirtualAlloc(lpAddress:LPVOID; dwSize:SIZE_T; flAllocationType:DWORD; flProtect:DWORD):LPVOID;

function VirtualFree(lpAddress:LPVOID; dwSize:SIZE_T; dwFreeType:DWORD):BOOL;

function VirtualQuery(lpAddress:LPCVOID; var lpBuffer:MEMORY_BASIC_INFORMATION; dwLength:DWORD):DWORD;

function VirtualLock(lpAddress:LPVOID; dwSize:SIZE_T):BOOL;

function VirtualUnlock(lpAddress:LPVOID; dwSize:SIZE_T):BOOL;

function FlushInstructionCache(hProcess:HANDLE; lpBaseAddress:LPCVOID; dwSize:DWORD):BOOL;

function GetNumaHighestNodeNumber(var HighestNodeNumber:ULONG):BOOL;

function TlsAlloc:DWORD;

function TlsAllocEx(bFree:BOOL):DWORD;

function TlsGetValue(dwTlsIndex:DWORD):LPVOID;

function TlsSetValue(dwTlsIndex:DWORD; lpTlsValue:LPVOID):BOOL;

function TlsFree(dwTlsIndex:DWORD):BOOL;

function SwitchToThread:BOOL; inline;

procedure Sleep(dwMilliseconds:DWORD); inline;

function SleepEx(dwMilliseconds:DWORD; bAlertable:BOOL):DWORD; inline;

function GetCurrentThread:HANDLE;

function GetCurrentThreadId:DWORD;

function GetThreadPriority(hThread:HANDLE):Integer;

function SetThreadPriority(hThread:HANDLE; nPriority:Integer):BOOL;

function GetExitCodeThread(hThread:HANDLE; var lpExitCode:DWORD):BOOL;

function GetThreadAffinityMask(hThread:HANDLE):DWORD_PTR;

function SetThreadAffinityMask(hThread:HANDLE; dwThreadAffinityMask:DWORD_PTR):DWORD_PTR;

function GetThreadTimes(hThread:HANDLE; var lpCreationTime,lpExitTime,lpKernelTime,lpUserTime:FILETIME):BOOL;

function CreateThread(lpThreadAttributes:LPSECURITY_ATTRIBUTES; dwStackSize:DWORD; lpStartAddress:LPTHREAD_START_ROUTINE; lpParameter:LPVOID; dwCreationFlags:DWORD; lpThreadId:LPDWORD):HANDLE;

function OpenThread(dwDesiredAccess:DWORD; bInheritHandle:BOOL; dwThreadId:DWORD):HANDLE;

function SuspendThread(hThread:HANDLE):DWORD;

function ResumeThread(hThread:HANDLE):DWORD;

function TerminateThread(hThread:HANDLE; dwExitCode:DWORD):BOOL;

procedure ExitThread(dwExitCode:DWORD);

function WaitForSingleObject(hHandle:HANDLE; dwMilliseconds:DWORD):DWORD;

function WaitForMultipleObjects(nCount:DWORD; lpHandles:PHANDLE; bWaitAll:BOOL; dwMilliseconds:DWORD):DWORD;

function WaitForSingleObjectEx(hHandle:HANDLE; dwMilliseconds:DWORD; bAlertable:BOOL):DWORD;

function WaitForMultipleObjectsEx(nCount:DWORD; lpHandles:PHANDLE; bWaitAll:BOOL; dwMilliseconds:DWORD; bAlertable:BOOL):DWORD;

function BeginThreadEx(ThreadFunction:TThreadFunc; Parameter:Pointer; var ThreadId:TThreadID; const StackSize:SizeUInt; Priority,Affinity,CPU:LongWord; Name:PChar):TThreadID;

function WaitMessage:BOOL;

function GetMessage(lpMsg:LPMSG; hThread:HANDLE; wMsgFilterMin,wMsgFilterMax:UINT):BOOL;

function PeekMessage(var lpMsg:MSG; hThread:HANDLE; wMsgFilterMin,wMsgFilterMax,wRemoveMsg:UINT):BOOL;

function PostMessage(hThread:HANDLE; Msg:UINT; wParam:WPARAM; lParam:LPARAM):BOOL;

function SendMessage(hThread:HANDLE; Msg:UINT; wParam:WPARAM; lParam:LPARAM):LRESULT;

function SendMessageTimeout(hThread:HANDLE; Msg:UINT; wParam:WPARAM; lParam:LPARAM; fuFlags,uTimeout:UINT; var lpdwResult:DWORD_PTR):LRESULT;

function InterlockedIncrement(var lpAddend:LONG):LONG; inline;

function InterlockedDecrement(var lpAddend:LONG):LONG; inline;

function InterlockedExchange(var Target:LONG; Value:LONG):LONG; inline;

function InterlockedExchangePointer(var Target:PVOID; Value:PVOID):PVOID; inline;

function InterlockedExchangeAdd(var Addend:LONG; Value:LONG):LONG; inline;

function InterlockedCompareExchange(var Destination:LONG; Exchange:LONG; Comperand:LONG):LONG; inline;

function InterlockedCompareExchangePointer(var Destination:PVOID; Exchange,Comperand:PVOID):PVOID; inline;

function CreateMutex(lpMutexAttributes:LPSECURITY_ATTRIBUTES; bInitialOwner:BOOL; lpName:LPCSTR):HANDLE;

function CreateMutexA(lpMutexAttributes:LPSECURITY_ATTRIBUTES; bInitialOwner:BOOL; lpName:LPCSTR):HANDLE;

function CreateMutexW(lpMutexAttributes:LPSECURITY_ATTRIBUTES; bInitialOwner:BOOL; lpName:LPCWSTR):HANDLE;

function OpenMutex(dwDesiredAccess:DWORD; bInheritHandle:BOOL; lpName:LPCSTR):HANDLE;

function OpenMutexA(dwDesiredAccess:DWORD; bInheritHandle:BOOL; lpName:LPCSTR):HANDLE;

function OpenMutexW(dwDesiredAccess:DWORD; bInheritHandle:BOOL; lpName:LPCWSTR):HANDLE;

function ReleaseMutex(hMutex:HANDLE):BOOL;

function CreateSemaphore(lpSemaphoreAttributes:LPSECURITY_ATTRIBUTES; lInitialCount,lMaximumCount:LONG; lpName:LPCSTR):HANDLE;

function CreateSemaphoreA(lpSemaphoreAttributes:LPSECURITY_ATTRIBUTES; lInitialCount,lMaximumCount:LONG; lpName:LPCSTR):HANDLE;

function CreateSemaphoreW(lpSemaphoreAttributes:LPSECURITY_ATTRIBUTES; lInitialCount,lMaximumCount:LONG; lpName:LPCWSTR):HANDLE;

function OpenSemaphore(dwDesiredAccess:DWORD; bInheritHandle:BOOL; lpName:LPCSTR):HANDLE;

function OpenSemaphoreA(dwDesiredAccess:DWORD; bInheritHandle:BOOL; lpName:LPCSTR):HANDLE;

function OpenSemaphoreW(dwDesiredAccess:DWORD; bInheritHandle:BOOL; lpName:LPCWSTR):HANDLE;

function ReleaseSemaphore(hSemaphore:HANDLE; lReleaseCount:LONG; lpPreviousCount:LPLONG):BOOL;

procedure InitializeCriticalSection(var lpCriticalSection:CRITICAL_SECTION);

procedure EnterCriticalSection(var lpCriticalSection:CRITICAL_SECTION);

procedure LeaveCriticalSection(var lpCriticalSection:CRITICAL_SECTION);

function TryEnterCriticalSection(var lpCriticalSection:CRITICAL_SECTION):BOOL;

function InitializeCriticalSectionAndSpinCount(var lpCriticalSection:CRITICAL_SECTION; dwSpinCount:DWORD):BOOL;

function SetCriticalSectionSpinCount(var lpCriticalSection:CRITICAL_SECTION; dwSpinCount:DWORD):DWORD;

procedure DeleteCriticalSection(var lpCriticalSection:CRITICAL_SECTION);

function CreateEvent(lpEventAttributes:LPSECURITY_ATTRIBUTES; bManualReset,bInitialState:BOOL; lpName:LPCSTR):HANDLE;

function CreateEventA(lpEventAttributes:LPSECURITY_ATTRIBUTES; bManualReset,bInitialState:BOOL; lpName:LPCSTR):HANDLE;

function CreateEventW(lpEventAttributes:LPSECURITY_ATTRIBUTES; bManualReset,bInitialState:BOOL; lpName:LPCWSTR):HANDLE;

function OpenEvent(dwDesiredAccess:DWORD; bInheritHandle:BOOL; lpName:LPCSTR):HANDLE;

function OpenEventA(dwDesiredAccess:DWORD; bInheritHandle:BOOL; lpName:LPCSTR):HANDLE;

function OpenEventW(dwDesiredAccess:DWORD; bInheritHandle:BOOL; lpName:LPCWSTR):HANDLE;

function SetEvent(hEvent:HANDLE):BOOL;

function ResetEvent(hEvent:HANDLE):BOOL;

function PulseEvent(hEvent:HANDLE):BOOL;

function GetProcessAffinityMask(hProcess:HANDLE; var lpProcessAffinityMask,lpSystemAffinityMask:DWORD_PTR):BOOL;

function SetProcessAffinityMask(hProcess:HANDLE; dwProcessAffinityMask:DWORD_PTR):BOOL;

function GetProcessTimes(hProcess:HANDLE; var lpCreationTime,lpExitTime,lpKernelTime,lpUserTime:FILETIME):BOOL;

function GetProcessIoCounters(hProcess:HANDLE; var lpIoCounters:IO_COUNTERS):BOOL;

function GetCurrentProcess:HANDLE;

function GetCurrentProcessId:DWORD;

procedure ExitProcess(uExitCode:UINT);

procedure FatalExit(ExitCode:Integer);

function TerminateProcess(hProcess:HANDLE; uExitCode:UINT):BOOL;

procedure OutputDebugString(lpOutputString:LPCSTR);

procedure OutputDebugStringA(lpOutputString:LPCSTR);

procedure OutputDebugStringW(lpOutputString:LPCWSTR);

function lstrcmp(lpString1,lpString2:LPCSTR):Integer;

function lstrcmpA(lpString1,lpString2:LPCSTR):Integer;

function lstrcmpW(lpString1,lpString2:LPCWSTR):Integer;

function lstrcmpi(lpString1,lpString2:LPCSTR):Integer;

function lstrcmpiA(lpString1,lpString2:LPCSTR):Integer;

function lstrcmpiW(lpString1,lpString2:LPCWSTR):Integer;

function lstrcpy(lpString1:LPSTR; lpString2:LPCSTR):LPSTR;

function lstrcpyA(lpString1:LPSTR; lpString2:LPCSTR):LPSTR;

function lstrcpyW(lpString1:LPWSTR; lpString2:LPCWSTR):LPWSTR;

function lstrcpyn(lpString1:LPSTR; lpString2:LPCSTR; iMaxLength:Integer):LPSTR;

function lstrcpynA(lpString1:LPSTR; lpString2:LPCSTR; iMaxLength:Integer):LPSTR;

function lstrcpynW(lpString1:LPWSTR; lpString2:LPCWSTR; iMaxLength:Integer):LPWSTR;

function lstrcat(lpString1:LPSTR; lpString2:LPCSTR):LPSTR;

function lstrcatA(lpString1:LPSTR; lpString2:LPCSTR):LPSTR;

function lstrcatW(lpString1:LPWSTR; lpString2:LPCWSTR):LPWSTR;

function lstrlen(lpString:LPCSTR):Integer;

function lstrlenA(lpString:LPCSTR):Integer;

function lstrlenW(lpString:LPCWSTR):Integer;