1047 lines
82 KiB
Plaintext
1047 lines
82 KiB
Plaintext
int AcquireSRWLockExclusive(PSRWLOCK SRWLock);
|
|
int AcquireSRWLockShared(PSRWLOCK SRWLock);
|
|
int ActivateActCtx(HANDLE hActCtx,ULONG_PTR* lpCookie);
|
|
int AddAtom(LPCTSTR lpString);
|
|
int AddAtomA(LPCTSTR lpString);
|
|
int AddAtomW(LPCTSTR lpString);
|
|
int AddConsoleAlias(LPCTSTR Source,LPCTSTR Target,LPCTSTR ExeName);
|
|
int AddRefActCtx(HANDLE hActCtx);
|
|
int AddSIDToBoundaryDescriptor(HANDLE* BoundaryDescriptor,PSID RequiredSid);
|
|
int AddSecureMemoryCacheCallback(PSECURE_MEMORY_CACHE_CALLBACK pfnCallBack);
|
|
int AddVectoredContinueHandler(ULONG FirstHandler,PVECTORED_EXCEPTION_HANDLER VectoredHandler);
|
|
int AddVectoredExceptionHandler(ULONG FirstHandler,PVECTORED_EXCEPTION_HANDLER VectoredHandler);
|
|
int AdjustCalendarDate(LPCALDATETIME lpCalDateTime,CALDATETIME_DATEUNIT calUnit,INT amount);
|
|
int AllocConsole();
|
|
int AllocateUserPhysicalPages(HANDLE hProcess,PULONG_PTR NumberOfPages,PULONG_PTR UserPfnArray);
|
|
int AllocateUserPhysicalPagesNuma(HANDLE hProcess,PULONG_PTR NumberOfPages,PULONG_PTR PageArray,DWORD nndPreferred);
|
|
int ApplicationRecoveryFinished(BOOL bSuccess);
|
|
int ApplicationRecoveryInProgress(PBOOL pbCanceled);
|
|
int AreFileApisANSI();
|
|
int AssignProcessToJobObject(HANDLE hJob,HANDLE hProcess);
|
|
int AttachConsole(DWORD dwProcessId);
|
|
int BackupRead(HANDLE hFile,LPBYTE lpBuffer,DWORD nNumberOfBytesToRead,LPDWORD lpNumberOfBytesRead,BOOL bAbort,BOOL bProcessSecurity,LPVOID* lpContext);
|
|
int BackupSeek(HANDLE hFile,DWORD dwLowBytesToSeek,DWORD dwHighBytesToSeek,LPDWORD lpdwLowByteSeeked,LPDWORD lpdwHighByteSeeked,LPVOID* lpContext);
|
|
int BackupWrite(HANDLE hFile,LPBYTE lpBuffer,DWORD nNumberOfBytesToWrite,LPDWORD lpNumberOfBytesWritten,BOOL bAbort,BOOL bProcessSecurity,LPVOID* lpContext);
|
|
int Beep(DWORD dwFreq,DWORD dwDuration);
|
|
int BeginUpdateResource(LPCTSTR pFileName,BOOL bDeleteExistingResources);
|
|
int BindIoCompletionCallback(HANDLE FileHandle,LPOVERLAPPED_COMPLETION_ROUTINE Function,ULONG Flags);
|
|
int BuildCommDCB(LPCTSTR lpDef,LPDCB lpDCB);
|
|
int BuildCommDCBAndTimeouts(LPCTSTR lpDef,LPDCB lpDCB,LPCOMMTIMEOUTS lpCommTimeouts);
|
|
int CallbackMayRunLong(PTP_CALLBACK_INSTANCE pci);
|
|
int CancelIo(HANDLE hFile);
|
|
int CancelIoEx(HANDLE hFile,LPOVERLAPPED lpOverlapped);
|
|
int CancelSynchronousIo(HANDLE hThread);
|
|
int CancelThreadpoolIo(PTP_IO pio);
|
|
int CancelWaitableTimer(HANDLE hTimer);
|
|
int ChangeTimerQueueTimer(HANDLE TimerQueue,HANDLE Timer,ULONG DueTime,ULONG Period);
|
|
int CheckNameLegalDOS8Dot3(LPCTSTR lpName,LPSTR lpOemName,DWORD OemNameSize,PBOOL pbNameContainsSpaces,PBOOL pbNameLegal);
|
|
int CheckRemoteDebuggerPresent(HANDLE hProcess,PBOOL pbDebuggerPresent);
|
|
int ClearCommBreak(HANDLE hFile);
|
|
int ClearCommError(HANDLE hFile,LPDWORD lpErrors,LPCOMSTAT lpStat);
|
|
int CloseHandle(HANDLE hObject);
|
|
int ClosePrivateNamespace(HANDLE Handle,DWORD Flags);
|
|
int CloseThreadpool(PTP_POOL ptpp);
|
|
int CloseThreadpoolCleanupGroup(PTP_CLEANUP_GROUP ptpcg);
|
|
int CloseThreadpoolCleanupGroupMembers(PTP_CLEANUP_GROUP ptpcg,BOOL fCancelPendingCallbacks,PVOID pvCleanupContext);
|
|
int CloseThreadpoolIo(PTP_IO pio);
|
|
int CloseThreadpoolTimer(PTP_TIMER pti);
|
|
int CloseThreadpoolWait(PTP_WAIT pwa);
|
|
int CloseThreadpoolWork(PTP_WORK pwk);
|
|
int CommConfigDialog(LPCTSTR lpszName,HWND hWnd,LPCOMMCONFIG lpCC);
|
|
int CompareFileTime(const FILETIME* lpFileTime1,const FILETIME* lpFileTime2);
|
|
int CompareString(LCID Locale,DWORD dwCmpFlags,LPCTSTR lpString1,int cchCount1,LPCTSTR lpString2,int cchCount2);
|
|
int CompareStringA(LCID Locale,DWORD dwCmpFlags,LPCTSTR lpString1,int cchCount1,LPCTSTR lpString2,int cchCount2);
|
|
int CompareStringEx(LPCWSTR lpLocaleName,DWORD dwCmpFlags,LPCWSTR lpString1,int cchCount1,LPCWSTR lpString2,int cchCount2,LPNLSVERSIONINFO lpVersionInformation,LPVOID lpReserved,LPARAM lParam);
|
|
int CompareStringOrdinal(LPCWSTR lpString1,int cchCount1,LPCWSTR lpString2,int cchCount2,BOOL bIgnoreCase);
|
|
int CompareStringW(LCID Locale,DWORD dwCmpFlags,LPCTSTR lpString1,int cchCount1,LPCTSTR lpString2,int cchCount2);
|
|
int ContinueDebugEvent(DWORD dwProcessId,DWORD dwThreadId,DWORD dwContinueStatus);
|
|
int ConvertCalDateTimeToSystemTime(const LPCALDATETIME lpCalDateTime,SYSTEMTIME* lpSysTime);
|
|
int ConvertDefaultLocale(LCID Locale);
|
|
int ConvertFiberToThread();
|
|
int ConvertSystemTimeToCalDateTime(const SYSTEMTIME lpSysTime,CALID calId,LPCALDATETIME lpCalDateTime);
|
|
int ConvertThreadToFiber(LPVOID lpParameter);
|
|
int ConvertThreadToFiberEx(LPVOID lpParameter,DWORD dwFlags);
|
|
int CopyExtendedContext(PCONTEXT_EX Destination,DWORD ContextFlags,PCONTEXT_EX Source);
|
|
int CopyFile(LPCTSTR lpExistingFileName,LPCTSTR lpNewFileName,BOOL bFailIfExists);
|
|
int CopyFileA(LPCTSTR lpExistingFileName,LPCTSTR lpNewFileName,BOOL bFailIfExists);
|
|
int CopyFileEx(LPCTSTR lpExistingFileName,LPCTSTR lpNewFileName,LPPROGRESS_ROUTINE lpProgressRoutine,LPVOID lpData,LPBOOL pbCancel,DWORD dwCopyFlags);
|
|
int CopyFileTransacted(LPCTSTR lpExistingFileName,LPCTSTR lpNewFileName,LPPROGRESS_ROUTINE lpProgressRoutine,LPVOID lpData,LPBOOL pbCancel,DWORD dwCopyFlags,HANDLE hTransaction);
|
|
int CopyFileW(LPCTSTR lpExistingFileName,LPCTSTR lpNewFileName,BOOL bFailIfExists);
|
|
int CreateActCtx(PACTCTX pActCtx);
|
|
int CreateActCtxA(PACTCTX actctx);
|
|
int CreateActCtxW(PACTCTX actctx);
|
|
int CreateBoundaryDescriptor(LPCTSTR Name,ULONG Flags);
|
|
int CreateConsoleScreenBuffer(DWORD dwDesiredAccess,DWORD dwShareMode,const SECURITY_ATTRIBUTES* lpSecurityAttributes,DWORD dwFlags,LPVOID lpScreenBufferData);
|
|
int CreateDirectory(LPCTSTR lpPathName,LPSECURITY_ATTRIBUTES lpSecurityAttributes);
|
|
int CreateDirectoryA(LPCTSTR lpPathName,LPSECURITY_ATTRIBUTES pSecurityAttributes);
|
|
int CreateDirectoryEx(LPCTSTR lpTemplateDirectory,LPCTSTR lpNewDirectory,LPSECURITY_ATTRIBUTES lpSecurityAttributes);
|
|
int CreateDirectoryTransacted(LPCTSTR lpTemplateDirectory,LPCTSTR lpNewDirectory,LPSECURITY_ATTRIBUTES lpSecurityAttributes,HANDLE hTransaction);
|
|
int CreateDirectoryW(LPCTSTR lpPathName,LPSECURITY_ATTRIBUTES pSecurityAttributes);
|
|
int CreateEvent(LPSECURITY_ATTRIBUTES lpEventAttributes,BOOL bManualReset,BOOL bInitialState,LPCTSTR lpName);
|
|
int CreateEventA(LPSECURITY_ATTRIBUTES lpEventAttributes,BOOL bManualReset,BOOL bInitialState,LPCTSTR lpName);
|
|
int CreateEventEx(LPSECURITY_ATTRIBUTES lpEventAttributes,LPCTSTR lpName,DWORD dwFlags,DWORD dwDesiredAccess);
|
|
int CreateEventW(LPSECURITY_ATTRIBUTES lpEventAttributes,BOOL bManualReset,BOOL bInitialState,LPCTSTR lpName);
|
|
int CreateFiber(SIZE_T dwStackSize,LPFIBER_START_ROUTINE lpStartAddress,LPVOID lpParameter);
|
|
int CreateFiberEx(SIZE_T dwStackCommitSize,SIZE_T dwStackReserveSize,DWORD dwFlags,LPFIBER_START_ROUTINE lpStartAddress,LPVOID lpParameter);
|
|
int CreateFile(LPCTSTR lpFileName,DWORD dwDesiredAccess,DWORD dwShareMode,LPSECURITY_ATTRIBUTES lpSecurityAttributes,DWORD dwCreationDisposition,DWORD dwFlagsAndAttributes,HANDLE hTemplateFile);
|
|
int CreateFileA(LPCTSTR lpFileName,DWORD dwDesiredAccess,DWORD dwShareMode,LPSECURITY_ATTRIBUTES lpSecurityAttributes,DWORD dwCreationDistribution,DWORD dwFlagsAndAttributes,HANDLE hTemplateFile);
|
|
int CreateFileMapping(HANDLE hFile,LPSECURITY_ATTRIBUTES lpAttributes,DWORD flProtect,DWORD dwMaximumSizeHigh,DWORD dwMaximumSizeLow,LPCTSTR lpName);
|
|
int CreateFileMappingA(HANDLE hFile,LPSECURITY_ATTRIBUTES lpFileMappingAttributes,DWORD flProtect,DWORD dwMaximumSizeHigh,DWORD dwMaximumSizeLow,LPCTSTR lpName);
|
|
int CreateFileMappingNuma(HANDLE hFile,LPSECURITY_ATTRIBUTES lpFileMappingAttributes,DWORD flProtect,DWORD dwMaximumSizeHigh,DWORD dwMaximumSizeLow,LPCTSTR lpName,DWORD nndPreferred);
|
|
int CreateFileMappingW(HANDLE hFile,LPSECURITY_ATTRIBUTES lpFileMappingAttributes,DWORD flProtect,DWORD dwMaximumSizeHigh,DWORD dwMaximumSizeLow,LPCTSTR lpName);
|
|
int CreateFileTransacted(LPCTSTR lpFileName,DWORD dwDesiredAccess,DWORD dwShareMode,LPSECURITY_ATTRIBUTES lpSecurityAttributes,DWORD dwCreationDisposition,DWORD dwFlagsAndAttributes,HANDLE hTemplateFile,HANDLE hTransaction,PUSHORT pusMiniVersion,PVOID pExtendedParameter);
|
|
int CreateFileW(LPCTSTR lpFileName,DWORD dwDesiredAccess,DWORD dwShareMode,LPSECURITY_ATTRIBUTES lpSecurityAttributes,DWORD dwCreationDistribution,DWORD dwFlagsAndAttributes,HANDLE hTemplateFile);
|
|
int CreateHardLink(LPCTSTR lpFileName,LPCTSTR lpExistingFileName,LPSECURITY_ATTRIBUTES lpSecurityAttributes);
|
|
int CreateHardLinkTransacted(LPCTSTR lpFileName,LPCTSTR lpExistingFileName,LPSECURITY_ATTRIBUTES lpSecurityAttributes,HANDLE hTransaction);
|
|
int CreateIoCompletionPort(HANDLE FileHandle,HANDLE ExistingCompletionPort,ULONG_PTR CompletionKey,DWORD NumberOfConcurrentThreads);
|
|
int CreateJobObject(LPSECURITY_ATTRIBUTES lpJobAttributes,LPCTSTR lpName);
|
|
int CreateMailslot(LPCTSTR lpName,DWORD nMaxMessageSize,DWORD lReadTimeout,LPSECURITY_ATTRIBUTES lpSecurityAttributes);
|
|
int CreateMailslotA(LPCTSTR lpName,DWORD nMaxMessageSize,DWORD lReadTimeout,LPSECURITY_ATTRIBUTES lpSecurityAttributes);
|
|
int CreateMailslotW(LPCTSTR lpName,DWORD nMaxMessageSize,DWORD lReadTimeout,LPSECURITY_ATTRIBUTES lpSecurityAttributes);
|
|
int CreateMemoryResourceNotification(MEMORY_RESOURCE_NOTIFICATION_TYPE NotificationType);
|
|
int CreateMutex(LPSECURITY_ATTRIBUTES lpMutexAttributes,BOOL bInitialOwner,LPCTSTR lpName);
|
|
int CreateMutexA(LPSECURITY_ATTRIBUTES lpMutexAttributes,BOOL bInitialOwner,LPCTSTR lpName);
|
|
int CreateMutexEx(LPSECURITY_ATTRIBUTES lpMutexAttributes,LPCTSTR lpName,DWORD dwFlags,DWORD dwDesiredAccess);
|
|
int CreateMutexW(LPSECURITY_ATTRIBUTES lpMutexAttributes,BOOL bInitialOwner,LPCTSTR lpName);
|
|
int CreatePrivateNamespace(LPSECURITY_ATTRIBUTES lpPrivateNamespaceAttributes,LPVOID lpBoundaryDescriptor,LPCTSTR lpAliasPrefix);
|
|
bool CreateProcess(LPCTSTR lpApplicationName,LPTSTR lpCommandLine,LPSECURITY_ATTRIBUTES lpProcessAttributes,LPSECURITY_ATTRIBUTES lpThreadAttributes,BOOL bInheritHandles,DWORD dwCreationFlags,LPVOID lpEnvironment,LPCTSTR lpCurrentDirectory,LPSTARTUPINFO lpStartupInfo,LPPROCESS_INFORMATION lpProcessInformation);
|
|
bool CreateProcessA(LPCTSTR lpApplicationName,LPTSTR lpCommandLine,LPSECURITY_ATTRIBUTES lpProcessAttributes,LPSECURITY_ATTRIBUTES lpThreadAttributes,BOOL bInheritHandles,DWORD dwCreationFlags,LPVOID lpEnvironment,LPCTSTR lpCurrentDirectory,LPSTARTUPINFO lpStartupInfo,LPPROCESS_INFORMATION lpProcessInformation);
|
|
bool CreateProcessW(LPCTSTR lpApplicationName,LPTSTR lpCommandLine,LPSECURITY_ATTRIBUTES lpProcessAttributes,LPSECURITY_ATTRIBUTES lpThreadAttributes,BOOL bInheritHandles,DWORD dwCreationFlags,LPVOID lpEnvironment,LPCTSTR lpCurrentDirectory,LPSTARTUPINFO lpStartupInfo,LPPROCESS_INFORMATION lpProcessInformation);
|
|
int CreateRemoteThread(HANDLE hProcess,LPSECURITY_ATTRIBUTES lpThreadAttributes,SIZE_T dwStackSize,LPTHREAD_START_ROUTINE lpStartAddress,LPVOID lpParameter,DWORD dwCreationFlags,LPDWORD lpThreadId);
|
|
int CreateRemoteThreadEx(HANDLE hProcess,LPSECURITY_ATTRIBUTES lpThreadAttributes,SIZE_T dwStackSize,LPTHREAD_START_ROUTINE lpStartAddress,LPVOID lpParameter,DWORD dwCreationFlags,LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList,LPDWORD lpThreadId);
|
|
int CreateSemaphore(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,LONG lInitialCount,LONG lMaximumCount,LPCTSTR lpName);
|
|
int CreateSemaphoreA(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,LONG lInitialCount,LONG lMaximumCount,LPCTSTR lpName);
|
|
int CreateSemaphoreEx(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,LONG lInitialCount,LONG lMaximumCount,LPCTSTR lpName,DWORD dwFlags,DWORD dwDesiredAccess);
|
|
int CreateSemaphoreW(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,LONG lInitialCount,LONG lMaximumCount,LPCTSTR lpName);
|
|
int CreateSymbolicLink(LPTSTR lpSymlinkFileName,LPTSTR lpTargetFileName,DWORD dwFlags);
|
|
int CreateSymbolicLinkTransacted(LPTSTR lpSymlinkFileName,LPTSTR lpTargetFileName,DWORD dwFlags,HANDLE hTransaction);
|
|
int CreateTapePartition(HANDLE hDevice,DWORD dwPartitionMethod,DWORD dwCount,DWORD dwSize);
|
|
HANDLE CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes,SIZE_T dwStackSize,LPTHREAD_START_ROUTINE dwThreadFunction,LPVOID pThreadParm,DWORD dwCreationFlags,LPDWORD lpThreadId);
|
|
int CreateThreadpool(PVOID reserved);
|
|
int CreateThreadpoolCleanupGroup();
|
|
int CreateThreadpoolIo(HANDLE fl,PTP_WIN32_IO_CALLBACK pfnio,PVOID pv,PTP_CALLBACK_ENVIRON pcbe);
|
|
int CreateThreadpoolTimer(PTP_TIMER_CALLBACK pfnti,PVOID pv,PTP_CALLBACK_ENVIRON pcbe);
|
|
int CreateThreadpoolWait(PTP_WAIT_CALLBACK pfnwa,PVOID pv,PTP_CALLBACK_ENVIRON pcbe);
|
|
int CreateThreadpoolWork(PTP_WORK_CALLBACK pfnwk,PVOID pv,PTP_CALLBACK_ENVIRON pcbe);
|
|
int CreateTimerQueue();
|
|
int CreateTimerQueueTimer(PHANDLE phNewTimer,HANDLE TimerQueue,WAITORTIMERCALLBACK Callback,PVOID Parameter,DWORD DueTime,DWORD Period,DWORD Flags);
|
|
int CreateToolhelp32Snapshot(DWORD dwFlags,DWORD th32ProcessID);
|
|
int CreateUmsCompletionList(PUMS_COMPLETION_LIST* UmsCompletionList);
|
|
int CreateUmsThreadContext(PUMS_CONTEXT* lpUmsThread);
|
|
int CreateWaitableTimer(LPSECURITY_ATTRIBUTES lpTimerAttributes,BOOL bManualReset,LPCTSTR lpTimerName);
|
|
int CreateWaitableTimerA(LPSECURITY_ATTRIBUTES lpTimerAttributes,BOOL bManualReset,LPCTSTR lpTimerName);
|
|
int CreateWaitableTimerEx(LPSECURITY_ATTRIBUTES lpTimerAttributes,LPCTSTR lpTimerName,DWORD dwFlags,DWORD dwDesiredAccess);
|
|
int CreateWaitableTimerW(LPSECURITY_ATTRIBUTES lpTimerAttributes,BOOL bManualReset,LPCTSTR lpTimerName);
|
|
int DeactivateActCtx(DWORD dwFlags,ULONG_PTR ulCookie);
|
|
int DebugActiveProcess(DWORD dwProcessId);
|
|
int DebugActiveProcessStop(DWORD dwProcessId);
|
|
int DebugBreak();
|
|
int DebugBreakProcess(HANDLE Process);
|
|
int DebugSetProcessKillOnExit(BOOL KillOnExit);
|
|
int DeleteAtom(ATOM nAtom);
|
|
int DeleteBoundaryDescriptor(HANDLE BoundaryDescriptor);
|
|
int DeleteCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
|
|
int DeleteFiber(LPVOID lpFiber);
|
|
int DeleteFile(LPCTSTR lpFileName);
|
|
int DeleteFileA(LPCTSTR lpFileName);
|
|
int DeleteFileTransacted(LPCTSTR lpFileName,HANDLE hTransaction);
|
|
int DeleteFileW(LPCTSTR lpFileName);
|
|
int DeleteProcThreadAttributeList(LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList);
|
|
int DeleteTimerQueue(HANDLE TimerQueue);
|
|
int DeleteTimerQueueEx(HANDLE TimerQueue,HANDLE CompletionEvent);
|
|
int DeleteTimerQueueTimer(HANDLE TimerQueue,HANDLE Timer,HANDLE CompletionEvent);
|
|
int DeleteUmsCompletionList(PUMS_COMPLETION_LIST UmsCompletionList);
|
|
int DeleteUmsThreadContext(PUMS_CONTEXT UmsThread);
|
|
int DequeueUmsCompletionListItems(PUMS_COMPLETION_LIST UmsCompletionList,DWORD WaitTimeOut,PUMS_CONTEXT* UmsThreadList);
|
|
int DeviceIoControl(HANDLE hDevice,DWORD dwIoControlCode,LPVOID lpInBuffer,DWORD nInBufferSize,LPVOID pOutBuffer,DWORD nOutBufferSize,LPDWORD lpBytesReturned,LPOVERLAPPED lpOverlapped);
|
|
int DisableThreadLibraryCalls(HMODULE hModule);
|
|
int DisassociateCurrentThreadFromCallback(PTP_CALLBACK_INSTANCE pci);
|
|
int DnsHostnameToComputerName(LPCTSTR Hostname,LPTSTR ComputerName,LPDWORD nSize);
|
|
int DosDateTimeToFileTime(WORD wFatDate,WORD wFatTime,LPFILETIME lpFileTime);
|
|
int DuplicateHandle(HANDLE hSourceProcessHandle,HANDLE hSourceHandle,HANDLE hTargetProcessHandle,LPHANDLE pTargetHandle,DWORD dwDesiredAccess,BOOL bInheritHandle,DWORD dwOptions);
|
|
int EmptyWorkingSet(HANDLE hProcess);
|
|
int EndUpdateResource(HANDLE hUpdate,BOOL fDiscard);
|
|
int EnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
|
|
int EnterUmsSchedulingMode(PUMS_SCHEDULER_STARTUP_INFO SchedulerStartupInfo);
|
|
int EnumCalendarInfo(CALINFO_ENUMPROC pCalInfoEnumProc,LCID Locale,CALID Calendar,CALTYPE CalType);
|
|
int EnumCalendarInfoA(CALINFO_ENUMPROC lpCalInfoEnumProc,LCID Locale,CALID Calendar,CALTYPE CalType);
|
|
int EnumCalendarInfoEx(CALINFO_ENUMPROCEX pCalInfoEnumProcEx,LCID Locale,CALID Calendar,CALTYPE CalType);
|
|
int EnumCalendarInfoExEx(CALINFO_ENUMPROCEXEX pCalInfoEnumProcExEx,LPCWSTR lpLocaleName,CALID Calendar,LPCWSTR lpReserved,CALTYPE CalType,LPARAM lParam);
|
|
int EnumCalendarInfoW(CALINFO_ENUMPROC lpCalInfoEnumProc,LCID Locale,CALID Calendar,CALTYPE CalType);
|
|
int EnumDateFormats(DATEFMT_ENUMPROC lpDateFmtEnumProc,LCID Locale,DWORD dwFlags);
|
|
int EnumDateFormatsA(DATEFMT_ENUMPROC lpDateFmtEnumProc,LCID Locale,DWORD dwFlags);
|
|
int EnumDateFormatsEx(DATEFMT_ENUMPROCEX lpDateFmtEnumProcEx,LCID Locale,DWORD dwFlags);
|
|
int EnumDateFormatsExEx(DATEFMT_ENUMPROCEXEX lpDateFmtEnumProcExEx,LPCWSTR lpLocaleName,DWORD dwFlags,LPARAM lParam);
|
|
int EnumDateFormatsW(DATEFMT_ENUMPROC lpDateFmtEnumProc,LCID Locale,DWORD dwFlags);
|
|
int EnumDeviceDrivers(LPVOID* lpImageBase,DWORD cb,LPDWORD lpcbNeeded);
|
|
int EnumLanguageGroupLocales(LANGGROUPLOCALE_ENUMPROC lpLangGroupLocaleEnumProc,LGRPID LanguageGroup,DWORD dwFlags,LONG_PTR lParam);
|
|
int EnumPageFiles(PENUM_PAGE_CALLBACK pCallbackRoutine,LPVOID lpContext);
|
|
int EnumProcessModules(HANDLE hProcess,HMODULE* lphModule,DWORD cb,LPDWORD lpcbNeeded);
|
|
int EnumProcessModulesEx(HANDLE hProcess,HMODULE* lphModule,DWORD cb,LPDWORD lpcbNeeded,DWORD dwFilterFlag);
|
|
int EnumProcesses(LPVOID pProcessIds,DWORD cb,DWORD* pBytesReturned);
|
|
int EnumResourceLanguages(HMODULE hModule,LPCTSTR lpType,LPCTSTR lpName,ENUMRESLANGPROC lpEnumFunc,LONG_PTR lParam);
|
|
int EnumResourceLanguagesEx(HMODULE hModule,LPCTSTR lpType,LPCTSTR lpName,ENUMRESLANGPROC lpEnumFunc,LONG_PTR lParam,DWORD dwFlags,LANGID LangId);
|
|
int EnumResourceNames(HMODULE hModule,LPCTSTR lpszType,ENUMRESNAMEPROC lpEnumFunc,LONG_PTR lParam);
|
|
int EnumResourceNamesA(HMODULE hModule,LPCTSTR lpszType,ENUMRESNAMEPROC lpEnumFunc,LONG_PTR IParam);
|
|
int EnumResourceNamesEx(HMODULE hModule,LPCTSTR lpszType,ENUMRESNAMEPROC lpEnumFunc,LONG_PTR lParam,DWORD dwFlags,LANGID LangId);
|
|
int EnumResourceNamesW(HMODULE hModule,LPCTSTR lpszType,ENUMRESNAMEPROC lpEnumFunc,LONG_PTR IParam);
|
|
int EnumResourceTypes(HMODULE hModule,ENUMRESTYPEPROC lpEnumFunc,LONG_PTR lParam);
|
|
int EnumResourceTypesA(HMODULE hModule,ENUMRESTYPEPROC lpEnumFunc,LONG_PTR IParam);
|
|
int EnumResourceTypesEx(HMODULE hModule,ENUMRESTYPEPROC lpEnumFunc,LONG_PTR lParam,DWORD dwFlags,LANGID LangId);
|
|
int EnumSystemCodePages(CODEPAGE_ENUMPROC lpCodePageEnumProc,DWORD dwFlags);
|
|
int EnumSystemCodePagesA(CODEPAGE_ENUMPROC lpCodePageEnumProc,DWORD dwFlags);
|
|
int EnumSystemCodePagesW(CODEPAGE_ENUMPROC lpCodePageEnumProc,DWORD dwFlags);
|
|
int EnumSystemFirmwareTables(DWORD FirmwareTableProviderSignature,PVOID pFirmwareTableBuffer,DWORD BufferSize);
|
|
int EnumSystemGeoID(GEOCLASS GeoClass,GEOID ParentGeoId,GEO_ENUMPROC lpGeoEnumProc);
|
|
int EnumSystemLanguageGroups(LANGUAGEGROUP_ENUMPROC lpLanguageGroupEnumProc,DWORD dwFlags,LONG_PTR lParam);
|
|
int EnumSystemLocales(LOCALE_ENUMPROC lpLocaleEnumProc,DWORD dwFlags);
|
|
int EnumSystemLocalesA(LOCALE_ENUMPROC pLocaleEnumProc,DWORD dwFlags);
|
|
int EnumSystemLocalesEx(LOCALE_ENUMPROCEX lpLocaleEnumProcEx,DWORD dwFlags,LPARAM lParam,LPVOID lpReserved);
|
|
int EnumSystemLocalesW(LOCALE_ENUMPROC pLocaleEnumProc,DWORD dwFlags);
|
|
int EnumTimeFormats(TIMEFMT_ENUMPROC lpTimeFmtEnumProc,LCID Locale,DWORD dwFlags);
|
|
int EnumTimeFormatsA(TIMEFMT_ENUMPROC lpTimeFmtEnumProc,LCID Locale,DWORD dwFlags);
|
|
int EnumTimeFormatsEx(TIMEFMT_ENUMPROCEX lpTimeFmtEnumProcEx,LPCWSTR lpLocaleName,DWORD dwFlags,LPARAM lParam);
|
|
int EnumTimeFormatsW(TIMEFMT_ENUMPROC lpTimeFmtEnumProc,LCID Locale,DWORD dwFlags);
|
|
int EraseTape(HANDLE hDevice,DWORD dwEraseType,BOOL bImmediate);
|
|
int EscapeCommFunction(HANDLE hFile,DWORD dwFunc);
|
|
int ExecuteUmsThread(PUMS_CONTEXT UmsThread);
|
|
VOID ExitProcess(UINT uExitCode);
|
|
int ExitThread(DWORD uExitCode);
|
|
int ExpandEnvironmentStrings(LPCTSTR lpSrc,LPTSTR lpDst,DWORD nSize);
|
|
int ExpandEnvironmentStringsA(LPCTSTR lpSrc,LPTSTR lpDst,DWORD nSize);
|
|
int ExpandEnvironmentStringsW(LPCTSTR lpSrc,LPTSTR lpDst,DWORD nSize);
|
|
int FatalAppExit(UINT uAction,LPCTSTR lpMessageText);
|
|
int FatalExit(int ExitCode);
|
|
int FileTimeToDosDateTime(const FILETIME* lpFileTime,LPWORD lpFatDate,LPWORD lpFatTime);
|
|
int FileTimeToLocalFileTime(const FILETIME* lpFileTime,LPFILETIME lpLocalFileTime);
|
|
int FileTimeToSystemTime(const FILETIME* lpFileTime,LPSYSTEMTIME lpSystemTime);
|
|
int FillConsoleOutputAttribute(HANDLE hConsoleOutput,WORD wAttribute,DWORD nLength,COORD dwWriteCoord,LPDWORD lpNumberOfAttrsWritten);
|
|
int FillConsoleOutputCharacter(HANDLE hConsoleOutput,TCHAR cCharacter,DWORD nLength,COORD dwWriteCoord,LPDWORD lpNumberOfCharsWritten);
|
|
int FillConsoleOutputCharacterA(HANDLE hConsoleOutput,TCHAR cCharacter,DWORD nLength,COORD dwWriteCoord,LPDWORD lpNumberOfCharsWritten);
|
|
int FindActCtxSectionGuid(DWORD dwFlags,const GUID* lpExtensionGuid,DWORD ulSectionId,const GUID* lpGuidToFind,PACTCTX_SECTION_KEYED_DATA ReturnedData);
|
|
int FindActCtxSectionString(DWORD dwFlags,const GUID* lpExtensionGuid,DWORD ulSectionId,LPCTSTR lpStringToFind,PACTCTX_SECTION_KEYED_DATA ReturnedData);
|
|
int FindAtom(LPCTSTR lpString);
|
|
int FindAtomA(LPCTSTR lpString);
|
|
int FindAtomW(LPCTSTR lpString);
|
|
int FindClose(HANDLE hFindFile);
|
|
int FindCloseChangeNotification(HANDLE hChangeHandle);
|
|
int FindCloseChangeNotificationA(HANDLE hChangeHandle);
|
|
int FindCloseChangeNotificationW(HANDLE hChangeHandle);
|
|
int FindFirstChangeNotification(LPCTSTR lpPathName,BOOL bWatchSubtree,DWORD dwNotifyFilter);
|
|
int FindFirstChangeNotificationA(LPCTSTR lpPathName,BOOL bWatchSubtree,DWORD dwNotifyFilter);
|
|
int FindFirstChangeNotificationW(LPCTSTR lpPathName,BOOL bWatchSubtree,DWORD dwNotifyFilter);
|
|
int FindFirstFile(LPCTSTR lpFileName,LPWIN32_FIND_DATA lpFindFileData);
|
|
int FindFirstFileA(LPCTSTR lpFileName,LPWIN32_FIND_DATA lpFindFileData);
|
|
int FindFirstFileEx(LPCTSTR lpFileName,FINDEX_INFO_LEVELS fInfoLevelId,LPVOID lpFindFileData,FINDEX_SEARCH_OPS fSearchOp,LPVOID lpSearchFilter,DWORD dwAdditionalFlags);
|
|
int FindFirstFileNameTransactedW(LPCWSTR lpFileName,DWORD dwFlags,LPDWORD StringLength,PWCHAR LinkName,HANDLE hTransaction);
|
|
int FindFirstFileNameW(LPCWSTR lpFileName,DWORD dwFlags,LPDWORD StringLength,PWCHAR LinkName);
|
|
int FindFirstFileTransacted(LPCTSTR lpFileName,FINDEX_INFO_LEVELS fInfoLevelId,LPVOID lpFindFileData,FINDEX_SEARCH_OPS fSearchOp,LPVOID lpSearchFilter,DWORD dwAdditionalFlags,HANDLE hTransaction);
|
|
int FindFirstFileW(LPCTSTR lpFileName,LPWIN32_FIND_DATA lpFindFileData);
|
|
int FindFirstStreamTransactedW(LPCWSTR lpFileName,STREAM_INFO_LEVELS InfoLevel,LPVOID lpFindStreamData,DWORD dwFlags,HANDLE hTransaction);
|
|
int FindFirstStreamW(LPCWSTR lpFileName,STREAM_INFO_LEVELS InfoLevel,LPVOID lpFindStreamData,DWORD dwFlags);
|
|
int FindNLSString(LCID Locale,DWORD dwFindNLSStringFlags,LPCWSTR lpStringSource,int cchSource,LPCWSTR lpStringValue,int cchValue,LPINT pcchFound);
|
|
int FindNLSStringEx(LPCWSTR lpLocaleName,DWORD dwFindNLSStringFlags,LPCWSTR lpStringSource,int cchSource,LPCWSTR lpStringValue,int cchValue,LPINT pcchFound,LPNLSVERSIONINFO lpVersionInformation,LPVOID lpReserved,LPARAM lParam);
|
|
int FindNextChangeNotification(HANDLE hChangeHandle );
|
|
int FindNextFile(HANDLE hFindFile,LPWIN32_FIND_DATA lpFindFileData);
|
|
int FindNextFileA(HANDLE hFindFile,LPWIN32_FIND_DATA lpFindFileData);
|
|
int FindNextFileNameW(HANDLE hFindStream,LPDWORD StringLength,PWCHAR LinkName);
|
|
int FindNextFileW(HANDLE hFindFile,LPWIN32_FIND_DATA lpFindFileData);
|
|
int FindNextStreamW(HANDLE hFindStream,LPVOID lpFindStreamData);
|
|
int FindResource(HMODULE hModule,LPCTSTR lpName,LPCTSTR lpType);
|
|
int FindResourceA(HMODULE hModule,LPCTSTR lpName,LPCTSTR lpType);
|
|
int FindResourceEx(HMODULE hModule,LPCTSTR lpType,LPCTSTR lpName,WORD wLanguage);
|
|
int FindResourceExA(HMODULE hModule,LPCTSTR lpType,LPCTSTR lpName,WORD wLanguage);
|
|
int FindResourceExW(HMODULE hModule,LPCTSTR lpType,LPCTSTR lpName,WORD wLanguage);
|
|
int FindResourceW(HMODULE hModule,LPCTSTR lpName,LPCTSTR lpType);
|
|
int FindStringOrdinal(DWORD dwFindStringOrdinalFlags,LPCWSTR lpStringSource,int cchSource,LPCWSTR lpStringValue,int cchValue,BOOL bIgnoreCase);
|
|
int FlsAlloc(PFLS_CALLBACK_FUNCTION lpCallback);
|
|
int FlsFree(DWORD dwFlsIndex);
|
|
int FlsGetValue(DWORD dwFlsIndex);
|
|
int FlsSetValue(DWORD dwFlsIndex,PVOID lpFlsData);
|
|
int FlushConsoleInputBuffer(HANDLE hConsoleInput);
|
|
int FlushFileBuffers(HANDLE hFile);
|
|
int FlushInstructionCache(HANDLE hProcess,LPCVOID lpBaseAddress,SIZE_T dwSize);
|
|
int FlushProcessWriteBuffers();
|
|
int FlushViewOfFile(LPCVOID lpBaseAddress,SIZE_T dwNumberOfBytesToFlush);
|
|
int FoldString(DWORD dwMapFlags,LPCTSTR lpSrcStr,int cchSrc,LPTSTR lpDestStr,int cchDest);
|
|
int FormatMessage(DWORD dwFlags,LPCVOID lpSource,DWORD dwMessageId,DWORD dwLanguageId,LPTSTR lpBuffer,DWORD nSize,va_list* Arguments);
|
|
int FormatMessageA(DWORD dwFlags,LPCVOID lpSource,DWORD dwMessageId,DWORD dwLanguageId,LPTSTR lpBuffer,DWORD nSize,va_list* Arguments);
|
|
int FreeConsole();
|
|
int FreeEnvironmentStrings(LPTCH lpszEnvironmentBlock);
|
|
int FreeEnvironmentStringsA(LPTCH lpszEnvironmentBlock);
|
|
int FreeEnvironmentStringsW(LPTCH lpszEnvironmentBlock);
|
|
int FreeLibrary(HMODULE hLibModule);
|
|
int FreeLibraryAndExitThread(HMODULE hModule,DWORD dwExitCode);
|
|
int FreeLibraryWhenCallbackReturns(PTP_CALLBACK_INSTANCE pci,HMODULE mod);
|
|
int FreeResource(HGLOBAL HretResource);
|
|
int FreeUserPhysicalPages(HANDLE hProcess,PULONG_PTR NumberOfPages,PULONG_PTR UserPfnArray);
|
|
int GenerateConsoleCtrlEvent(DWORD dwCtrlEvent,DWORD dwProcessGroupId);
|
|
int GetACP();
|
|
int GetActiveProcessorCount(WORD GroupNumber);
|
|
int GetActiveProcessorGroupCount();
|
|
int GetApplicationRecoveryCallback(HANDLE hProcess,APPLICATION_RECOVERY_CALLBACK* pRecoveryCallback,PVOID* ppvParameter,DWORD dwPingInterval,DWORD dwFlags);
|
|
int GetApplicationRestartSettings(HANDLE hProcess,PWSTR pwzCommandline,PDWORD pcchSize,PDWORD pdwFlags);
|
|
int GetAtomName(ATOM nAtom,LPTSTR lpBuffer,int nSize);
|
|
int GetAtomNameA(ATOM nAtom,LPTSTR lpBuffer,int nSize);
|
|
int GetAtomNameW(ATOM nAtom,LPTSTR lpBuffer,int nSize);
|
|
int GetBinaryType(LPCTSTR lpApplicationName,DWORD lpBinaryType);
|
|
int GetBinaryTypeA(LPCTSTR lpApplicationName,DWORD lpBinaryType);
|
|
int GetBinaryTypeW(LPCTSTR lpApplicationName,DWORD lpBinaryType);
|
|
int GetCPInfo(UINT CodePage,LPCPINFO lpCPInfo);
|
|
int GetCPInfoEx(UINT CodePage,DWORD dwFlags,LPCPINFOEX lpCPInfoEx);
|
|
int GetCalendarDateFormatEx(LPCWSTR lpszLocale,DWORD dwFlags,const LPCALDATETIME lpCalDateTime,LPCWSTR lpFormat,LPWSTR lpDateStr,int cchDate);
|
|
int GetCalendarInfo(LCID Locale,CALID Calendar,CALTYPE CalType,LPTSTR lpCalData,int cchData,LPDWORD lpValue);
|
|
int GetCalendarInfoEx(LPCWSTR lpLocaleName,CALID Calendar,LPCWSTR lpReserved,CALTYPE CalType,LPWSTR lpCalData,int cchData,LPDWORD lpValue);
|
|
int GetCalendarSupportedDateRange(CALID Calendar,LPCALDATETIME lpCalMinDateTime,LPCALDATETIME lpCalMaxDateTime);
|
|
int GetCommConfig(HANDLE hCommDev,LPCOMMCONFIG lpCC,LPDWORD lpdwSize);
|
|
int GetCommMask(HANDLE hFile,LPDWORD lpEvtMask);
|
|
int GetCommModemStatus(HANDLE hFile,LPDWORD lpModemStat);
|
|
int GetCommProperties(HANDLE hFile,LPCOMMPROP lpCommProp);
|
|
int GetCommState(HANDLE hFile,LPDCB lpDCB);
|
|
int GetCommTimeouts(HANDLE hFile,LPCOMMTIMEOUTS lpCommTimeouts);
|
|
int GetCommandLine();
|
|
int GetCommandLineA();
|
|
int GetCommandLineW();
|
|
int GetCompressedFileSize(LPCTSTR lpFileName,LPDWORD lpFileSizeHigh);
|
|
int GetCompressedFileSizeTransacted(LPCTSTR lpFileName,LPDWORD lpFileSizeHigh,HANDLE hTransaction);
|
|
int GetComputerName(LPTSTR lpBuffer,LPDWORD lpnSize);
|
|
int GetComputerNameA(LPTSTR lpBuffer,LPDWORD nBufferSize);
|
|
int GetComputerNameEx(COMPUTER_NAME_FORMAT NameType,LPTSTR lpBuffer,LPDWORD lpnSize);
|
|
int GetComputerNameW(LPTSTR lpBuffer,LPDWORD nBufferSize);
|
|
int GetConsoleAlias(LPTSTR lpSource,LPTSTR lpTargetBuffer,DWORD TargetBufferLength,LPTSTR lpExeName);
|
|
int GetConsoleAliasExes(LPTSTR lpExeNameBuffer,DWORD ExeNameBufferLength);
|
|
int GetConsoleAliasExesLength();
|
|
int GetConsoleAliases(LPTSTR lpAliasBuffer,DWORD AliasBufferLength,LPTSTR lpExeName);
|
|
int GetConsoleAliasesLength(LPTSTR lpExeName);
|
|
int GetConsoleCP();
|
|
int GetConsoleCursorInfo(HANDLE hConsoleOutput,PCONSOLE_CURSOR_INFO lpConsoleCursorInfo);
|
|
int GetConsoleDisplayMode(LPDWORD lpdwMode);
|
|
int GetConsoleFontSize(HANDLE hConsoleOutput,DWORD nFont);
|
|
int GetConsoleHistoryInfo(PCONSOLE_HISTORY_INFO lpConsoleHistoryInfo);
|
|
int GetConsoleMode(HANDLE hConsoleHandle,DWORD lpMode);
|
|
int GetConsoleOriginalTitle(LPTSTR lpConsoleTitle,DWORD nSize);
|
|
int GetConsoleOutputCP();
|
|
int GetConsoleProcessList(LPDWORD lpdwProcessList,DWORD dwProcessCount);
|
|
int GetConsoleScreenBufferInfo(HANDLE hConsoleOutput,PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo);
|
|
int GetConsoleScreenBufferInfoEx(HANDLE hConsoleOutput,PCONSOLE_SCREEN_BUFFER_INFOEX lpConsoleScreenBufferInfoEx);
|
|
int GetConsoleSelectionInfo(PCONSOLE_SELECTION_INFO lpConsoleSelectionInfo);
|
|
int GetConsoleTitle(LPTSTR lpConsoleTitle,DWORD nSize);
|
|
int GetConsoleWindow();
|
|
int GetCurrencyFormat(LCID Locale,DWORD dwFlags,LPCTSTR lpValue,const CURRENCYFMT* lpFormat,LPTSTR lpCurrencyStr,int cchCurrency);
|
|
int GetCurrencyFormatA(LCID Locale,DWORD dwFlags,LPCTSTR lpValue,const CURRENCYFMT* lpFormat,LPTSTR lpCurrencyStr,int cchCurrency);
|
|
int GetCurrencyFormatEx(LPCWSTR lpLocaleName,DWORD dwFlags,LPCWSTR lpValue,const CURRENCYFMT* lpFormat,LPWSTR lpCurrencyStr,int cchCurrency);
|
|
int GetCurrencyFormatW(LCID Locale,DWORD dwFlags,LPCTSTR lpValue,const CURRENCYFMT* lpFormat,LPTSTR lpCurrencyStr,int cchCurrency);
|
|
int GetCurrentActCtx(HANDLE* lphActCtx);
|
|
int GetCurrentConsoleFont(HANDLE hConsoleOutput,BOOL bMaximumWindow,PCONSOLE_FONT_INFO lpConsoleCurrentFont);
|
|
int GetCurrentConsoleFontEx(HANDLE hConsoleOutput,BOOL bMaximumWindow,PCONSOLE_FONT_INFOEX lpConsoleCurrentFontEx);
|
|
int GetCurrentDirectory(DWORD nBufferLength,LPTSTR lpBuffer);
|
|
int GetCurrentDirectoryA(DWORD nBufferSize,LPTSTR lpBuffer);
|
|
int GetCurrentDirectoryW(DWORD nBufferSize,LPTSTR lpBuffer);
|
|
int GetCurrentProcess();
|
|
int GetCurrentProcessId();
|
|
int GetCurrentProcessorNumber();
|
|
int GetCurrentProcessorNumberEx(PPROCESSOR_NUMBER ProcNumber);
|
|
int GetCurrentThread();
|
|
int GetCurrentThreadId();
|
|
int GetCurrentUmsThread();
|
|
int GetDateFormat(LCID Locale,DWORD dwFlags,const SYSTEMTIME* lpDate,LPCTSTR lpFormat,LPTSTR lpDateStr,int cchDate);
|
|
int GetDateFormatA(LCID Locale,DWORD dwFlags,const SYSTEMTIME* lpDate,LPCTSTR lpFormat,LPTSTR lpDateStr,int cchDate);
|
|
int GetDateFormatEx(LPCWSTR lpLocaleName,DWORD dwFlags,const SYSTEMTIME* lpDate,LPCWSTR lpFormat,LPWSTR lpDateStr,int cchDate,LPCWSTR lpCalendar);
|
|
int GetDateFormatW(LCID Locale,DWORD dwFlags,const SYSTEMTIME* lpDate,LPCTSTR lpFormat,LPTSTR lpDateStr,int cchDate);
|
|
int GetDefaultCommConfig(LPCTSTR lpszName,LPCOMMCONFIG lpCC,LPDWORD lpdwSize);
|
|
int GetDeviceDriverBaseName(LPVOID ImageBase,LPTSTR lpBaseName,DWORD nSize);
|
|
int GetDeviceDriverFileName(LPVOID ImageBase,LPTSTR lpFilename,DWORD nSize);
|
|
int GetDevicePowerState(HANDLE hDevice,BOOL* pfOn);
|
|
int GetDiskFreeSpace(LPCTSTR lpRootPathName,LPDWORD lpSectorsPerCluster,LPDWORD lpBytesPerSector,LPDWORD lpNumberOfFreeClusters,LPDWORD lpTotalNumberOfClusters);
|
|
int GetDiskFreeSpaceA(LPCTSTR lpRootPathName,LPDWORD lpSectorsPerCluster,LPDWORD lpBytesPerSector,LPDWORD lpNumberOfFreeClusters,LPDWORD lpTotalNumberOfClusters);
|
|
int GetDiskFreeSpaceEx(LPCTSTR lpDirectoryName,PULARGE_INTEGER lpFreeBytesAvailable,PULARGE_INTEGER lpTotalNumberOfBytes,PULARGE_INTEGER lpTotalNumberOfFreeBytes);
|
|
int GetDiskFreeSpaceExA(LPCTSTR lpDirectoryName,PULARGE_INTEGER lpFreeBytesAvailableToCaller,PULARGE_INTEGER lpTotalNumberOfBytes,PULARGE_INTEGER lpTotalNumberOfFreeBytes);
|
|
int GetDiskFreeSpaceExW(LPCTSTR lpDirectoryName,PULARGE_INTEGER lpFreeBytesAvailableToCaller,PULARGE_INTEGER lpTotalNumberOfBytes,PULARGE_INTEGER lpTotalNumberOfFreeBytes);
|
|
int GetDiskFreeSpaceW(LPCTSTR lpRootPathName,LPDWORD lpSectorsPerCluster,LPDWORD lpBytesPerSector,LPDWORD lpNumberOfFreeClusters,LPDWORD lpTotalNumberOfClusters);
|
|
int GetDllDirectory(DWORD nBufferLength,LPTSTR lpBuffer);
|
|
int GetDurationFormat(LCID Locale,DWORD dwFlags,const SYSTEMTIME* lpDuration,ULONGLONG ullDuration,LPCWSTR lpFormat,LPWSTR lpDurationStr,int cchDuration);
|
|
int GetDurationFormatEx(LPCWSTR lpLocaleName,DWORD dwFlags,const SYSTEMTIME* lpDuration,ULONGLONG ullDuration,LPCWSTR lpFormat,LPWSTR lpDurationStr,int cchDuration);
|
|
int GetDynamicTimeZoneInformation(PDYNAMIC_TIME_ZONE_INFORMATION pTimeZoneInformation);
|
|
int GetEnabledExtendedFeatures(DWORD64 FeatureMask);
|
|
int GetEnvironmentStrings();
|
|
int GetEnvironmentStringsW();
|
|
int GetEnvironmentVariable(LPCTSTR lpName,LPTSTR lpBuffer,DWORD nSize);
|
|
int GetEnvironmentVariableA(LPCTSTR lpName,LPTSTR lpBuffer,DWORD nBufferSize);
|
|
int GetEnvironmentVariableW(LPCTSTR lpName,LPTSTR lpBuffer,DWORD nBufferSize);
|
|
int GetErrorMode();
|
|
int GetExitCodeProcess(HANDLE hProcess,LPDWORD lpExitCode);
|
|
int GetExitCodeThread(HANDLE hThread,LPDWORD lpExitCode);
|
|
int GetExtendedContextLength(DWORD ContextFlags,PDWORD ContextLength);
|
|
int GetExtendedFeaturesMask(PCONTEXT_EX ContextEx);
|
|
int GetFileAttributes(LPCTSTR lpFileName);
|
|
int GetFileAttributesA(LPCTSTR lpFileName);
|
|
int GetFileAttributesEx(LPCTSTR lpFileName,GET_FILEEX_INFO_LEVELS fInfoLevelId,LPVOID lpFileInformation);
|
|
int GetFileAttributesTransacted(LPCTSTR lpFileName,GET_FILEEX_INFO_LEVELS fInfoLevelId,LPVOID lpFileInformation,HANDLE hTransaction);
|
|
int GetFileAttributesW(LPCTSTR lpFileName);
|
|
int GetFileBandwidthReservation(HANDLE hFile,LPDWORD lpPeriodMilliseconds,LPDWORD lpBytesPerPeriod,LPBOOL pDiscardable,LPDWORD lpTransferSize,LPDWORD lpNumOutstandingRequests);
|
|
int GetFileInformationByHandle(HANDLE hFile,LPBY_HANDLE_FILE_INFORMATION lpFileInformation);
|
|
int GetFileInformationByHandleEx(HANDLE hFile,FILE_INFO_BY_HANDLE_CLASS FileInformationClass,LPVOID lpFileInformation,DWORD dwBufferSize);
|
|
int GetFileSize(HANDLE hFile,LPDWORD lpFileSizeHigh);
|
|
int GetFileSizeEx(HANDLE hFile,PLARGE_INTEGER lpFileSize);
|
|
int GetFileTime(HANDLE hFile,LPFILETIME lpCreationTime,LPFILETIME lpLastAccessTime,LPFILETIME lpLastWriteTime);
|
|
int GetFileType(HANDLE hFile);
|
|
int GetFinalPathNameByHandle(HANDLE hFile,LPTSTR lpszFilePath,DWORD cchFilePath,DWORD dwFlags);
|
|
int GetFirmwareEnvironmentVariable(LPCTSTR lpName,LPCTSTR lpGuid,PVOID pBuffer,DWORD nSize);
|
|
int GetFullPathName(LPCTSTR lpFileName,DWORD nBufferLength,LPTSTR lpBuffer,LPTSTR* lpFilePart);
|
|
int GetFullPathNameA(LPCTSTR lpFileName,DWORD nBufferSize,LPTSTR lpBuffer,LPTSTR* lpFilePart);
|
|
int GetFullPathNameTransacted(LPCTSTR lpFileName,DWORD nBufferLength,LPTSTR lpBuffer,LPTSTR* lpFilePart,HANDLE hTransaction);
|
|
int GetFullPathNameW(LPCTSTR lpFileName,DWORD nBufferSize,LPTSTR lpBuffer,LPTSTR* lpFilePart);
|
|
int GetGeoInfo(GEOID Location,GEOTYPE GeoType,LPTSTR lpGeoData,int cchData,LANGID LangId);
|
|
int GetHandleInformation(HANDLE hObject,LPDWORD lpdwFlags);
|
|
int GetLargePageMinimum();
|
|
int GetLargestConsoleWindowSize(HANDLE hConsoleOutput);
|
|
int GetLastError();
|
|
int GetLocalTime(LPSYSTEMTIME lpSystemTime);
|
|
int GetLocaleInfo(LCID Locale,LCTYPE LCType,LPTSTR lpLCData,int cchData);
|
|
int GetLocaleInfoA(LCID Locale,LCTYPE LCType,LPTSTR lpLCData,int cchData);
|
|
int GetLocaleInfoEx(LPCWSTR lpLocaleName,LCTYPE LCType,LPWSTR lpLCData,int cchData);
|
|
int GetLocaleInfoW(LCID Locale,LCTYPE LCType,LPTSTR lpLCData,int cchData);
|
|
int GetLogicalProcessorInformation(PSYSTEM_LOGICAL_PROCESSOR_INFORMATION Buffer,PDWORD ReturnLength);
|
|
int GetLogicalProcessorInformationEx(LOGICAL_PROCESSOR_RELATIONSHIP RelationshipType,PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX Buffer,PDWORD ReturnedLength);
|
|
int GetLongPathName(LPCTSTR lpszShortPath,LPTSTR lpszLongPath,DWORD cchBuffer);
|
|
int GetLongPathNameA(LPCTSTR lpszShortPath,LPTSTR lpBuffer,DWORD nBuffer);
|
|
int GetLongPathNameTransacted(LPCTSTR lpszShortPath,LPTSTR lpszLongPath,DWORD cchBuffer,HANDLE hTransaction);
|
|
int GetLongPathNameW(LPCTSTR lpszShortPath,LPTSTR lpBuffer,DWORD nBuffer);
|
|
int GetMailslotInfo(HANDLE hMailslot,LPDWORD lpMaxMessageSize,LPDWORD lpNextSize,LPDWORD lpMessageCount,LPDWORD lpReadTimeout);
|
|
int GetMappedFileName(HANDLE hProcess,LPVOID lpv,LPTSTR lpFilename,DWORD nSize);
|
|
int GetMaximumProcessorCount(WORD GroupNumber);
|
|
int GetMaximumProcessorGroupCount();
|
|
int GetModuleBaseName(HANDLE hProcess,HMODULE hModule,LPTSTR lpBaseName,DWORD nSize);
|
|
int GetModuleFileName(HMODULE hModule,LPTSTR lpFilename,DWORD nSize);
|
|
int GetModuleFileNameA(HMODULE hModule,LPTSTR lpBuffer,DWORD nBufferSize);
|
|
int GetModuleFileNameEx(HANDLE hProcess,HMODULE hModule,LPTSTR lpFilename,DWORD nSize);
|
|
int GetModuleFileNameExA(HANDLE hProcess,HMODULE hModule,LPTSTR lpBuffer,DWORD nBufferSize);
|
|
int GetModuleFileNameExW(HANDLE hProcess,HMODULE hModule,LPTSTR lpBuffer,DWORD nBufferSize);
|
|
int GetModuleFileNameW(HMODULE hModule,LPTSTR lpBuffer,DWORD nBufferSize);
|
|
int GetModuleHandle(LPCTSTR lpModuleName);
|
|
int GetModuleHandleA(LPCTSTR lpModuleName);
|
|
int GetModuleHandleEx(DWORD dwFlags,LPCTSTR lpModuleName,HMODULE* phModule);
|
|
int GetModuleHandleW(LPCTSTR lpModuleName);
|
|
int GetModuleInformation(HANDLE hProcess,HMODULE hModule,LPMODULEINFO lpmodinfo,DWORD dwSizemodinfo);
|
|
int GetNLSVersion(NLS_FUNCTION Function,LCID Locale,LPNLSVERSIONINFO lpVersionInformation);
|
|
int GetNLSVersionEx(NLS_FUNCTION function,LPCWSTR lpLocaleName,LPNLSVERSIONINFOEX lpVersionInformation);
|
|
int GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo);
|
|
int GetNextUmsListItem(PUMS_CONTEXT UmsContext);
|
|
int GetNumaAvailableMemoryNode(UCHAR Node,PULONGLONG AvailableBytes);
|
|
int GetNumaAvailableMemoryNodeEx(USHORT Node,PULONGLONG AvailableBytes);
|
|
int GetNumaHighestNodeNumber(PULONG HighestNodeNumber);
|
|
int GetNumaNodeNumberFromHandle(HANDLE hFile,PUSHORT NodeNumber);
|
|
int GetNumaNodeProcessorMask(UCHAR Node,PULONGLONG ProcessorMask);
|
|
int GetNumaNodeProcessorMaskEx(USHORT Node,PGROUP_AFFINITY ProcessorMask);
|
|
int GetNumaProcessorNode(UCHAR Processor,PUCHAR NodeNumber);
|
|
int GetNumaProcessorNodeEx(PPROCESSOR_NUMBER Processor,PUSHORT NodeNumber);
|
|
int GetNumaProximityNode(ULONG ProximityId,PUCHAR NodeNumber);
|
|
int GetNumaProximityNodeEx(ULONG ProximityId,PUSHORT NodeNumber);
|
|
int GetNumberFormat(LCID Locale,DWORD dwFlags,LPCTSTR lpValue,const NUMBERFMT* lpFormat,LPTSTR lpNumberStr,int cchNumber);
|
|
int GetNumberFormatA(LCID Locale,DWORD dwFlags,LPCTSTR lpValue,const NUMBERFMT* lpFormat,LPTSTR lpNumberStr,int cchNumber);
|
|
int GetNumberFormatEx(LPCWSTR lpLocaleName,DWORD dwFlags,LPCWSTR lpValue,const NUMBERFMT* lpFormat,LPWSTR lpNumberStr,int cchNumber);
|
|
int GetNumberFormatW(LCID Locale,DWORD dwFlags,LPCTSTR lpValue,const NUMBERFMT* lpFormat,LPTSTR lpNumberStr,int cchNumber);
|
|
int GetNumberOfConsoleInputEvents(HANDLE hConsoleInput,LPDWORD lpcNumberOfEvents);
|
|
int GetNumberOfConsoleMouseButtons(LPDWORD lpNumberOfMouseButtons);
|
|
int GetOEMCP();
|
|
int GetOverlappedResult(HANDLE hFile,LPOVERLAPPED lpOverlapped,LPDWORD lpNumberOfBytesTransferred,BOOL bWait);
|
|
int GetPerformanceInfo(PPERFORMANCE_INFORMATION pPerformanceInformation,DWORD cb);
|
|
int GetPhysicallyInstalledSystemMemory(PULONGLONG TotalMemoryInKilobytes);
|
|
int GetPriorityClass(HANDLE hProcess);
|
|
int GetPrivateProfileInt(LPCTSTR lpAppName,LPCTSTR lpKeyName,INT nDefault,LPCTSTR lpFileName);
|
|
int GetPrivateProfileIntA(LPCTSTR lpAppName,LPCTSTR lpKeyName,INT nDefault,LPCTSTR lpFileName);
|
|
int GetPrivateProfileIntW(LPCTSTR lpAppName,LPCTSTR lpKeyName,INT nDefault,LPCTSTR lpFileName);
|
|
int GetPrivateProfileSection(LPCTSTR lpAppName,LPTSTR lpReturnedString,DWORD nSize,LPCTSTR lpFileName);
|
|
int GetPrivateProfileSectionA(LPCTSTR lpAppName,LPTSTR lpReturnedString,DWORD nSize,LPCTSTR lpFileName);
|
|
int GetPrivateProfileSectionNames(LPTSTR lpszReturnBuffer,DWORD nSize,LPCTSTR lpFileName);
|
|
int GetPrivateProfileSectionW(LPCTSTR lpAppName,LPTSTR lpReturnedString,DWORD nSize,LPCTSTR lpFileName);
|
|
int GetPrivateProfileString(LPCTSTR lpAppName,LPCTSTR lpKeyName,LPCTSTR lpDefault,LPTSTR lpReturnedString,DWORD nSize,LPCTSTR lpFileName);
|
|
int GetPrivateProfileStringA(LPCTSTR lpAppName,LPCTSTR lpKeyName,LPCTSTR lpDefault,LPTSTR lpBuffer,DWORD nSize,LPCTSTR lpFileName);
|
|
int GetPrivateProfileStringW(LPCTSTR lpAppName,LPCTSTR lpKeyName,LPCTSTR lpDefault,LPTSTR lpBuffer,DWORD nSize,LPCTSTR lpFileName);
|
|
int GetPrivateProfileStruct(LPCTSTR lpszSection,LPCTSTR lpszKey,LPVOID lpStruct,UINT uSizeStruct,LPCTSTR szFile);
|
|
int GetPrivateProfileStructA(LPCTSTR lpszSection,LPCTSTR lpszKey,LPVOID lpStruct,UINT uSizeStruct,LPCTSTR szFile);
|
|
int GetProcAddress(HMODULE hModule,LPCSTR lpProcName);
|
|
int GetProcessAffinityMask(HANDLE hProcess,PDWORD_PTR lpProcessAffinityMask,PDWORD_PTR lpSystemAffinityMask);
|
|
int GetProcessDEPPolicy(HANDLE hProcess,LPDWORD lpFlags,PBOOL lpPermanent);
|
|
int GetProcessGroupAffinity(HANDLE hProcess,PUSHORT GroupCount,PUSHORT GroupArray);
|
|
int GetProcessHandleCount(HANDLE hProcess,PDWORD pdwHandleCount);
|
|
int GetProcessHeap();
|
|
int GetProcessHeaps(DWORD NumberOfHeaps,PHANDLE ProcessHeaps);
|
|
int GetProcessId(HANDLE Process);
|
|
int GetProcessIdOfThread(HANDLE Thread);
|
|
int GetProcessImageFileName(HANDLE hProcess,LPTSTR lpImageFileName,DWORD nSize);
|
|
int GetProcessIoCounters(HANDLE hProcess,PIO_COUNTERS lpIoCounters);
|
|
int GetProcessMemoryInfo(HANDLE Process,PPROCESS_MEMORY_COUNTERS ppsmemCounters,DWORD cb);
|
|
int GetProcessPriorityBoost(HANDLE hProcess,PBOOL pDisablePriorityBoost);
|
|
int GetProcessShutdownParameters(LPDWORD lpdwLevel,LPDWORD lpdwFlags);
|
|
int GetProcessTimes(HANDLE hProcess,LPFILETIME lpCreationTime,LPFILETIME lpExitTime,LPFILETIME lpKernelTime,LPFILETIME lpUserTime);
|
|
int GetProcessVersion(DWORD ProcessId);
|
|
int GetProcessWorkingSetSize(HANDLE hProcess,PSIZE_T lpMinimumWorkingSetSize,PSIZE_T lpMaximumWorkingSetSize);
|
|
int GetProcessWorkingSetSizeEx(HANDLE hProcess,PSIZE_T lpMinimumWorkingSetSize,PSIZE_T lpMaximumWorkingSetSize,PDWORD Flags);
|
|
int GetProcessorSystemCycleTime(USHORT Group,PSYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION Buffer,PDWORD ReturnedLength);
|
|
int GetProductInfo(DWORD dwOSMajorVersion,DWORD dwOSMinorVersion,DWORD dwSpMajorVersion,DWORD dwSpMinorVersion,DWORD pdwReturnedProductType);
|
|
UINT GetProfileInt(LPCTSTR lpAppName,LPCTSTR lpKeyName,INT nDefault);
|
|
UINT GetProfileIntA(LPCTSTR lpAppName,LPCTSTR lpKeyName,INT nDefault);
|
|
UINT GetProfileIntW(LPCTSTR lpAppName,LPCWSTR lpKeyName,INT nDefault);
|
|
int GetProfileSection(LPCTSTR lpAppName,LPTSTR lpReturnedString,DWORD nSize);
|
|
int GetProfileSectionA(LPCTSTR lpAppName,LPTSTR lpReturnedString,DWORD nSize);
|
|
int GetProfileSectionW(LPCTSTR lpAppName,LPTSTR lpReturnedString,DWORD nSize);
|
|
int GetProfileString(LPCTSTR lpAppName,LPCTSTR lpKeyName,LPCTSTR lpDefault,LPTSTR lpReturnedString,DWORD nSize);
|
|
int GetProfileStringA(LPCTSTR lpAppName,LPCTSTR lpKeyName,LPCTSTR lpDefault,LPTSTR lpReturnedString,DWORD nSize);
|
|
int GetProfileStringW(LPCTSTR lpAppName,LPCTSTR lpKeyName,LPCTSTR lpDefault,LPTSTR lpReturnedString,DWORD nSize);
|
|
int GetQueuedCompletionStatus(HANDLE CompletionPort,LPDWORD lpNumberOfBytes,PULONG_PTR lpCompletionKey,LPOVERLAPPED* lpOverlapped,DWORD dwMilliseconds);
|
|
int GetQueuedCompletionStatusEx(HANDLE CompletionPort,LPOVERLAPPED_ENTRY lpCompletionPortEntries,ULONG ulCount,PULONG ulNumEntriesRemoved,DWORD dwMilliseconds,BOOL fAlertable);
|
|
int GetShortPathName(LPCTSTR lpszLongPath,LPTSTR lpszShortPath,DWORD cchBuffer);
|
|
int GetShortPathNameA(LPCTSTR lpszLongPath,LPTSTR lpBuffer,DWORD cchBuffer);
|
|
int GetShortPathNameW(LPCTSTR lpszLongPath,LPTSTR lpBuffer,DWORD cchBuffer);
|
|
int GetStartupInfo(LPSTARTUPINFO lpStartupInfo);
|
|
int GetStartupInfoA(LPSTARTUPINFO lpStartupInfo);
|
|
int GetStartupInfoW(LPSTARTUPINFO lpStartupInfo);
|
|
int GetStdHandle(DWORD nStdHandle);
|
|
int GetStringScripts(DWORD dwFlags,LPCWSTR lpString,int cchString,LPWSTR lpScripts,int cchScripts);
|
|
int GetStringTypeA(LCID Locale,DWORD dwInfoType,LPCSTR lpSrcStr,int cchSrc,LPWORD lpCharType);
|
|
int GetStringTypeEx(LCID Locale,DWORD dwInfoType,LPCTSTR lpSrcStr,int cchSrc,LPWORD lpCharType);
|
|
int GetStringTypeExA(LCID Locale,DWORD dwInfoType,LPCTSTR lpSrcStr,int cchSrc,LPWORD lpCharType);
|
|
int GetStringTypeExW(LCID Locale,DWORD dwInfoType,LPCTSTR lpSrcStr,int cchSrc,LPWORD lpCharType);
|
|
int GetStringTypeW(DWORD Locale,LPCWSTR dwInfoType,int lpSrcStr,LPWORD cchSrc,LPWORD lpCharType);
|
|
int GetSystemDEPPolicy();
|
|
int GetSystemDefaultLCID();
|
|
int GetSystemDefaultLangID();
|
|
int GetSystemDefaultLocaleName(LPWSTR lpLocaleName,int cchLocaleName);
|
|
int GetSystemDirectory(LPTSTR lpBuffer,UINT uSize);
|
|
int GetSystemDirectoryA(LPTSTR lpBuffer,UINT nBufferSize);
|
|
int GetSystemDirectoryW(LPTSTR lpBuffer,UINT nBufferSize);
|
|
int GetSystemFileCacheSize(PSIZE_T lpMinimumFileCacheSize,PSIZE_T lpMaximumFileCacheSize,PDWORD lpFlags);
|
|
int GetSystemFirmwareTable(DWORD FirmwareTableProviderSignature,DWORD FirmwareTableID,PVOID pFirmwareTableBuffer,DWORD BufferSize);
|
|
int GetSystemInfo(LPSYSTEM_INFO lpSystemInfo);
|
|
int GetSystemPowerStatus(LPSYSTEM_POWER_STATUS lpSystemPowerStatus);
|
|
int GetSystemRegistryQuota(PDWORD pdwQuotaAllowed,PDWORD pdwQuotaUsed);
|
|
int GetSystemTime(LPSYSTEMTIME lpSystemTime);
|
|
int GetSystemTimeAdjustment(PDWORD lpTimeAdjustment,PDWORD lpTimeIncrement,PBOOL lpTimeAdjustmentDisabled);
|
|
int GetSystemTimeAsFileTime(LPFILETIME lpSystemTimeAsFileTime);
|
|
int GetSystemTimes(LPFILETIME lpIdleTime,LPFILETIME lpKernelTime,LPFILETIME lpUserTime);
|
|
int GetSystemWindowsDirectory(LPTSTR lpBuffer,UINT uSize);
|
|
int GetSystemWow64Directory(LPTSTR lpBuffer,UINT uSize);
|
|
int GetTapeParameters(HANDLE hDevice,DWORD dwOperation,LPDWORD lpdwSize,LPVOID lpTapeInformation);
|
|
int GetTapePosition(HANDLE hDevice,DWORD dwPositionType,LPDWORD lpdwPartition,LPDWORD lpdwOffsetLow,LPDWORD lpdwOffsetHigh);
|
|
int GetTapeStatus(HANDLE hDevice);
|
|
int GetTempFileName(LPCTSTR lpPathName,LPCTSTR lpPrefixString,UINT uUnique,LPTSTR lpTempFileName);
|
|
int GetTempFileNameA(LPCTSTR lpPathName,LPCTSTR lpPrefixString,UINT uUnique,LPTSTR lpTempFileName);
|
|
int GetTempFileNameW(LPCTSTR lpPathName,LPCTSTR lpPrefixString,UINT uUnique,LPTSTR lpTempFileName);
|
|
int GetTempPath(DWORD nBufferLength,LPTSTR lpBuffer);
|
|
int GetTempPathA(DWORD nBufferSize,LPTSTR lpBuffer);
|
|
int GetTempPathW(DWORD nBufferSize,LPTSTR lpBuffer);
|
|
int GetThreadContext(HANDLE hThread,LPCONTEXT lpContext);
|
|
int GetThreadErrorMode();
|
|
int GetThreadGroupAffinity(HANDLE hThread,PGROUP_AFFINITY GroupAffinity);
|
|
int GetThreadIOPendingFlag(HANDLE hThread,PBOOL lpIOIsPending);
|
|
int GetThreadId(HANDLE Thread);
|
|
int GetThreadIdealProcessorEx(HANDLE hThread,PPROCESSOR_NUMBER lpIdealProcessor);
|
|
int GetThreadLocale();
|
|
int GetThreadPriority(HANDLE hThread);
|
|
int GetThreadPriorityBoost(HANDLE hThread,PBOOL pDisablePriorityBoost);
|
|
int GetThreadSelectorEntry(HANDLE hThread,DWORD dwSelector,LPLDT_ENTRY lpSelectorEntry);
|
|
int GetThreadTimes(HANDLE hThread,LPFILETIME lpCreationTime,LPFILETIME lpExitTime,LPFILETIME lpKernelTime,LPFILETIME lpUserTime);
|
|
int GetTickCount();
|
|
int GetTickCount64();
|
|
int GetTimeFormat(LCID Locale,DWORD dwFlags,const SYSTEMTIME* lpTime,LPCTSTR lpFormat,LPTSTR lpTimeStr,int cchTime);
|
|
int GetTimeFormatA(LCID Locale,DWORD dwFlags,const SYSTEMTIME* lpTime,LPCTSTR lpFormat,LPTSTR lpTimeStr,int cchTime);
|
|
int GetTimeFormatEx(LPCWSTR lpLocaleName,DWORD dwFlags,const SYSTEMTIME* lpTime,LPCWSTR lpFormat,LPWSTR lpTimeStr,int cchTime);
|
|
int GetTimeFormatW(LCID Locale,DWORD dwFlags,const SYSTEMTIME* lpTime,LPCTSTR lpFormat,LPTSTR lpTimeStr,int cchTime);
|
|
int GetTimeZoneInformation(LPTIME_ZONE_INFORMATION lpTimeZoneInformation);
|
|
int GetTimeZoneInformationForYear(USHORT wYear,PDYNAMIC_TIME_ZONE_INFORMATION pdtzi,LPTIME_ZONE_INFORMATION ptzi);
|
|
int GetUmsCompletionListEvent(PUMS_COMPLETION_LIST UmsCompletionList,PHANDLE UmsCompletionEvent);
|
|
int GetUserDefaultLCID();
|
|
int GetUserDefaultLangID();
|
|
int GetUserDefaultLocaleName(LPWSTR lpLocaleName,int cchLocaleName);
|
|
int GetUserGeoID(GEOCLASS GeoClass);
|
|
int GetVersion();
|
|
bool GetVersionEx(LPOSVERSIONINFO lpVersionInfo);
|
|
bool GetVersionExA(LPOSVERSIONINFO lpVersionInformation);
|
|
bool GetVersionExW(LPOSVERSIONINFO lpVersionInformation);
|
|
int GetWindowsDirectory(LPTSTR lpBuffer,UINT uSize);
|
|
int GetWindowsDirectoryA(LPTSTR lpBuffer,UINT nBufferSize);
|
|
int GetWindowsDirectoryW(LPTSTR lpBuffer,UINT nBufferSize);
|
|
int GetWriteWatch(DWORD dwFlags,PVOID lpBaseAddress,SIZE_T dwRegionSize,PVOID* lpAddresses,PULONG_PTR lpdwCount,PULONG lpdwGranularity);
|
|
int GetWsChanges(HANDLE hProcess,PPSAPI_WS_WATCH_INFORMATION lpWatchInfo,DWORD cb);
|
|
int GetWsChangesEx(HANDLE hProcess,PPSAPI_WS_WATCH_INFORMATION_EX lpWatchInfoEx,DWORD cb);
|
|
int GlobalAddAtom(LPCTSTR lpString);
|
|
int GlobalAddAtomA(LPCTSTR lpString);
|
|
int GlobalAddAtomW(LPCTSTR lpString);
|
|
int GlobalAlloc(UINT uFlags,SIZE_T dwBytes);
|
|
int GlobalDeleteAtom(ATOM nAtom);
|
|
int GlobalFindAtom(LPCTSTR lpString);
|
|
int GlobalFindAtomA(LPCTSTR AtomName);
|
|
int GlobalFindAtomW(LPCTSTR AtomName);
|
|
int GlobalFlags(HGLOBAL hMem);
|
|
int GlobalFree(HGLOBAL hMem);
|
|
int GlobalGetAtomName(ATOM nAtom,LPTSTR lpBuffer,int nSize);
|
|
int GlobalGetAtomNameA(ATOM nAtom,LPTSTR lpBuffer,int nBufferSize);
|
|
int GlobalGetAtomNameW(ATOM nAtom,LPTSTR lpBuffer,int nBufferSize);
|
|
int GlobalHandle(LPCVOID hMem);
|
|
int GlobalLock(HGLOBAL hMem);
|
|
int GlobalMemoryStatus(LPMEMORYSTATUS lpMemBuffer);
|
|
int GlobalMemoryStatusEx(LPMEMORYSTATUSEX lpBuffer);
|
|
int GlobalReAlloc(HGLOBAL hMem,SIZE_T dwBytes,UINT uFlags);
|
|
int GlobalSize(HGLOBAL hMem);
|
|
int GlobalUnlock(HGLOBAL hMem);
|
|
int Heap32First(LPHEAPENTRY32 lphe,DWORD th32ProcessID,ULONG_PTR th32HeapID);
|
|
int Heap32ListFirst(HANDLE hSnapshot,LPHEAPLIST32 lphl);
|
|
int Heap32ListNext(HANDLE hSnapshot,LPHEAPLIST32 lphl);
|
|
int Heap32Next(LPHEAPENTRY32 lphe);
|
|
int HeapAlloc(HANDLE hHeap,DWORD Flags,SIZE_T HeapSize);
|
|
int HeapCompact(HANDLE hHeap,DWORD dwFlags);
|
|
int HeapCreate(DWORD flOptions,SIZE_T dwInitialSize,SIZE_T dwMaximumSize);
|
|
int HeapDestroy(HANDLE hHeap);
|
|
int HeapFree(HANDLE hHeap);
|
|
int HeapLock(HANDLE hHeap);
|
|
int HeapQueryInformation(HANDLE HeapHandle,HEAP_INFORMATION_CLASS HeapInformationClass,PVOID HeapInformation,SIZE_T HeapInformationLength,PSIZE_T ReturnLength);
|
|
int HeapReAlloc(HANDLE hHeap,DWORD Flags,LPVOID pMemory,SIZE_T NewSize);
|
|
int HeapSetInformation(HANDLE HeapHandle,HEAP_INFORMATION_CLASS HeapInformationClass,PVOID HeapInformation,SIZE_T HeapInformationLength);
|
|
int HeapSize(HANDLE hHeap,DWORD dwFlags,LPCVOID lpMem);
|
|
int HeapUnlock(HANDLE hHeap);
|
|
int HeapValidate(HANDLE hHeap,DWORD dwFlags,LPCVOID lpMem);
|
|
int HeapWalk(HANDLE hHeap,LPPROCESS_HEAP_ENTRY lpEntry);
|
|
int InitAtomTable(DWORD nSize);
|
|
int InitOnceBeginInitialize(LPINIT_ONCE lpInitOnce,DWORD dwFlags,PBOOL fPending,LPVOID* lpContext);
|
|
int InitOnceComplete(LPINIT_ONCE lpInitOnce,DWORD dwFlags,LPVOID lpContext);
|
|
int InitOnceExecuteOnce(PINIT_ONCE InitOnce,PINIT_ONCE_FN InitFn,PVOID Parameter,LPVOID* Context);
|
|
int InitOnceInitialize(PINIT_ONCE InitOnce);
|
|
int InitializeConditionVariable(PCONDITION_VARIABLE ConditionVariable);
|
|
int InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
|
|
int InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION lpCriticalSection);
|
|
int InitializeCriticalSectionEx(LPCRITICAL_SECTION lpCriticalSection,DWORD dwSpinCount,DWORD Flags);
|
|
int InitializeExtendedContext(PVOID Context,DWORD ContextFlags,PCONTEXT_EX* ContextEx);
|
|
int InitializeProcThreadAttributeList(LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList,DWORD dwAttributeCount,DWORD dwFlags,PSIZE_T lpSize);
|
|
int InitializeProcessForWsWatch(HANDLE hProcess);
|
|
int InitializeSListHead(PSLIST_HEADER ListHead);
|
|
int InitializeSRWLock(PSRWLOCK SRWLock);
|
|
int InterlockedCompareExchange(LONG volatile* Destination,LONG Exchange,LONG Comperand);
|
|
int InterlockedCompareExchange64(LONGLONG volatile* Destination,LONGLONG Exchange,LONGLONG Comparand);
|
|
int InterlockedDecrement(LONG volatile* lpAddend);
|
|
int InterlockedExchange(DWORD Target,DWORD Value);
|
|
int InterlockedExchange(LONG volatile* Target,LONG Value);
|
|
int InterlockedExchangeAdd(LONG volatile* Addend,LONG Increment);
|
|
int InterlockedFlushSList(PSLIST_HEADER ListHead);
|
|
int InterlockedIncrement(LONG volatile* lpAddend);
|
|
int InterlockedPopEntrySList(PSLIST_HEADER ListHead);
|
|
int InterlockedPushEntrySList(PSLIST_HEADER ListHead,PSLIST_ENTRY ListEntry);
|
|
int IsBadCodePtr(FARPROC lpfn);
|
|
int IsBadReadPtr(const VOID* lp,UINT_PTR ucb);
|
|
int IsBadStringPtr(LPCTSTR lpsz,UINT_PTR ucchMax);
|
|
int IsBadStringPtrA(LPCTSTR lpsz,UINT_PTR ucchMax);
|
|
int IsBadStringPtrW(LPCTSTR lpsz,UINT_PTR ucchMax);
|
|
int IsBadWritePtr(LPVOID lp,UINT_PTR ucb);
|
|
int IsCalendarLeapYear(CALID calId,UINT year,UINT era);
|
|
int IsDBCSLeadByte(BYTE TestChar);
|
|
int IsDBCSLeadByteEx(UINT CodePage,BYTE TestChar);
|
|
int IsDebuggerPresent();
|
|
int IsNLSDefinedString(NLS_FUNCTION Function,DWORD dwFlags,LPNLSVERSIONINFO lpVersionInformation,LPCWSTR lpString,INT cchStr);
|
|
int IsProcessInJob(HANDLE ProcessHandle,HANDLE JobHandle,PBOOL Result);
|
|
int IsProcessorFeaturePresent(DWORD ProcessorFeature);
|
|
int IsSystemResumeAutomatic();
|
|
int IsThreadAFiber();
|
|
int IsThreadpoolTimerSet(PTP_TIMER pti);
|
|
int IsValidCodePage(UINT CodePage);
|
|
int IsValidLanguageGroup(LGRPID LanguageGroup,DWORD dwFlags);
|
|
int IsValidLocale(LCID Locale,DWORD dwFlags);
|
|
int IsValidLocaleName(LPCWSTR lpLocaleName);
|
|
int IsWow64Process(HANDLE hProcess,PBOOL Wow64Process);
|
|
int LCIDToLocaleName(LCID Locale,LPWSTR lpName,int cchName,DWORD dwFlags);
|
|
int LCMapString(LCID Locale,DWORD dwMapFlags,LPCTSTR lpSrcStr,int cchSrc,LPTSTR lpDestStr,int cchDest);
|
|
int LCMapStringA(LCID Locale,DWORD dwCmpFlags,LPCTSTR lpString1,int cchCount1,LPTSTR lpString2,int cchCount2);
|
|
int LCMapStringEx(LPCWSTR lpLocaleName,DWORD dwMapFlags,LPCWSTR lpSrcStr,int cchSrc,LPWSTR lpDestStr,int cchDest,LPNLSVERSIONINFO lpVersionInformation,LPVOID lpReserved,LPARAM lParam);
|
|
int LCMapStringW(LCID Locale,DWORD dwMapFlags,LPCTSTR lpSrcStr,int cchSrc,LPTSTR lpDestStr,int cchDest);
|
|
int LeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
|
|
int LeaveCriticalSectionWhenCallbackReturns(PTP_CALLBACK_INSTANCE pci,PCRITICAL_SECTION pcs);
|
|
int LoadLibrary(LPCTSTR lpFileName);
|
|
int LoadLibraryA(LPCTSTR lpLibFileName);
|
|
int LoadLibraryEx(LPCTSTR lpFileName,HANDLE hFile,DWORD dwFlags);
|
|
int LoadLibraryExA(LPCTSTR pLibFileName,HANDLE hFile,DWORD dwFlags);
|
|
int LoadLibraryExW(LPCTSTR pLibFileName,HANDLE hFile,DWORD dwFlags);
|
|
int LoadLibraryW(LPCTSTR lpLibFileName);
|
|
int LoadModule(LPCSTR lpModuleName,LPVOID lpParameterBlock);
|
|
int LoadResource(HMODULE hModule,HRSRC hResInfo);
|
|
HLOCAL LocalAlloc(UINT uFlags,SIZE_T uBytes);
|
|
int LocalFileTimeToFileTime(const FILETIME* lpLocalFileTime,LPFILETIME lpFileTime);
|
|
int LocalFlags(HLOCAL hMem);
|
|
int LocalFree(HLOCAL hMem);
|
|
int LocalHandle(LPCVOID pMem);
|
|
int LocalLock(HLOCAL hMem);
|
|
HLOCAL LocalReAlloc(HLOCAL hMem, SIZE_T uBytes, UINT uFlags);
|
|
int LocalSize(HLOCAL hMem);
|
|
int LocalUnlock(HLOCAL hMem);
|
|
int LocaleNameToLCID(LPCWSTR lpName,DWORD dwFlags);
|
|
int LocateExtendedFeature(PCONTEXT_EX ContextEx,DWORD FeatureId,PDWORD Length);
|
|
int LocateLegacyContext(PCONTEXT_EX ContextEx,PDWORD Length);
|
|
int LockFile(HANDLE hFile,DWORD dwFileOffsetLow,DWORD dwFileOffsetHigh,DWORD nNumberOfBytesToLockLow,DWORD nNumberOfBytesToLockHigh);
|
|
int LockFileEx(HANDLE hFile,DWORD dwFlags,DWORD dwReserved,DWORD nNumberOfBytesToLockLow,DWORD nNumberOfBytesToLockHigh,LPOVERLAPPED lpOverlapped);
|
|
int LockResource(HGLOBAL hResInfo);
|
|
int MapUserPhysicalPages(PVOID lpAddress,ULONG_PTR NumberOfPages,PULONG_PTR UserPfnArray);
|
|
int MapUserPhysicalPagesScatter(PVOID* VirtualAddresses,ULONG_PTR NumberOfPages,PULONG_PTR PageArray);
|
|
int MapViewOfFile(HANDLE hFileMappingObject,DWORD dwDesiredAccess,DWORD dwFileOffsetHigh,DWORD dwFileOffsetLow,SIZE_T dwNumberOfBytesToMap);
|
|
int MapViewOfFileEx(HANDLE hFileMappingObject,DWORD dwDesiredAccess,DWORD dwFileOffsetHigh,DWORD dwFileOffsetLow,SIZE_T dwNumberOfBytesToMap,LPVOID lpBaseAddress);
|
|
int MapViewOfFileExNuma(HANDLE hFileMappingObject,DWORD dwDesiredAccess,DWORD dwFileOffsetHigh,DWORD dwFileOffsetLow,SIZE_T dwNumberOfBytesToMap,LPVOID lpBaseAddress,DWORD nndPreferred);
|
|
int Module32First(HANDLE hModuleSnap,LPMODULEENTRY32 lpme);
|
|
int Module32FirstW(HANDLE hSnapshot,LPMODULEENTRY32 lpme);
|
|
int Module32Next(HANDLE hModuleSnap,LPMODULEENTRY32 lpme);
|
|
int Module32NextW(HANDLE hSnapshot,LPMODULEENTRY32 lpme);
|
|
int MoveFile(LPCTSTR lpExistingFileName,LPCTSTR lpNewFileName);
|
|
int MoveFileA(LPCTSTR lpExistingFileName,LPCTSTR lpNewFileName);
|
|
int MoveFileEx(LPCTSTR lpExistingFileName,LPCTSTR lpNewFileName,DWORD dwFlags);
|
|
int MoveFileTransacted(LPCTSTR lpExistingFileName,LPCTSTR lpNewFileName,LPPROGRESS_ROUTINE lpProgressRoutine,LPVOID lpData,DWORD dwFlags,HANDLE hTransaction);
|
|
int MoveFileW(LPCTSTR lpExistingFileName,LPCTSTR lpNewFileName);
|
|
int MoveFileWithProgress(LPCTSTR lpExistingFileName,LPCTSTR lpNewFileName,LPPROGRESS_ROUTINE lpProgressRoutine,LPVOID lpData,DWORD dwFlags);
|
|
int MultiByteToWideChar(UINT CodePage,DWORD dwFlags,LPCSTR lpMultiByteStr,int cchMultiByte,LPWSTR lpwcBuffer,int nBuffer);
|
|
int NeedCurrentDirectoryForExePath(LPCTSTR ExeName);
|
|
int OpenEvent(DWORD dwDesiredAccess,BOOL bInheritHandle,LPCTSTR lpName);
|
|
int OpenEventA(DWORD dwDesiredAccess,BOOL bInheritHandle,LPCTSTR lpName);
|
|
int OpenEventW(DWORD dwDesiredAccess,BOOL bInheritHandle,LPCTSTR lpName);
|
|
int OpenFile(LPCSTR lpFileName,LPOFSTRUCT lpReOpenBuff,DWORD uStyle);
|
|
int OpenFileById(HANDLE hFile,LPFILE_ID_DESCRIPTOR lpFileID,DWORD dwDesiredAccess,DWORD dwShareMode,LPSECURITY_ATTRIBUTES lpSecurityAttributes,DWORD dwFlags);
|
|
int OpenFileMapping(DWORD dwDesiredAccess,BOOL bInheritHandle,LPCTSTR lpName);
|
|
int OpenFileMappingA(DWORD dwDesiredAccess,BOOL bInheritHandle,LPCTSTR lpName);
|
|
int OpenFileMappingW(DWORD dwDesiredAccess,BOOL bInheritHandle,LPCTSTR lpName);
|
|
int OpenJobObject(DWORD dwDesiredAccess,BOOL bInheritHandles,LPCTSTR lpName);
|
|
int OpenMutex(DWORD dwDesiredAccess,BOOL bInheritHandle,LPCTSTR lpName);
|
|
int OpenMutexA(DWORD dwDesiredAccess,BOOL bInheritHandle,LPCTSTR lpName);
|
|
int OpenMutexW(DWORD dwDesiredAccess,BOOL bInheritHandle,LPCTSTR lpName);
|
|
int OpenPrivateNamespace(LPVOID lpBoundaryDescriptor,LPCTSTR lpAliasPrefix);
|
|
int OpenProcess(DWORD dwDesiredAccess,BOOL bInheritHandle,DWORD dwProcessId);
|
|
int OpenSemaphore(DWORD dwDesiredAccess,BOOL bInheritHandle,LPCTSTR lpName);
|
|
int OpenThread(DWORD dwDesiredAccess,BOOL bInheritHandle,DWORD dwThreadId);
|
|
int OpenWaitableTimer(DWORD dwDesiredAccess,BOOL bInheritHandle,LPCTSTR lpTimerName);
|
|
int OutputDebugString(LPCTSTR lpOutputString);
|
|
int OutputDebugStringA(LPCTSTR lpOutputString);
|
|
int OutputDebugStringW(LPCTSTR lpOutputString);
|
|
int PeekConsoleInput(HANDLE hConsoleInput,PINPUT_RECORD lpBuffer,DWORD nLength,LPDWORD lpNumberOfEventsRead);
|
|
int PostQueuedCompletionStatus(HANDLE CompletionPort,DWORD dwNumberOfBytesTransferred,ULONG_PTR dwCompletionKey,LPOVERLAPPED lpOverlapped);
|
|
int PowerClearRequest(HANDLE PowerRequest,POWER_REQUEST_TYPE RequestType);
|
|
int PowerCreateRequest(PREASON_CONTEXT Context);
|
|
int PowerSetRequest(HANDLE PowerRequest,POWER_REQUEST_TYPE RequestType);
|
|
int PrepareTape(HANDLE hDevice,DWORD dwOperation,BOOL bImmediate);
|
|
int Process32First(HANDLE hSnapshot,LPPROCESSENTRY32 lppe);
|
|
int Process32FirstW(HANDLE hSnapshot,LPPROCESSENTRY32 lppe);
|
|
int Process32Next(HANDLE hSnapshot,LPPROCESSENTRY32 lppe);
|
|
int Process32NextW(HANDLE hSnapshot,LPPROCESSENTRY32 lppe);
|
|
int ProcessIdToSessionId(DWORD dwProcessId,DWORD* pSessionId);
|
|
int PulseEvent(HANDLE hEvent);
|
|
int PurgeComm(HANDLE hFile,DWORD dwFlags);
|
|
int QueryActCtxSettingsW(DWORD dwFlags,HANDLE hActCtx,PCWSTR settingsNameSpace,PCWSTR settingName,PWSTR pvBuffer,SIZE_T dwBuffer,SIZE_T* pdwWrittenOrRequired);
|
|
int QueryActCtxW(DWORD dwFlags,HANDLE hActCtx,PVOID pvSubInstance,UINT ulInfoClass,PVOID pvBuffer,SIZE_T cbBuffer,SIZE_T* pcbWrittenOrRequired);
|
|
int QueryDepthSList(PSLIST_HEADER ListHead);
|
|
int QueryFullProcessImageName(HANDLE hProcess,DWORD dwFlags,LPTSTR lpExeName,PDWORD lpdwSize);
|
|
int QueryIdleProcessorCycleTime(PULONG BufferLength,PULONG64 ProcessorIdleCycleTime);
|
|
int QueryIdleProcessorCycleTimeEx(USHORT Group,PULONG BufferLength,PULONG64 ProcessorIdleCycleTime);
|
|
int QueryInformationJobObject(HANDLE hJob,JOBOBJECTINFOCLASS JobObjectInfoClass,LPVOID lpJobObjectInfo,DWORD cbJobObjectInfoLength,LPDWORD lpReturnLength);
|
|
int QueryMemoryResourceNotification(HANDLE ResourceNotificationHandle,PBOOL ResourceState);
|
|
int QueryPerformanceCounter(LARGE_INTEGER* lpPerformanceCount);
|
|
int QueryPerformanceFrequency(LARGE_INTEGER* lpFrequency);
|
|
int QueryProcessAffinityUpdateMode(HANDLE ProcessHandle,DWORD lpdwFlags);
|
|
int QueryProcessCycleTime(HANDLE ProcessHandle,PULONG64 CycleTime);
|
|
int QueryThreadCycleTime(HANDLE ThreadHandle,PULONG64 CycleTime);
|
|
int QueryThreadpoolStackInformation(PTP_POOL ptpp,PTP_POOL_STACK_INFORMATION ptpsi);
|
|
int QueryUmsThreadInformation(PUMS_CONTEXT UmsThread,UMS_THREAD_INFO_CLASS UmsThreadInfoClass,PVOID UmsThreadInformation,ULONG UmsThreadInformationLength,PULONG ReturnLength);
|
|
int QueryUnbiasedInterruptTime(PULONGLONG UnbiasedTime);
|
|
int QueryWorkingSet(HANDLE hProcess,PVOID pv,DWORD cb);
|
|
int QueryWorkingSetEx(HANDLE hProcess,PVOID pv,DWORD cb);
|
|
int QueueUserAPC(PAPCFUNC pfnAPC,HANDLE hThread,ULONG_PTR dwData);
|
|
int QueueUserWorkItem(LPTHREAD_START_ROUTINE Function,PVOID Context,DWORD Flags);
|
|
int RaiseException(DWORD dwExceptionCode,DWORD dwExceptionFlags,DWORD nNumberOfArguments,const ULONG_PTR* lpArguments);
|
|
int RaiseFailFastException(PEXCEPTION_RECORD pExceptionRecord,PCONTEXT pContextRecord,DWORD dwFlags);
|
|
int ReOpenFile(HANDLE hOriginalFile,DWORD dwDesiredAccess,DWORD dwShareMode,DWORD dwFlags);
|
|
int ReadConsole(HANDLE hConsoleInput,LPVOID lpBuffer,DWORD nNumberOfCharsToRead,LPDWORD lpNumberOfCharsRead,LPVOID pInputControl);
|
|
int ReadConsoleInput(HANDLE hConsoleInput,PINPUT_RECORD lpBuffer,DWORD nLength,LPDWORD lpNumberOfEventsRead);
|
|
int ReadConsoleInputA(HANDLE hConsoleInput,PINPUT_RECORD lpInputRecord,DWORD nLength,LPDWORD lpNumberOfEventsRead);
|
|
int ReadConsoleOutput(HANDLE hConsoleOutput,PCHAR_INFO lpBuffer,COORD dwBufferSize,COORD dwBufferCoord,PSMALL_RECT lpReadRegion);
|
|
int ReadConsoleOutputAttribute(HANDLE hConsoleOutput,LPWORD lpAttribute,DWORD nLength,COORD dwReadCoord,LPDWORD lpNumberOfAttrsRead);
|
|
int ReadConsoleOutputCharacter(HANDLE hConsoleOutput,LPTSTR lpCharacter,DWORD nLength,COORD dwReadCoord,LPDWORD lpNumberOfCharsRead);
|
|
int ReadDirectoryChangesW(HANDLE hDirectory,LPVOID lpBuffer,DWORD nBufferLength,BOOL bWatchSubtree,DWORD dwNotifyFilter,LPDWORD lpBytesReturned,LPOVERLAPPED lpOverlapped,LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
|
|
bool ReadFile(HANDLE hFile,LPVOID lpBuffer,DWORD nNumberOfBytesToRead,LPDWORD lpNumberOfBytesRead,LPOVERLAPPED lpOverlapped);
|
|
int ReadFileEx(HANDLE hFile,LPVOID lpBuffer,DWORD nNumberOfBytesToRead,LPOVERLAPPED lpOverlapped,LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
|
|
int ReadFileScatter(HANDLE hFile,FILE_SEGMENT_ELEMENT aSegmentArray,DWORD nNumberOfBytesToRead,LPDWORD lpReserved,LPOVERLAPPED lpOverlapped);
|
|
int ReadProcessMemory(HANDLE hProcess,LPCVOID lpBaseAddress,LPVOID lpStockBuffer,SIZE_T nSize,SIZE_T* lpNumberOfBytesRead);
|
|
int RegisterApplicationRecoveryCallback(APPLICATION_RECOVERY_CALLBACK pRecoveryCallback,PVOID pvParameter,DWORD dwPingInterval,DWORD dwFlags);
|
|
int RegisterApplicationRestart(PCWSTR pwzCommandline,DWORD dwFlags);
|
|
int RegisterWaitForSingleObject(PHANDLE phNewWaitObject,HANDLE hObject,WAITORTIMERCALLBACK Callback,PVOID Context,DWORD dwMilliseconds,DWORD dwFlags);
|
|
int ReleaseActCtx(HANDLE hActCtx);
|
|
int ReleaseMutex(HANDLE hMutex);
|
|
int ReleaseMutexWhenCallbackReturns(PTP_CALLBACK_INSTANCE pci,HANDLE mut);
|
|
int ReleaseSRWLockExclusive(PSRWLOCK SRWLock);
|
|
int ReleaseSRWLockShared(PSRWLOCK SRWLock);
|
|
int ReleaseSemaphore(HANDLE hSemaphore,LONG lReleaseCount,LPLONG lpPreviousCount);
|
|
int ReleaseSemaphoreWhenCallbackReturns(PTP_CALLBACK_INSTANCE pci,HANDLE sem,DWORD crel);
|
|
int RemoveDirectory(LPCTSTR lpPathName);
|
|
int RemoveDirectoryA(LPCTSTR lpPathName);
|
|
int RemoveDirectoryTransacted(LPCTSTR lpPathName,HANDLE hTransaction);
|
|
int RemoveDirectoryW(LPCTSTR lpPathName);
|
|
int RemoveSecureMemoryCacheCallback(PSECURE_MEMORY_CACHE_CALLBACK pfnCallBack);
|
|
int RemoveVectoredContinueHandler(PVOID Handler);
|
|
int RemoveVectoredExceptionHandler(PVOID Handler);
|
|
int ReplaceFile(LPCTSTR lpReplacedFileName,LPCTSTR lpReplacementFileName,LPCTSTR lpBackupFileName,DWORD dwReplaceFlags,LPVOID lpExclude,LPVOID lpReserved);
|
|
int RequestWakeupLatency(LATENCY_TIME latency);
|
|
int ResetEvent(HANDLE hEvent);
|
|
int ResetWriteWatch(LPVOID lpBaseAddress,SIZE_T dwRegionSize);
|
|
int ResolveLocaleName(LPCWSTR lpNameToResolve,LPWSTR lpLocaleName,int cchLocaleName);
|
|
int ResumeThread(HANDLE hThread);
|
|
int RtlAddFunctionTable(PRUNTIME_FUNCTION FunctionTable,DWORD EntryCount,DWORD64 BaseAddress,ULONGLONG TargetGp);
|
|
int RtlCaptureContext(PCONTEXT ContextRecord);
|
|
int RtlCaptureStackBackTrace(ULONG FramesToSkip,ULONG FramesToCapture,PVOID* BackTrace,PULONG BackTraceHash);
|
|
int RtlDeleteFunctionTable(PRUNTIME_FUNCTION FunctionTable);
|
|
int RtlInstallFunctionTableCallback(DWORD64 TableIdentifier,DWORD64 BaseAddress,DWORD Length,PGET_RUNTIME_FUNCTION_CALLBACK Callback,PVOID Context,PCWSTR OutOfProcessCallbackDll);
|
|
int RtlIsValidLocaleName(LPCWSTR LocaleName,ULONG Flags);
|
|
int RtlLookupFunctionEntry(ULONGLONG ControlPC,PULONGLONG ImageBase,PULONGLONG TargetGp);
|
|
int RtlPcToFileHeader(PVOID PcValue,PVOID* BaseOfImage);
|
|
int RtlRestoreContext(PCONTEXT ContextRecord,PEXCEPTION_RECORD ExceptionRecord);
|
|
int ScrollConsoleScreenBuffer(HANDLE hConsoleOutput,const SMALL_RECT* lpScrollRectangle,const SMALL_RECT* lpClipRectangle,COORD dwDestinationOrigin,const CHAR_INFO* lpFill);
|
|
int ScrollConsoleScreenBufferA(HANDLE hConsoleOutput,const SMALL_RECT* lpScrollRectangle,const SMALL_RECT* lpClipRectangle,COORD dwDestinationOrigin,const CHAR_INFO* lpFill);
|
|
int SearchPath(LPCTSTR lpPath,LPCTSTR lpFileName,LPCTSTR lpExtension,DWORD nBufferLength,LPTSTR lpBuffer,LPTSTR* lpFilePart);
|
|
int SearchPathA(LPCTSTR lpPath,LPCTSTR lpFileName,LPCTSTR lpExtension,DWORD nBufferSize,LPTSTR lpStockBuffer,LPTSTR* lpFilePart);
|
|
int SearchPathW(LPCTSTR lpPath,LPCTSTR lpFileName,LPCTSTR lpExtension,DWORD nBufferSize,LPTSTR lpStockBuffer,LPTSTR* lpFilePart);
|
|
int SetCalendarInfo(LCID Locale,CALID Calendar,CALTYPE CalType,LPCTSTR lpCalData);
|
|
int SetCommBreak(HANDLE hFile);
|
|
int SetCommConfig(HANDLE hCommDev,LPCOMMCONFIG lpCC,DWORD dwSize);
|
|
int SetCommMask(HANDLE hFile,DWORD dwEvtMask);
|
|
int SetCommState(HANDLE hFile,LPDCB lpDCB);
|
|
int SetCommTimeouts(HANDLE hFile,LPCOMMTIMEOUTS lpCommTimeouts);
|
|
int SetComputerName(LPCTSTR lpComputerName);
|
|
int SetComputerNameA(LPCTSTR lpComputerName);
|
|
int SetComputerNameEx(COMPUTER_NAME_FORMAT NameType,LPCTSTR lpBuffer);
|
|
int SetComputerNameW(LPCTSTR lpComputerName);
|
|
int SetConsoleActiveScreenBuffer(HANDLE hConsoleOutput);
|
|
int SetConsoleCP(UINT wCodePageID);
|
|
int SetConsoleCtrlHandler(PHANDLER_ROUTINE hRoutine,BOOL Add);
|
|
int SetConsoleCursorInfo(HANDLE hConsoleOutput,const CONSOLE_CURSOR_INFO* lpConsoleCursorInfo);
|
|
int SetConsoleCursorPosition(HANDLE hConsoleOutput,COORD dwCursorPosition);
|
|
int SetConsoleDisplayMode(HANDLE hConsoleOutput,DWORD dwFlags,PCOORD lpNewScreenBufferDimensions);
|
|
int SetConsoleHistoryInfo(PCONSOLE_HISTORY_INFO lpConsoleHistoryInfo);
|
|
int SetConsoleMode(HANDLE hConsoleHandle,DWORD dwMode);
|
|
int SetConsoleOutputCP(UINT wCodePageID);
|
|
int SetConsoleScreenBufferInfoEx(HANDLE hConsoleOutput,PCONSOLE_SCREEN_BUFFER_INFOEX lpConsoleScreenBufferInfoEx);
|
|
int SetConsoleScreenBufferSize(HANDLE hConsoleOutput,COORD dwSize);
|
|
int SetConsoleTextAttribute(HANDLE hConsoleOutput,WORD wAttributes);
|
|
int SetConsoleTitle(LPCTSTR lpConsoleTitle);
|
|
int SetConsoleTitleA(LPCTSTR pConsoleTitle);
|
|
int SetConsoleTitleW(LPCTSTR pConsoleTitle);
|
|
int SetConsoleWindowInfo(HANDLE hConsoleOutput,BOOL bAbsolute,const SMALL_RECT* lpConsoleWindow);
|
|
int SetCriticalSectionSpinCount(LPCRITICAL_SECTION lpCriticalSection,DWORD dwSpinCount);
|
|
int SetCurrentConsoleFontEx(HANDLE hConsoleOutput,BOOL bMaximumWindow,PCONSOLE_FONT_INFOEX lpConsoleCurrentFontEx);
|
|
int SetCurrentDirectory(LPCTSTR lpPathName);
|
|
int SetCurrentDirectoryA(LPCTSTR lpPathName);
|
|
int SetCurrentDirectoryW(LPCTSTR lpPathName);
|
|
int SetDefaultCommConfig(LPCTSTR lpszName,LPCOMMCONFIG lpCC,DWORD dwSize);
|
|
int SetDllDirectory(LPCTSTR lpPathName);
|
|
int SetDynamicTimeZoneInformation(const DYNAMIC_TIME_ZONE_INFORMATION* lpTimeZoneInformation);
|
|
int SetEndOfFile(HANDLE hFile);
|
|
int SetEnvironmentVariable(LPCTSTR lpName,LPCTSTR lpValue);
|
|
int SetEnvironmentVariableA(LPCTSTR lpName,LPCTSTR lpValue);
|
|
int SetEnvironmentVariableW(LPCTSTR lpName,LPCTSTR lpValue);
|
|
int SetErrorMode(DWORD uMode);
|
|
int SetEvent(HANDLE hEvent);
|
|
int SetEventWhenCallbackReturns(PTP_CALLBACK_INSTANCE pci,HANDLE evt);
|
|
int SetExtendedFeaturesMask(PCONTEXT_EX ContextEx,DWORD64 FeatureMask);
|
|
int SetFileApisToANSI();
|
|
int SetFileApisToOEM();
|
|
int SetFileAttributes(LPCTSTR lpFileName,DWORD dwFileAttributes);
|
|
int SetFileAttributesA(LPCTSTR lpFileName,DWORD dwFileAttributes);
|
|
int SetFileAttributesTransacted(LPCTSTR lpFileName,DWORD dwFileAttributes,HANDLE hTransaction);
|
|
int SetFileAttributesW(LPCTSTR lpFileName,DWORD dwFileAttributes);
|
|
int SetFileBandwidthReservation(HANDLE hFile,DWORD nPeriodMilliseconds,DWORD nBytesPerPeriod,BOOL bDiscardable,LPDWORD lpTransferSize,LPDWORD lpNumOutstandingRequests);
|
|
int SetFileCompletionNotificationModes(HANDLE FileHandle,UCHAR Flags);
|
|
int SetFileInformationByHandle(HANDLE hFile,FILE_INFO_BY_HANDLE_CLASS FileInformationClass,LPVOID lpFileInformation,DWORD dwBufferSize);
|
|
int SetFileIoOverlappedRange(HANDLE FileHandle,PUCHAR OverlappedRangeStart,ULONG Length);
|
|
int SetFilePointer(HANDLE hFile,LONG lDistanceToMove,PLONG lpDistanceToMoveHigh,DWORD dwMoveMethod);
|
|
int SetFilePointerEx(HANDLE hFile,LARGE_INTEGER lDistanceToMove,PLARGE_INTEGER pliNewFilePointer,DWORD dwMoveMethod);
|
|
int SetFileShortName(HANDLE hFile,LPCTSTR lpShortName);
|
|
int SetFileTime(HANDLE hFile,const FILETIME* lpCreationTime,const FILETIME* lpLastAccessTime,const FILETIME* lpLastWriteTime);
|
|
int SetFileValidData(HANDLE hFile,LONGLONG ValidDataLength);
|
|
int SetFirmwareEnvironmentVariable(LPCTSTR lpName,LPCTSTR lpGuid,PVOID pBuffer,DWORD nSize);
|
|
int SetHandleInformation(HANDLE hObject,DWORD dwMask,DWORD dwFlags);
|
|
int SetInformationJobObject(HANDLE hJob,JOBOBJECTINFOCLASS JobObjectInfoClass,LPVOID lpJobObjectInfo,DWORD cbJobObjectInfoLength);
|
|
int SetLastError(DWORD dwErrCode);
|
|
int SetLocalTime(const SYSTEMTIME* lpSystemTime);
|
|
int SetLocaleInfo(LCID Locale,LCTYPE LCType,LPCTSTR lpLCData);
|
|
int SetLocaleInfoA(LCID Locale,LCTYPE LCType,LPCTSTR lpLCData);
|
|
int SetLocaleInfoW(LCID Locale,LCTYPE LCType,LPCTSTR lpLCData);
|
|
int SetMailslotInfo(HANDLE hMailslot,DWORD lReadTimeout);
|
|
int SetPriorityClass(HANDLE hProcess,DWORD dwPriorityClass);
|
|
int SetProcessAffinityMask(HANDLE hProcess,DWORD_PTR dwProcessAffinityMask);
|
|
int SetProcessAffinityUpdateMode(HANDLE ProcessHandle,DWORD dwFlags);
|
|
int SetProcessDEPPolicy(DWORD dwFlags);
|
|
int SetProcessPriorityBoost(HANDLE hProcess,BOOL DisablePriorityBoost);
|
|
int SetProcessShutdownParameters(DWORD dwLevel,DWORD dwFlags);
|
|
int SetProcessWorkingSetSize(HANDLE hProcess,SIZE_T dwMinimumWorkingSetSize,SIZE_T dwMaximumWorkingSetSize);
|
|
int SetProcessWorkingSetSizeEx(HANDLE hProcess,SIZE_T dwMinimumWorkingSetSize,SIZE_T dwMaximumWorkingSetSize,DWORD Flags);
|
|
int SetSearchPathMode(DWORD Flags);
|
|
int SetStdHandle(DWORD nStdHandle,HANDLE hHandle);
|
|
int SetSystemFileCacheSize(SIZE_T MinimumFileCacheSize,SIZE_T MaximumFileCacheSize,DWORD Flags);
|
|
int SetSystemPowerState(BOOL fSuspend,BOOL fForce);
|
|
int SetSystemTime(const SYSTEMTIME* lpSystemTime);
|
|
int SetSystemTimeAdjustment(DWORD dwTimeAdjustment,BOOL bTimeAdjustmentDisabled);
|
|
int SetTapeParameters(HANDLE hDevice,DWORD dwOperation,LPVOID lpTapeInformation);
|
|
int SetTapePosition(HANDLE hDevice,DWORD dwPositionMethod,DWORD dwPartition,DWORD dwOffsetLow,DWORD dwOffsetHigh,BOOL bImmediate);
|
|
int SetThreadAffinityMask(HANDLE hThread,DWORD_PTR dwThreadAffinityMask);
|
|
int SetThreadContext(HANDLE hThread,const CONTEXT* lpContext);
|
|
int SetThreadErrorMode(DWORD dwNewMode,LPDWORD lpOldMode);
|
|
int SetThreadExecutionState(EXECUTION_STATE esFlags);
|
|
int SetThreadGroupAffinity(HANDLE hThread,const GROUP_AFFINITY* GroupAffinity);
|
|
int SetThreadIdealProcessor(HANDLE hThread,DWORD dwIdealProcessor);
|
|
int SetThreadIdealProcessorEx(HANDLE hThread,PPROCESSOR_NUMBER lpIdealProcessor,PPROCESSOR_NUMBER lpPreviousIdealProcessor);
|
|
int SetThreadLocale(LCID Locale);
|
|
int SetThreadPriority(HANDLE hThread,DWORD nPriority);
|
|
int SetThreadPriorityBoost(HANDLE hThread,BOOL DisablePriorityBoost);
|
|
int SetThreadStackGuarantee(PULONG StackSizeInBytes);
|
|
int SetThreadpoolCallbackPriority(PTP_CALLBACK_ENVIRON pcbe,TP_CALLBACK_PRIORITY Priority);
|
|
int SetThreadpoolStackInformation(PTP_POOL ptpp,PTP_POOL_STACK_INFORMATION ptpsi);
|
|
int SetThreadpoolThreadMaximum(PTP_POOL ptpp,DWORD cthrdMost);
|
|
int SetThreadpoolThreadMinimum(PTP_POOL ptpp,DWORD cthrdMic);
|
|
int SetThreadpoolTimer(PTP_TIMER pti,PFILETIME pftDueTime,DWORD msPeriod,DWORD msWindowLength);
|
|
int SetThreadpoolWait(PTP_WAIT pwa,HANDLE h,PFILETIME pftTimeout);
|
|
int SetTimeZoneInformation(const TIME_ZONE_INFORMATION* lpTimeZoneInformation);
|
|
int SetUmsThreadInformation(PUMS_CONTEXT UmsThread,UMS_THREAD_INFO_CLASS UmsThreadInfoClass,PVOID UmsThreadInformation,ULONG UmsThreadInformationLength);
|
|
int SetUnhandledExceptionFilter(LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter);
|
|
int SetUserGeoID(GEOID GeoId);
|
|
int SetWaitableTimer(HANDLE hTimer,const LARGE_INTEGER* pDueTime,LONG lPeriod,PTIMERAPCROUTINE pfnCompletionRoutine,LPVOID lpArgToCompletionRoutine,BOOL fResume);
|
|
int SetWaitableTimerEx(HANDLE hTimer,const LARGE_INTEGER* lpDueTime,LONG lPeriod,PTIMERAPCROUTINE pfnCompletionRoutine,LPVOID lpArgToCompletionRoutine,PREASON_CONTEXT WakeContext,ULONG TolerableDelay);
|
|
int SetupComm(HANDLE hFile,DWORD dwInQueue,DWORD dwOutQueue);
|
|
int SignalObjectAndWait(HANDLE hObjectToSignal,HANDLE hObjectToWaitOn,DWORD dwMilliseconds,BOOL bAlertable);
|
|
int SizeofResource(HMODULE hModule,HRSRC hResInfo);
|
|
void Sleep(DWORD dwMilliseconds);
|
|
int SleepConditionVariableCS(PCONDITION_VARIABLE ConditionVariable,PCRITICAL_SECTION CriticalSection,DWORD dwMilliseconds);
|
|
int SleepConditionVariableSRW(PCONDITION_VARIABLE ConditionVariable,PSRWLOCK SRWLock,DWORD dwMilliseconds,ULONG Flags);
|
|
int SleepEx(DWORD dwMilliseconds,BOOL bAlertable);
|
|
int StartThreadpoolIo(PTP_IO pio);
|
|
int SubmitThreadpoolWork(PTP_WORK pwk);
|
|
int SuspendThread(HANDLE hThread);
|
|
int SwitchToFiber(LPVOID lpFiber);
|
|
int SwitchToThread();
|
|
int SystemTimeToFileTime(const SYSTEMTIME* lpSystemTime,LPFILETIME lpFileTime);
|
|
int SystemTimeToTzSpecificLocalTime(LPTIME_ZONE_INFORMATION lpTimeZoneInformation,LPSYSTEMTIME lpUniversalTime,LPSYSTEMTIME lpLocalTime);
|
|
int TerminateJobObject(HANDLE hJob,UINT uExitCode);
|
|
int TerminateProcess(HANDLE hProcess,UINT uExitCode);
|
|
int TerminateThread(HANDLE hProcess,DWORD uExitCode);
|
|
int Thread32First(HANDLE hSnapshot,LPTHREADENTRY32 lpte);
|
|
int Thread32Next(HANDLE hSnapshot,LPTHREADENTRY32 lpte);
|
|
int TlsAlloc();
|
|
int TlsFree(DWORD dwTlsIndex );
|
|
int TlsGetValue(DWORD dwTlsIndex);
|
|
int TlsSetValue(DWORD dwTlsIndex,LPVOID pTlsValue);
|
|
int Toolhelp32ReadProcessMemory(DWORD th32ProcessID,LPCVOID lpBaseAddress,LPVOID lpBuffer,SIZE_T cbRead,SIZE_T lpNumberOfBytesRead);
|
|
int TransmitCommChar(HANDLE hFile,char cChar);
|
|
int TryAcquireSRWLockExclusive(PSRWLOCK SRWLock);
|
|
int TryAcquireSRWLockShared(PSRWLOCK SRWLock);
|
|
int TryEnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
|
|
int TrySubmitThreadpoolCallback(PTP_SIMPLE_CALLBACK pfns,PVOID pv,PTP_CALLBACK_ENVIRON pcbe);
|
|
int TzSpecificLocalTimeToSystemTime(LPTIME_ZONE_INFORMATION lpTimeZoneInformation,LPSYSTEMTIME lpLocalTime,LPSYSTEMTIME lpUniversalTime);
|
|
int UmsThreadYield(PVOID SchedulerParam);
|
|
int UnhandledExceptionFilter(struct _EXCEPTION_POINTERS* pExceptionInfo);
|
|
int UnlockFile(HANDLE hFile,DWORD dwFileOffsetLow,DWORD dwFileOffsetHigh,DWORD nNumberOfBytesToUnlockLow,DWORD nNumberOfBytesToUnlockHigh);
|
|
int UnlockFileEx(HANDLE hFile,DWORD dwReserved,DWORD nNumberOfBytesToUnlockLow,DWORD nNumberOfBytesToUnlockHigh,LPOVERLAPPED lpOverlapped);
|
|
int UnmapViewOfFile(LPCVOID lpBaseAddress);
|
|
int UnregisterApplicationRecoveryCallback();
|
|
int UnregisterApplicationRestart();
|
|
int UnregisterWait(HANDLE WaitHandle);
|
|
int UnregisterWaitEx(HANDLE WaitHandle,HANDLE CompletionEvent);
|
|
int UpdateCalendarDayOfWeek(LPCALDATETIME lpCalDateTime);
|
|
int UpdateProcThreadAttribute(LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList,DWORD dwFlags,DWORD Attribute,PVOID lpValue,SIZE_T cbSize,PVOID lpPreviousValue,PSIZE_T lpReturnSize);
|
|
int UpdateResource(HANDLE hUpdate,LPCTSTR lpType,LPCTSTR lpName,WORD wLanguage,LPVOID lpData,DWORD cbData);
|
|
int VerLanguageName(DWORD wLang,LPTSTR szLang,DWORD cchLang);
|
|
int VerLanguageNameA(DWORD wLang,LPTSTR szLang,DWORD nSize);
|
|
int VerLanguageNameW(DWORD wLang,LPTSTR szLang,DWORD nSize);
|
|
int VerSetConditionMask(ULONGLONG dwlConditionMask,DWORD dwTypeBitMask,DWORD dwConditionMask);
|
|
int VerifyScripts(DWORD dwFlags,LPCWSTR lpLocaleScripts,int cchLocaleScripts,LPCWSTR lpTestScripts,int cchTestScripts);
|
|
int VerifyVersionInfo(LPOSVERSIONINFOEX lpVersionInfo,DWORD dwTypeMask,DWORDLONG dwlConditionMask);
|
|
int VirtualAlloc(LPVOID lpAddress,SIZE_T dwSize,DWORD flAllocationType,DWORD flProtect);
|
|
int VirtualAllocEx(HANDLE hProcess,LPVOID lpAddress,SIZE_T dwSize,DWORD flAllocationType,DWORD flProtect);
|
|
int VirtualAllocExNuma(HANDLE hProcess,LPVOID lpAddress,SIZE_T dwSize,DWORD flAllocationType,DWORD flProtect,DWORD nndPreferred);
|
|
int VirtualFree(LPVOID lpAddress,SIZE_T dwSize,DWORD FreeType);
|
|
int VirtualFreeEx(HANDLE hProces,LPVOID lpAddress,SIZE_T dwSize,DWORD dwFreeType);
|
|
int VirtualLock(LPVOID lpAddress,SIZE_T dwSize);
|
|
int VirtualProtect(LPVOID lpAddress,SIZE_T dwSize,DWORD flNewProtect,DWORD lpflOldProtect);
|
|
int VirtualProtectEx(HANDLE hProces,LPVOID lpAddress,SIZE_T dwSize,DWORD flNewProtect,DWORD lpflOldProtect);
|
|
int VirtualQuery(LPCVOID lpAddress,PMEMORY_BASIC_INFORMATION pbi_Buffer,SIZE_T dwLength);
|
|
int VirtualQueryEx(HANDLE hProcess,LPCVOID lpAddress,PMEMORY_BASIC_INFORMATION pbi_Buffer,SIZE_T dwLength);
|
|
int VirtualUnlock(LPVOID lpAddress,SIZE_T dwSize);
|
|
int WTSGetActiveConsoleSessionId();
|
|
int WaitCommEvent(HANDLE hFile,LPDWORD lpEvtMask,LPOVERLAPPED lpOverlapped);
|
|
int WaitForDebugEvent(LPDEBUG_EVENT lpDebugEvent,DWORD dwMilliseconds);
|
|
int WaitForMultipleObjects(DWORD nCount,const HANDLE* lpHandles,BOOL bWaitAll,DWORD dwMilliseconds);
|
|
int WaitForMultipleObjectsEx(DWORD nCount,const HANDLE* lpHandles,BOOL bWaitAll,DWORD dwMilliseconds,BOOL bAlertable);
|
|
int WaitForSingleObject(HANDLE hHandle,DWORD dwMilliseconds);
|
|
int WaitForSingleObjectEx(HANDLE hHandle,DWORD dwMilliseconds,BOOL bAlertable);
|
|
int WaitForThreadpoolIoCallbacks(PTP_IO pio,BOOL fCancelPendingCallbacks);
|
|
int WaitForThreadpoolTimerCallbacks(PTP_TIMER pti,BOOL fCancelPendingCallbacks);
|
|
int WaitForThreadpoolWaitCallbacks(PTP_WAIT pwa,BOOL fCancelPendingCallbacks);
|
|
int WaitForThreadpoolWorkCallbacks(PTP_WORK pwk,BOOL fCancelPendingCallbacks);
|
|
int WakeAllConditionVariable(PCONDITION_VARIABLE ConditionVariable);
|
|
int WakeConditionVariable(PCONDITION_VARIABLE ConditionVariable);
|
|
int WerGetFlags(HANDLE hProcess,PDWORD pdwFlags);
|
|
int WerRegisterFile(PCWSTR pwzFile,WER_REGISTER_FILE_TYPE regFileType,DWORD dwFlags);
|
|
int WerRegisterMemoryBlock(PVOID pvAddress,DWORD dwSize);
|
|
int WerRegisterRuntimeExceptionModule(PCWSTR pwszOutOfProcessCallbackDll,PVOID pContext);
|
|
int WerSetFlags(DWORD dwFlags);
|
|
int WerUnregisterFile(PCWSTR pwzFilePath);
|
|
int WerUnregisterMemoryBlock(PVOID pvAddress);
|
|
int WerUnregisterRuntimeExceptionModule(PCWSTR pwszOutOfProcessCallbackDll,PVOID pContext);
|
|
int WideCharToMultiByte(UINT CodePage,DWORD Options,LPCWSTR WideCharStr,int WideCharCount,LPSTR lpszBuffer,int MultiByteByte,LPCSTR pDefaultChar,LPBOOL pDefaultCharUsed);
|
|
int WinExec(LPCSTR lpCmdLine,UINT uCmdShow);
|
|
int Wow64DisableWow64FsRedirection(PVOID* OldValue);
|
|
int Wow64EnableWow64FsRedirection(BOOLEAN Wow64FsEnableRedirection);
|
|
int Wow64GetThreadContext(HANDLE hThread,PWOW64_CONTEXT lpContext);
|
|
int Wow64GetThreadSelectorEntry(HANDLE hThread,DWORD dwSelector,PWOW64_LDT_ENTRY lpSelectorEntry);
|
|
int Wow64RevertWow64FsRedirection(PVOID OldValue);
|
|
int Wow64SetThreadContext(HANDLE hThread,CONST WOW64_CONTEXT* lpContext);
|
|
int Wow64SuspendThread(HANDLE hThread);
|
|
int WriteConsole(HANDLE hConsoleOutput,LPCTSTR lpBuffer,DWORD nNumberOfCharsToWrite,LPDWORD lpNumberOfCharsWritten,LPVOID lpReserved);
|
|
int WriteConsoleInput(HANDLE hConsoleInput,const INPUT_RECORD* lpBuffer,DWORD nLength,LPDWORD lpNumberOfEventsWritten);
|
|
int WriteConsoleOutput(HANDLE hConsoleOutput,const CHAR_INFO* lpBuffer,COORD dwBufferSize,COORD dwBufferCoord,PSMALL_RECT lpWriteRegion);
|
|
int WriteConsoleOutputA(HANDLE hConsoleOutput,const CHAR_INFO* lpBuffer,COORD dwBufferSize,COORD dwBufferCoord,PSMALL_RECT lpWriteRegion);
|
|
int WriteConsoleOutputAttribute(HANDLE hConsoleOutput,const WORD* lpAttribute,DWORD nLength,COORD dwWriteCoord,LPDWORD lpNumberOfAttrsWritten);
|
|
int WriteConsoleOutputCharacter(HANDLE hConsoleOutput,LPCTSTR lpCharacter,DWORD nLength,COORD dwWriteCoord,LPDWORD lpNumberOfCharsWritten);
|
|
BOOL WriteFile(HANDLE hFile,LPCVOID lpWriteData,DWORD nNumberOfBytesToWrite,LPDWORD lpNumberOfBytesWritten,LPOVERLAPPED lpOverlapped);
|
|
int WriteFileEx(HANDLE hFile,LPCVOID lpWriteData,DWORD nNumberOfBytesToWrite,LPOVERLAPPED lpOverlapped,LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
|
|
int WriteFileGather(HANDLE hFile,FILE_SEGMENT_ELEMENT lpBuffer,DWORD nNumberOfBytesToWrite,LPDWORD pOverlapped,LPOVERLAPPED lpCompletionRoutine);
|
|
int WriteFileW(HANDLE hFile,LPCVOID lpWriteData,DWORD nNumberOfBytesToWrite,LPDWORD lpNumberOfBytesWritten,LPOVERLAPPED lpOverlapped);
|
|
int WritePrivateProfileSection(LPCTSTR lpAppName,LPCTSTR lpString,LPCTSTR lpFileName);
|
|
int WritePrivateProfileSectionA(LPCTSTR lpAppName,LPCTSTR lpString,LPCTSTR lpFileName);
|
|
int WritePrivateProfileSectionW(LPCTSTR lpAppName,LPCTSTR lpString,LPCTSTR lpFileName);
|
|
int WritePrivateProfileString(LPCTSTR lpAppName,LPCTSTR lpKeyName,LPCTSTR lpString,LPCTSTR lpFileName);
|
|
int WritePrivateProfileStringA(LPCTSTR lpAppName,LPCTSTR lpKeyName,LPCTSTR lpString,LPCTSTR pFileName);
|
|
int WritePrivateProfileStringW(LPCTSTR lpAppName,LPCTSTR lpKeyName,LPCTSTR lpString,LPCTSTR pFileName);
|
|
int WritePrivateProfileStruct(LPCTSTR lpszSection,LPCTSTR lpszKey,LPVOID lpStruct,UINT uSizeStruct,LPCTSTR szFile);
|
|
int WritePrivateProfileStructA(LPCTSTR lpszSection,LPCTSTR lpszKey,LPVOID lpStruct,UINT uSizeStruct,LPCTSTR szFile);
|
|
int WritePrivateProfileStructW(LPCTSTR lpszSection,LPCTSTR lpszKey,LPVOID lpStruct,UINT uSizeStruct,LPCTSTR szFile);
|
|
int WriteProcessMemory(HANDLE hProcess,LPVOID lpBaseAddress,LPCVOID lpStockBuffer,SIZE_T nBufferSize,SIZE_T* lpNumberOfBytesWritten);
|
|
int WriteProfileSection(LPCTSTR lpAppName,LPCTSTR lpString);
|
|
int WriteProfileSectionA(LPCTSTR lpAppName,LPCTSTR lpString);
|
|
int WriteProfileSectionW(LPCTSTR lpAppName,LPCTSTR lpString);
|
|
int WriteProfileString(LPCTSTR lpAppName,LPCTSTR lpKeyName,LPCTSTR lpString);
|
|
int WriteProfileStringA(LPCTSTR lpszSection,LPCTSTR lpszKeyName,LPCTSTR lpszString);
|
|
int WriteProfileStringW(LPCTSTR lpszSection,LPCTSTR lpszKeyName,LPCTSTR lpszString);
|
|
int WriteTapemark(HANDLE hDevice,DWORD dwTapemarkType,DWORD dwTapemarkCount,BOOL bImmediate);
|
|
int ZombifyActCtx(HANDLE hActCtx);
|
|
int _hread(HFILE hFile,DWORD lpBuffer,DWORD nBufferSize);
|
|
int _hwrite(HFILE hFile,DWORD lpBuffer,DWORD nBufferSize);
|
|
int _lclose(HFILE hFile);
|
|
int _lcreat(LPCSTR lpPathName,DWORD iAttribute);
|
|
int _llseek(HFILE hFile,LONG lOffset,int iOrigin);
|
|
int _lopen(LPCSTR lpPathName,int iReadWrite);
|
|
int _lread(HFILE hFile,LPVOID lpBuffer,UINT nBufferSize);
|
|
int _lwrite(HFILE hFile,LPVOID lpBuffer,UINT nBufferSize);
|
|
int lstrcat(LPTSTR String1,LPTSTR String2);
|
|
int lstrcatW(LPTSTR String1,LPTSTR String2);
|
|
int lstrcmp(LPCTSTR string1,LPCTSTR string2);
|
|
int lstrcmpA(LPCTSTR string1,LPCTSTR string2);
|
|
int lstrcmpW(LPCTSTR string1,LPCTSTR string2);
|
|
int lstrcmpi(LPCTSTR string1,LPCTSTR string2);
|
|
int lstrcmpiW(LPCTSTR lpString1,LPCTSTR lpString2);
|
|
int lstrcpy(LPTSTR lpString1,LPTSTR lpString2);
|
|
int lstrcpyW(LPTSTR lpString1,LPTSTR lpString2);
|
|
int lstrcpyn(LPTSTR lpBuffer,LPCTSTR lpstrSrc,int nBuffer);
|
|
int lstrcpynW(LPTSTR lpBuffer,LPCTSTR lpstrSrc,int nBuffer);
|
|
int lstrlen(LPCTSTR lpString);
|
|
int lstrlenA(LPCTSTR lpString);
|
|
int lstrlenW(LPCTSTR lpString);
|
|
int RtlUnwind(PEXCEPTION_REGISTRATION pRegistrationFrame,PVOID returnAddr,PEXCEPTION_RECORD pExcptRec,DWORD _eax_value);
|
|
bool CreatePipe(PHANDLE hReadPipe,PHANDLE hWritePipe,LPSECURITY_ATTRIBUTES lpPipeAttributes,DWORD nSize);
|
|
long SetHandleCount(long wNumber); |