From dfe18ccda57d3e5e274b8c6dfbe2679963198463 Mon Sep 17 00:00:00 2001 From: tr4ceflow Date: Mon, 9 Jun 2014 15:15:25 +0200 Subject: [PATCH] api fingerprints can be used to obtain informations about common api calls like "messageboxa" added informations for "gdi32, kernel32, shell32, stdio, user32" --- x64_dbg_gui/Project/Data/gdi32.txt | 337 ++++++ x64_dbg_gui/Project/Data/kernel32.txt | 1047 +++++++++++++++++ x64_dbg_gui/Project/Data/shell32.txt | 246 ++++ x64_dbg_gui/Project/Data/stdio.txt | 61 + x64_dbg_gui/Project/Data/user32.txt | 719 +++++++++++ x64_dbg_gui/Project/DebuggerX64.pro | 6 +- x64_dbg_gui/Project/Src/Gui/CPUJumps.cpp | 7 + x64_dbg_gui/Project/Src/Gui/Configuration.cpp | 18 +- x64_dbg_gui/Project/Src/Gui/Configuration.h | 1 + x64_dbg_gui/Project/Src/Gui/MainWindow.cpp | 2 + x64_dbg_gui/Project/Src/Gui/MainWindow.h | 2 + .../Project/Src/Utils/ApiFingerprints.cpp | 110 ++ .../Project/Src/Utils/ApiFingerprints.h | 28 + x64_dbg_gui/Project/Src/config.json | 18 + 14 files changed, 2596 insertions(+), 6 deletions(-) create mode 100644 x64_dbg_gui/Project/Data/gdi32.txt create mode 100644 x64_dbg_gui/Project/Data/kernel32.txt create mode 100644 x64_dbg_gui/Project/Data/shell32.txt create mode 100644 x64_dbg_gui/Project/Data/stdio.txt create mode 100644 x64_dbg_gui/Project/Data/user32.txt create mode 100644 x64_dbg_gui/Project/Src/Utils/ApiFingerprints.cpp create mode 100644 x64_dbg_gui/Project/Src/Utils/ApiFingerprints.h create mode 100644 x64_dbg_gui/Project/Src/config.json diff --git a/x64_dbg_gui/Project/Data/gdi32.txt b/x64_dbg_gui/Project/Data/gdi32.txt new file mode 100644 index 00000000..0c000486 --- /dev/null +++ b/x64_dbg_gui/Project/Data/gdi32.txt @@ -0,0 +1,337 @@ +int AbortDoc(HDC hDC); +int AbortPath(HDC hDC); +int AddFontMemResourceEx(PVOID pbFont,DWORD cbFont,PVOID pdv,DWORD* pcFonts); +int AddFontResource(LPCTSTR lpszFilename); +int AddFontResourceA(LPCTSTR lpszFilename); +int AddFontResourceEx(LPCTSTR lpszFilename,DWORD fl,PVOID pdv); +int AddFontResourceW(LPCTSTR lpszFilename); +int AngleArc(HDC hDC,int x,int y,DWORD dwRadius,FLOAT eStartAngle,FLOAT eSweepAngle); +int AnimatePalette(HPALETTE hpal,UINT iStartindex,UINT cEntries,const PALETTEENTRY* ppe); +int Arc(HDC hDC,int nLeftRect,int nTopRect,int nTopRect,int nBottomRect,int nXStartArc,int nYStartArc,int nXEndArc,int nYEndArc); +int ArcTo(HDC hdc,int nLeftRect,int nTopRect,int nRightRect,int nBottomRect,int nXRadial1,int nYRadial1,int nXRadial2,int nYRadial2); +int BeginPath(HDC hDC); +int BitBlt(HDC hDCDest,int nXDest,int nYDest,int nWidth,int nHeight,HDC hdcSrc,int nXSrc,int nYSrc,DWORD dwRop); +int CancelDC(HDC hDC); +int ChoosePixelFormat(HDC hdc,const PIXELFORMATDESCRIPTOR* ppfd); +int Chord(HDC hDC,int nLeftRect,int nTopRect,int nRightRect,int nBottomRect,int nXRadial1,int nYRadial1,int nXRadial2,int nYRadial2); +int CloseEnhMetaFile(HDC hDC); +int CloseFigure(HDC hDC); +int CloseMetaFile(HDC hDC); +int CombineRgn(HRGN hrgnDest,HRGN hrgnSrc1,HRGN hrgnSrc2,DWORD fnCombineMode); +int CombineTransform(LPXFORM lpxformResult,const XFORM* lpxform1,const XFORM* lpxform2); +int CopyEnhMetaFile(HENHMETAFILE hemfSrc,LPCTSTR lpszFile); +int CopyEnhMetaFileA(HENHMETAFILE hemfSrc,LPCTSTR lpszFile); +int CopyEnhMetaFileW(HENHMETAFILE hemfSrc,LPCTSTR lpszFile); +int CopyMetaFile(HMETAFILE hmfSrc,LPCTSTR lpszFile); +int CopyMetaFileA(HMETAFILE hmfSrc,LPCTSTR lpszFile); +int CopyMetaFileW(HMETAFILE hmfSrc,LPCTSTR lpszFile); +int CreateBitmap(int nWidth,int nHeight,UINT cPlanes,UINT cBitsPerPel,const VOID* lpvBits); +int CreateBitmapIndirect(const BITMAP* lpbm); +int CreateBrushIndirect(const LOGBRUSH* lplb); +int CreateCompatibleBitmap(HDC hDC,int nWidth,int nHeight); +int CreateCompatibleDC(HDC hDC); +int CreateDC(LPCTSTR lpszDriver,LPCTSTR lpszDevice,LPCTSTR lpszOutput,const DEVMODE* lpInitData); +int CreateDCA(LPCTSTR lpszDriver,LPCTSTR lpszDevice,LPCTSTR lpszOutput,const DEVMODE* lpInitData); +int CreateDCW(LPCTSTR lpszDriver,LPCTSTR lpszDevice,LPCTSTR lpszOutput,const DEVMODE* lpInitData); +int CreateDIBPatternBrush(HGLOBAL hglbDIBPacked,UINT fuColorSpec); +int CreateDIBPatternBrushPt(const VOID* lpPackedDIB,DWORD iUsage); +int CreateDIBSection(HDC hDC,const BITMAPINFO* pbmi,DWORD iUsage,VOID** ppvBits,HANDLE hSection,DWORD dwOffset); +int CreateDIBitmap(HDC hDC,const BITMAPINFOHEADER* lpbmih,DWORD lpbmih,const VOID* lpbInit,const BITMAPINFO* lpbmi,DWORD fuUsage); +int CreateDiscardableBitmap(HDC hdc,int nWidth,int nHeight); +int CreateEllipticRgn(int nLeftRect,int nTopRect,int nRightRect,int nBottomRect); +int CreateEllipticRgnIndirect(const RECT* lprc); +int CreateEnhMetaFile(HDC hdcRef,LPCTSTR lpFilename,const RECT* lpRect,LPCTSTR lpDescription); +int CreateEnhMetaFileA(HDC hDC,LPCTSTR lpFilename,const RECT* lpRect,LPCTSTR lpDescription); +int CreateEnhMetaFileW(HDC hDC,LPCTSTR lpFilename,const RECT* lpRect,LPCTSTR lpDescription); +int CreateFont(int nHeight,int nWidth,int nEscapement,int nOrientation,DWORD fnWeight,DWORD fdwItalic,DWORD fdwUnderline,DWORD fdwStrikeOut,DWORD fdwCharSet,DWORD fdwOutputPrecision,DWORD fdwClipPrecision,DWORD fdwQuality,DWORD fdwPitchAndFamily,LPCTSTR lpszFace); +int CreateFontA(int nHeight,int nWidth,int nEscapement,int nOrientation,DWORD fnWeight,DWORD fdwItalic,DWORD fdwUnderline,DWORD fdwStrikeOut,DWORD fdwCharSet,DWORD fdwOutputPrecision,DWORD fdwClipPrecision,DWORD fdwQuality,DWORD fdwPitchAndFamily,LPCTSTR lpszFace); +int CreateFontIndirect(const LOGFONT* lplf); +int CreateFontIndirectA(const LOGFONT* lplf); +int CreateFontIndirectEx(const ENUMLOGFONTEXDV* penumlfex); +int CreateFontIndirectW(const LOGFONT* lplf); +int CreateFontW(int nHeight,int nWidth,int nEscapement,int nOrientation,DWORD fnWeight,DWORD fdwItalic,DWORD fdwUnderline,DWORD fdwStrikeOut,DWORD fdwCharSet,DWORD fdwOutputPrecision,DWORD fdwClipPrecision,DWORD fdwQuality,DWORD fdwPitchAndFamily,LPCTSTR lpszFace); +int CreateHalftonePalette(HDC hDC); +int CreateHatchBrush(DWORD fnStyle,COLORREF clrref); +int CreateIC(LPCTSTR lpszDriver,LPCTSTR lpszDevice,LPCTSTR lpszOutput,const DEVMODE* lpdvmInit); +int CreateICA(LPCTSTR lpszDriver,LPCTSTR lpszDevice,LPCTSTR lpszOutput,const DEVMODE* lpdvmInit); +int CreateMetaFile(LPCTSTR lpszFile); +int CreateMetaFileA(LPCTSTR lpszFile); +int CreateMetaFileW(LPCTSTR lpszFile); +int CreatePalette(const LOGPALETTE* lplgpl); +int CreatePatternBrush(HBITMAP hbmp); +int CreatePolyPolygonRgn(const POINT* lppt,const INT* lpPolyCounts,int nCount,DWORD fnPolyFillMode); +int CreatePolygonRgn(const POINT* lppt,int cPoints,DWORD fnPolyFillMode); +int CreateRectRgn(int nLeftRect,int nTopRect,int nRightRect,int nBottomRect); +int CreateRectRgnIndirect(const RECT* lprc); +int CreateRoundRectRgn(int nLeftRect,int nTopRect,int nRightRect,int nBottomRect,int nWidthEllipse,int nHeightEllipse); +int CreateScalableFontResource(DWORD fdwHidden,LPCTSTR lpszFontRes,LPCTSTR lpszFontFile,LPCTSTR lpszCurrentPath); +int CreateScalableFontResourceA(DWORD fdwHidden,LPCTSTR lpszFontRes,LPCTSTR lpszFontFile,LPCTSTR lpszCurrentPath); +int CreateScalableFontResourceW(DWORD fdwHidden,LPCTSTR lpszFontRes,LPCTSTR lpszFontFile,LPCTSTR lpszCurrentPath); +int CreateSolidBrush(COLORREF crColor); +int DPtoLP(HDC hDC,LPPOINT lpPoints,int nCount); +int DeleteDC(HDC hDC); +int DeleteEnhMetaFile(HENHMETAFILE hemf); +int DeleteMetaFile(HMETAFILE hmf); +int DeleteObject(HGDIOBJ hObject); +int DescribePixelFormat(HDC hdc,int iPixelFormat,UINT nBytes,LPPIXELFORMATDESCRIPTOR ppfd); +int DrawEscape(HDC hDC,int nEscape,int cbInput,LPCSTR lpszInData); +int Ellipse(HDC hdc,int nLeftRect,int nTopRect,int nRightRect,int nBottomRect); +int EndDoc(HDC hDC); +int EndPage(HDC hDC); +int EndPath(HDC hDC); +int EnumEnhMetaFile(HDC hDC,HENHMETAFILE hemf,ENHMFENUMPROC lpEnhMetaFunc,LPVOID lpData,const RECT* lpRect); +int EnumFontFamilies(HDC hdc,LPCTSTR lpszFamily,FONTENUMPROC lpEnumFontFamProc,LPARAM lParam); +int EnumFontFamiliesA(HDC hDC,LPCTSTR lpszFamily,FONTENUMPROC lpEnumFontFamProc,LPARAM lParam); +int EnumFontFamiliesEx(HDC hdc,LPLOGFONT lpLogfont,FONTENUMPROC lpEnumFontFamExProc,LPARAM lParam,DWORD dwFlags); +int EnumFontFamiliesExA(HDC hDC,LPLOGFONT lpLogfont,FONTENUMPROC lpEnumFontFamExProc,LPARAM lParam,DWORD dwFlags); +int EnumFontFamiliesExW(HDC hDC,LPLOGFONT lpLogfont,FONTENUMPROC lpEnumFontFamExProc,LPARAM lParam,DWORD dwFlags); +int EnumFontFamiliesW(HDC hDC,LPCTSTR lpszFamily,FONTENUMPROC lpEnumFontFamProc,LPARAM lParam); +int EnumFonts(HDC hdc,LPCTSTR lpFaceName,FONTENUMPROC lpFontFunc,LPARAM lParam); +int EnumFontsA(HDC hDC,LPCTSTR lpFaceName,FONTENUMPROC lpFontFunc,LPARAM lParam); +int EnumFontsW(HDC hDC,LPCTSTR lpFaceName,FONTENUMPROC lpFontFunc,LPARAM lParam); +int EnumMetaFile(HDC hDC,HMETAFILE hmf,MFENUMPROC lpMetaFunc,LPARAM lParam); +int EnumObjects(HDC hDC,int nObjectType,GOBJENUMPROC lpObjectFunc,LPARAM lParam); +int EqualRgn(HRGN hSrcRgn1,HRGN hSrcRgn2); +int Escape(HDC hDC,DWORD nEscape,int cbInput,LPCSTR lpvInData,LPVOID lpvOutData ); +int ExcludeClipRect(HDC hDC,int nLeftRect,int nTopRect,int nRightRect,int nBottomRect); +int ExtCreateRegion(const XFORM* lpXform,DWORD nCount,const RGNDATA* lpRgnData); +int ExtEscape(HDC hdc,int nEscape,int cbInput,LPCSTR lpszInData,int cbOutput,LPSTR lpszOutData); +int ExtFloodFill(HDC hDC,int nXStart,int nYStart,COLORREF crColor,UINT fuFillType); +int ExtSelectClipRgn(HDC hDC,HRGN hrgn,DWORD fnMode); +int ExtTextOut(HDC hdc,int X,int Y,DWORD fuOptions,const RECT* lprc,LPCTSTR lpString,UINT cbCount,const INT* lpDx); +int ExtTextOutA(HDC hDC,int X,int Y,DWORD fuOptions,const RECT* lprc,LPCTSTR lpString,UINT cbCount,const INT* lpDx); +int ExtTextOutW(HDC hDC,int X,int Y,DWORD fuOptions,const RECT* lprc,LPCTSTR lpString,UINT cbCount,const INT* lpDx); +int FillPath(HDC hDC); +int FillRgn(HDC hDc,HRGN hrgn,HBRUSH hbr); +int FlattenPath(HDC hDC); +int FloodFill(HDC hDc,int nXStart,int nYStart,COLORREF crFill); +int FrameRgn(HDC hDc,HRGN hrgn,HBRUSH hbr,int nWidth,int nHeight); +int GdiComment(HDC hDC,UINT cbSize,const BYTE* lpData); +int GdiFlush(); +int GdiGetBatchLimit(); +int GdiSetBatchLimit(DWORD dwLimit); +int GetArcDirection(HDC hDC); +int GetAspectRatioFilterEx(HDC hDC); +int GetBitmapBits(HBITMAP hBitmap,LONG dwCount,LPVOID lpBits); +int GetBitmapDimensionEx(HBITMAP hBitmap,LPSIZE lpDimension); +int GetBkColor(HDC hDC); +int GetBkMode(HDC hDC); +int GetBoundsRect(HDC hDC,LPRECT lprcBounds,DWORD flags); +int GetBrushOrgEx(HDC hDC,LPPOINT lppt); +int GetCharABCWidths(HDC hdc,UINT uFirstChar,UINT uLastChar,LPABC lpabc); +int GetCharABCWidthsA(HDC hDC,UINT uFirstChar,UINT uLastChar,LPABC lpabc); +int GetCharABCWidthsFloat(HDC hdc,UINT iFirstChar,UINT iLastChar,LPABCFLOAT lpABCF); +int GetCharABCWidthsFloatA(HDC hDC,UINT iFirstChar,UINT iLastChar,LPABCFLOAT lpABCF); +int GetCharABCWidthsFloatW(HDC hDC,UINT iFirstChar,UINT iLastChar,LPABCFLOAT lpABCF); +int GetCharABCWidthsI(HDC hdc,UINT giFirst,UINT cgi,LPWORD pgi,LPABC lpabc); +int GetCharABCWidthsW(HDC hDC,UINT uFirstChar,UINT uLastChar,LPABC lpabc); +int GetCharWidth(HDC hdc,UINT iFirstChar,UINT iLastChar,LPINT lpBuffer); +int GetCharWidth32(HDC hdc,UINT iFirstChar,UINT iLastChar,LPINT lpBuffer); +int GetCharWidthA(HDC hDC,UINT iFirstChar,UINT iLastChar,LPINT lpStockBuffer); +int GetCharWidthFloat(HDC hdc,UINT iFirstChar,UINT iLastChar,PFLOAT pxBuffer); +int GetCharWidthI(HDC hdc,UINT giFirst,UINT cgi,LPWORD pgi,LPINT lpBuffer); +int GetCharWidthW(HDC hDC,UINT iFirstChar,UINT iLastChar,LPINT lpStockBuffer); +int GetCharacterPlacement(HDC hdc,LPCTSTR lpString,int nCount,int nMaxExtent,LPGCP_RESULTS lpResults,DWORD dwFlags); +int GetCharacterPlacementA(HDC hDC,LPCTSTR lpString,int nCount,int nMaxExtent,LPGCP_RESULTS lpResults,DWORD dwFlags); +int GetCharacterPlacementW(HDC hDC,LPCTSTR lpString,int nCount,int nMaxExtent,LPGCP_RESULTS lpResults,DWORD dwFlags); +int GetClipBox(HDC hDC,LPRECT lprc); +int GetClipRgn(HDC hdc,HRGN hrgn); +int GetColorAdjustment(HDC hdc,LPCOLORADJUSTMENT lpca); +int GetCurrentObject(HDC hDC,DWORD uObjectType); +int GetCurrentPositionEx(HDC hDC,LPPOINT lpPoint); +int GetDCBrushColor(HDC hdc); +int GetDCOrgEx(HDC hDC,LPPOINT lpPoint); +int GetDCPenColor(HDC hdc); +int GetDIBColorTable(HDC hDC,UINT uStartIndex,UINT cEntries,RGBQUAD* pColors); +int GetDIBits(HDC hDC,HBITMAP hbmp,UINT uStartScan,UINT cScanLines,LPVOID lpvBits,LPBITMAPINFO lpbi,DWORD uUsage); +int GetDeviceCaps(HDC hDC,DWORD nIndex); +int GetEnhMetaFile(LPCTSTR lpszMetaFile); +int GetEnhMetaFileA(LPCTSTR lpszMetaFile); +int GetEnhMetaFileBits(HENHMETAFILE hemf,UINT cbBuffer,LPBYTE lpbBuffer); +int GetEnhMetaFileDescription(HENHMETAFILE hemf,UINT cchBuffer,LPTSTR lpszDescription); +int GetEnhMetaFileDescriptionA(HENHMETAFILE hemf,UINT cchBuffer,LPTSTR lpszDescription); +int GetEnhMetaFileDescriptionW(HENHMETAFILE hemf,UINT cchBuffer,LPTSTR lpszDescription); +int GetEnhMetaFileHeader(HENHMETAFILE hemf,UINT cbBuffer,LPENHMETAHEADER lpemh); +int GetEnhMetaFilePaletteEntries(HENHMETAFILE hemf,UINT cEntries,LPPALETTEENTRY lppe); +int GetEnhMetaFilePixelFormat(HENHMETAFILE hemf,DWORD cbBuffer,const PIXELFORMATDESCRIPTOR* ppfd); +int GetEnhMetaFileW(LPCTSTR lpszMetaFile); +int GetFontData(HDC hDC,DWORD dwTable,DWORD dwOffset,LPVOID lpvBuffer,DWORD cbData); +int GetFontLanguageInfo(HDC hDC); +int GetFontUnicodeRanges(HDC hdc,LPGLYPHSET lpgs); +int GetGlyphIndices(HDC hdc,LPCTSTR lpstr,int c,LPWORD pgi,DWORD fl); +int GetGlyphOutline(HDC hDC,UINT uChar,DWORD uFormat,LPGLYPHMETRICS lpgm,DWORD cbBuffer,LPVOID lpvBuffer,const MAT2* lpmat2); +int GetGlyphOutlineW(HDC hDC,UINT uChar,DWORD uFormat,LPGLYPHMETRICS lpgm,DWORD cbBuffer,LPVOID lpvBuffer,const MAT2* lpmat2); +int GetGraphicsMode(HDC hDC); +int GetKerningPairs(HDC hDC,DWORD nNumPairs,LPKERNINGPAIR lpkrnpair); +int GetKerningPairsW(HDC hDC,DWORD nNumPairs,LPKERNINGPAIR lpkrnpair); +int GetLayout(HDC hdc); +int GetMapMode(HDC hDC); +int GetMetaFileBitsEx(HMETAFILE hmf,UINT nSize,LPVOID lpvData); +int GetMetaRgn(HDC hdc,HRGN hrgn); +int GetMiterLimit(HDC hDC,PFLOAT peLimit); +int GetNearestColor(HDC hDC,COLORREF crColor); +int GetNearestPaletteIndex(HPALETTE hpal,COLORREF crColor); +int GetObject(HGDIOBJ hgdiobj,int cbBuffer,LPVOID lpvObject); +int GetObjectA(HGDIOBJ hgdiobj,int cbBuffer,LPVOID lpvObject); +int GetObjectType(HGDIOBJ hgdiobj); +int GetObjectW(HGDIOBJ hgdiobj,int cbBuffer,LPVOID lpvObject); +int GetOutlineTextMetrics(HDC hdc,UINT cbData,LPOUTLINETEXTMETRIC lpOTM); +int GetOutlineTextMetricsA(HDC hDC,UINT cbData,LPOUTLINETEXTMETRIC lpOTM); +int GetOutlineTextMetricsW(HDC hDC,UINT cbData,LPOUTLINETEXTMETRIC lpOTM); +int GetPaletteEntries(HPALETTE hpal,UINT iStartIndex,UINT nEntries,LPPALETTEENTRY lppe); +int GetPath(HDC hDC,LPPOINT lpPoints,LPBYTE lpTypes,int nSize); +int GetPixel(HDC hDC,int XPos,int YPos); +int GetPixelFormat(HDC hdc); +int GetPolyFillMode(HDC hDC); +int GetROP2(HDC hDC); +int GetRandomRgn(HDC hdc,HRGN hrgn,DWORD iNum); +int GetRasterizerCaps(LPRASTERIZER_STATUS lprs,UINT cb); +int GetRegionData(HRGN hRgn,DWORD dwCount,LPRGNDATA lpRgnData); +int GetRgnBox(HRGN hrgn,LPRECT lprc); +int GetStockObject(int fnIndex); +int GetStretchBltMode(HDC hDC); +int GetSystemPaletteEntries(HDC hDC,UINT wStartIndex,UINT wNumEntries,LPPALETTEENTRY lpPaletteEntries); +int GetSystemPaletteUse(HDC hdc); +int GetTextAlign(HDC hDC); +int GetTextCharacterExtra(HDC hDC); +int GetTextCharset(HDC hDC); +int GetTextCharsetInfo(HDC hDC); +int GetTextColor(HDC hDC); +int GetTextExtentExPoint(HDC hdc,LPCTSTR lpszStr,int cchString,int nMaxExtent,LPINT lpnFit,LPINT alpDx,LPSIZE lpSize); +int GetTextExtentExPointA(HDC hDC,LPCTSTR lpszStr,int cchString,int nMaxExtent,LPINT lpnFit,LPINT alpDx,LPSIZE lpSize); +int GetTextExtentExPointI(HDC hdc,LPWORD pgiIn,int cgi,int nMaxExtent,LPINT lpnFit,LPINT alpDx,LPSIZE lpSize); +int GetTextExtentExPointW(HDC hDC,LPCTSTR lpszStr,int cchString,int nMaxExtent,LPINT lpnFit,LPINT alpDx,LPSIZE lpSize); +int GetTextExtentPoint(HDC hdc,LPCTSTR lpString,int cbString,LPSIZE lpSize); +int GetTextExtentPoint32(HDC hdc,LPCTSTR lpString,int c,LPSIZE lpSize); +int GetTextExtentPoint32A(HDC hDC,LPCTSTR lpString,int cbString,LPSIZE lpSize); +int GetTextExtentPoint32W(HDC hdc,LPCTSTR lpString,int cbString,LPSIZE lpSize); +int GetTextExtentPointA(HDC hDC,LPCTSTR lpString,int cbString,LPSIZE lpSize); +int GetTextExtentPointI(HDC hdc,LPWORD pgiIn,int cgi,LPSIZE lpSize); +int GetTextExtentPointW(HDC hDC,LPCTSTR lpString,int cbString,LPSIZE lpSize); +int GetTextFace(HDC hdc,int nCount,LPTSTR lpFaceName); +int GetTextFaceA(HDC hDC,int nCount,LPTSTR lpFaceName); +int GetTextFaceW(HDC hDC,int nCount,LPTSTR lpFaceName); +int GetTextMetrics(HDC hdc,LPTEXTMETRIC lptm); +int GetTextMetricsA(HDC hDC,LPTEXTMETRIC lptm); +int GetTextMetricsW(HDC hDC,LPTEXTMETRIC lptm); +int GetViewportExtEx(HDC hDC,LPSIZE lpSize); +int GetViewportOrgEx(HDC hDC,LPPOINT lpPoint); +int GetWinMetaFileBits(HENHMETAFILE hemf,UINT cbBuffer,LPBYTE lpbBuffer,DWORD fnMapMode,HDC hdcRef); +int GetWindowExtEx(HDC hWnd,LPSIZE lpSize); +int GetWindowOrgEx(HDC hWnd,LPPOINT lpPoint); +int GetWorldTransform(HDC hDC,LPXFORM lpXform); +int IntersectClipRect(HDC hDC,int nLeftRect,int nTopRect,int nRightRect,int nBottomRect); +int InvertRgn(HDC hDC,HRGN hrgn); +int LPtoDP(HDC hDC,LPPOINT lpPoints,int nCount); +int LineDDA(int nXStart,int nYStart,int nXEnd,int nYEnd,LINEDDAPROC lpLineFunc,LPARAM lpData); +int LineTo(HDC hDC,int nXEnd,int nYEnd); +int MaskBlt(HDC hdcDest,int nXDest,int nYDest,int nWidth,int nHeight,HDC hdcSrc,int nXSrc,int nYSrc,HBITMAP hbmMask,int xMask,int yMask,DWORD dwRop); +int ModifyWorldTransform(HDC hDC,const XFORM* lpXform,DWORD iMode); +int MoveToEx(HDC hDC,int X,int Y,LPPOINT lpPoint); +int OffsetClipRgn(HDC hDC,int nXOffset,int nYOffset); +int OffsetRgn(HRGN hrgn,int nXOffset,int nYOffset); +int OffsetViewportOrgEx(HDC hDC,int nXOffset,int nYOffset,LPPOINT lpPoint); +int OffsetWindowOrgEx(HDC hDC,int nXOffset,int nYOffset,LPPOINT lpPoint); +int PaintRgn(HDC hDC,HRGN hrgn); +int PatBlt(HDC hDC,int nXLeft,int nYLeft,int nWidth,int nHeight,DWORD dwRop); +int PathToRegion(HDC hDC); +int Pie(HDC hDC,int nLeftRect,int nTopRect,int nRightRect,int nBottomRect,int nXRadial1,int nYRadial1,int nXRadial2,int nYRadial2); +int PlayEnhMetaFile(HDC hDC,HENHMETAFILE hemf,const RECT* lpRect); +int PlayEnhMetaFileRecord(HDC hDC,LPHANDLETABLE lpHandletable,const ENHMETARECORD* lpEnhMetaRecord,UINT nHandles); +int PlayMetaFile(HDC hDC,HMETAFILE hmf); +int PlayMetaFileRecord(HDC hDC,LPHANDLETABLE lpHandletable,LPMETARECORD lpMetaRecord,UINT nHandles); +int PlgBlt(HDC hdcDest,const POINT* lpPoint,HDC hdcSrc,int nXSrc,int nYSrc,int nWidth,int nHeight,HBITMAP hbmMask,int xMask,int yMask); +int PolyBezier(HDC hDC,const POINT* lppt,DWORD lppt); +int PolyBezierTo(HDC hdc,const POINT* lppt,DWORD cCount); +int PolyDraw(HDC hDC,const POINT* lppt,const BYTE* lpbTypes,int cCount); +int PolyPolygon(HDC hDC,const POINT* lpPoints,const INT* lpPolyCounts,int nCount); +int PolyPolyline(HDC hDC,const POINT* lppt,const DWORD* lpdwPolyPoints,DWORD cCount); +int PolyTextOut(HDC hdc,const POLYTEXT* pptxt,int cStrings); +int PolyTextOutA(HDC hDC,const POLYTEXT* pptxt,int cStrings); +int PolyTextOutW(HDC hDC,const POLYTEXT* pptxt,int cStrings); +int Polygon(HDC hDC,const POINT* lpPoints,int nCount); +int Polyline(HDC hDC,const POINT* lppt,int cPoints); +int PolylineTo(HDC hdc,const POINT* lppt,DWORD cCount); +int PtInRegion(HRGN hrgn,int X,int Y); +int PtVisible(HDC hDC,int X,int Y); +int RealizePalette(DWORD hDC); +int RealizePalette(HDC hDC); +int RectInRegion(HRGN hrgn,const RECT* lprc); +int RectVisible(HDC hDC,const RECT* lprc); +int Rectangle(HDC hDC,int nLeftRect,int nTopRect,int nRightRect,int nBottomRect); +int RemoveFontMemResourceEx(HANDLE fh); +int RemoveFontResource(LPCTSTR lpFileName); +int RemoveFontResourceA(LPCTSTR lpFileName); +int RemoveFontResourceEx(LPCTSTR lpFileName,DWORD fl,PVOID pdv); +int RemoveFontResourceW(LPCTSTR lpFileName); +int ResetDC(HDC hdc,const DEVMODE* lpInitData); +int ResetDCA(HDC hDc,const DEVMODE* lpInitData); +int ResetDCW(HDC hDc,const DEVMODE* lpInitData); +int ResizePalette(HPALETTE hpal,UINT nEntries); +int RestoreDC(HDC hDC,int nSavedDC); +int RoundRect(HDC hDC,int nLeftRect,int nTopRect,int nRightRect,int nBottomRect,int nWidth,int nHeight); +int SaveDC(HDC hDC); +int ScaleViewportExtEx(HDC hDC,int Xnum,int Xdenom,int Ynum,int Ydenom,LPSIZE lpSize); +int ScaleWindowExtEx(HDC hDC,int Xnum,int Xdenom,int Ynum,int Ydenom,LPSIZE lpSize); +int SelectClipPath(HDC hDC,int iMode); +int SelectClipRgn(HDC hDC,HRGN hrgn); +int SelectObject(HDC hDC,HGDIOBJ hObjec); +int SelectPalette(HDC hDC,HPALETTE hpal,BOOL bForceBackground); +int SetAbortProc(HDC hDC,ABORTPROC lpAbortProc); +int SetArcDirection(HDC hDC,int ArcDirection); +int SetBitmapBits(HBITMAP hbmp,DWORD cBytes,const VOID* lpBits); +int SetBitmapDimensionEx(HBITMAP hBitmap,int nWidth,int nHeight,LPSIZE lpSize); +int SetBkColor(HDC hDC,COLORREF crColor); +int SetBkMode(HDC hDC,DWORD iBkMode); +int SetBoundsRect(HDC hDC,const RECT* lprcBounds,DWORD flags); +int SetBrushOrgEx(HDC hDC,int nXOrg,int nYOrg,LPPOINT lppt); +int SetColorAdjustment(HDC hdc,const COLORADJUSTMENT* lpca); +int SetDCBrushColor(HDC hdc,COLORREF crColor); +int SetDCPenColor(HDC hdc,COLORREF crColor); +int SetDIBColorTable(HDC hDC,UINT un1,UINT un2,const RGBQUAD* pcRGBQuad); +int SetDIBits(HDC hDC,HBITMAP hbmp,UINT uStartScan,UINT cScanLines,const VOID* lpvBits,const BITMAPINFO* lpbmi,DWORD fuColorUse); +int SetDIBitsToDevice(HDC hDC,int XDest,int YDest,DWORD dwWidth,DWORD dwHeight,int XSrc,int YSrc,UINT uStartScan,UINT cScanLines,const VOID* lpvBits,const BITMAPINFO* lpbmi,DWORD fuColorUse); +int SetEnhMetaFileBits(UINT cbBuffer,const BYTE* lpData); +int SetGraphicsMode(HDC hDC,DWORD iMode); +int SetLayout(HDC hdc,DWORD dwLayout); +int SetMapMode(HDC hDC,DWORD fnMapMode); +int SetMapperFlags(HDC hDC,DWORD dwFlag); +int SetMetaFileBitsEx(UINT nSize,const BYTE* lpData); +int SetMetaRgn(HDC hdc); +int SetMiterLimit(HDC hDC,FLOAT eNewLimit,PFLOAT peOldLimit); +int SetPaletteEntries(HPALETTE hpal,UINT iStart,UINT cEntries,const PALETTEENTRY* lppe); +int SetPixel(HDC hDC,int X,int Y,COLORREF crColor); +int SetPixelFormat(HDC hdc,int iPixelFormat,const PIXELFORMATDESCRIPTOR* ppfd); +int SetPixelV(HDC hDC,int X,int Y,COLORREF crColor); +int SetPolyFillMode(HDC hDC,DWORD iPolyFillMode); +int SetROP2(HDC hDC,DWORD fnDrawMode2); +int SetRectRgn(HRGN hrgn,int nLeftRect,int nTopRect,int nRightRect,int nBottomRect); +int SetStretchBltMode(HDC hDC,DWORD iStretchMode); +int SetSystemPaletteUse(HDC hdc,UINT uUsage); +int SetTextAlign(HDC hDC,DWORD fMode); +int SetTextCharacterExtra(HDC hDC,int nCharExtra); +int SetTextColor(HDC hDC,COLORREF crColor); +int SetTextJustification(HDC hDC,int nBreakExtra,int nBreakCount); +int SetViewportExtEx(HDC hDc,int nXExtent,int nYExtent,LPSIZE lpSize); +int SetViewportOrgEx(HDC hDC,int X,int Y,LPPOINT lpPoint); +int SetWinMetaFileBits(UINT nBufferSize,const BYTE* lpbBuffer,HDC hdcRef,const METAFILEPICT* lpmfp); +int SetWindowExtEx(HDC hDC,int nXExtent,int nYExtent,LPSIZE lpSize); +int SetWindowOrgEx(HDC hDC,int X,int Y,LPPOINT lpPoint); +int SetWorldTransform(HDC hDC,const XFORM* lpXform); +int StartDoc(HDC hdc,const DOCINFO* lpdi); +int StartDocA(HDC hDC,const DOCINFO* lpdi); +int StartDocW(HDC hDC,const DOCINFO* lpdi); +int StartPage(HDC hDC); +int StretchBlt(HDC hdcDest,int nXOriginDest,int nYOriginDest,int nWidthDest,int nHeightDest,HDC hdcSrc,int nXOriginSrc,int nYOriginSrc,int nWidthSrc,int nHeightSrc,DWORD dwRop); +int StretchDIBits(HDC hDC,int XDest,int YDest,int nDestWidth,int nDestHeight,int XSrc,int YSrc,int nSrcWidth,int nSrcHeight,const VOID* lpBits,const BITMAPINFO* lpBitsInf,DWORD iUsage,DWORD dwRop); +int StrokeAndFillPath(HDC hDC); +int StrokePath(HDC hDC); +int SwapBuffers(HDC hdc); +int TextOut(HDC hdc,int nXStart,int nYStart,LPCTSTR lpString,int cbString); +int TextOutA(HDC hDC,int nXStart,int nYStart,LPCTSTR lpString,int cbString); +int TextOutW(HDC hDC,int nXStart,int nYStart,LPCTSTR lpString,int cbString); +int TranslateCharsetInfo(DWORD* lpSrc,LPCHARSETINFO lpCharsetInfo,DWORD dwFlags); +int UnrealizeObject(HGDIOBJ hgdiobj); +int UpdateColors(HDC hdc); +int WidenPath(HDC hDC); +HPEN CreatePen(int fnPenStyle,int nWidth,COLORREF crColor); \ No newline at end of file diff --git a/x64_dbg_gui/Project/Data/kernel32.txt b/x64_dbg_gui/Project/Data/kernel32.txt new file mode 100644 index 00000000..94731120 --- /dev/null +++ b/x64_dbg_gui/Project/Data/kernel32.txt @@ -0,0 +1,1047 @@ +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); \ No newline at end of file diff --git a/x64_dbg_gui/Project/Data/shell32.txt b/x64_dbg_gui/Project/Data/shell32.txt new file mode 100644 index 00000000..11d0250a --- /dev/null +++ b/x64_dbg_gui/Project/Data/shell32.txt @@ -0,0 +1,246 @@ +int AssocCreateForClasses(const ASSOCIATIONELEMENT* rgClasses,ULONG cClasses,REFIID riid,void** ppv); +int AssocGetDetailsOfPropKey(IShellFolder* psf,PCUITEMID_CHILD pidl,PROPERTYKEY* pkey,VARIANT* pv,BOOL* pfFoundPropKey); +int CDefFolderMenu_Create2(PCIDLIST_ABSOLUTE pidlFolder,HWND hwnd,UINT cidl,PCUITEMID_CHILD_ARRAY* apidl,IShellFolder* psf,LPFNDFMCALLBACK lpfn,UINT nKeys,const HKEY* ahkeys,IContextMenu** ppcm); +int CIDLData_CreateFromIDArray(PCIDLIST_ABSOLUTE pidlFolder,UINT cidl,PCUIDLIST_RELATIVE_ARRAY apidl,IDataObject** ppdtobj); +int CallCPLEntry16(HINSTANCE hInst,FARPROC16 lpfnEntry,HWND hwndCPL,UINT msg,LPARAM lParam1,LPARAM lParam2); +int CommandLineToArgvW(LPCWSTR lpCmdLine,int* pNumArgs); +int DAD_AutoScroll(HWND hwnd,AUTO_SCROLL_DATA* pad,const POINT* pptNow); +int DAD_DragEnterEx(HWND hwndTarget,const POINT ptStart); +int DAD_DragLeave(); +int DAD_DragMove(POINT pt); +int DAD_SetDragImage(HIMAGELIST him,POINT* pptOffset); +int DAD_ShowDragImage(BOOL fShow); +int DllGetVersion(DLLVERSIONINFO* pDllVersionInfo); +int DoEnvironmentSubst(LPTSTR pszString,UINT cchString); +int DragAcceptFiles(HWND hWnd,BOOL fAccept); +int DragFinish(HDROP hDrop); +int DragQueryFile(HDROP hDrop,UINT iFile,LPTSTR lpBuffer,UINT nBuffer); +int DragQueryFileA(HDROP hDrop,UINT iFile,LPTSTR lpBuffer,UINT nBuffer); +int DragQueryFileW(HDROP hDrop,UINT iFile,LPTSTR lpBuffer,UINT nBuffer); +int DragQueryPoint(HDROP hDrop,LPPOINT lppt); +int DriveType(int iDrive); +int DuplicateIcon(HINSTANCE hInst,HICON hIcon); +int ExtractAssociatedIcon(HINSTANCE hInst,LPTSTR lpIconPath,LPWORD lpiIcon); +int ExtractAssociatedIconA(HINSTANCE hInst,LPTSTR szIconPath,LPWORD lpiIcon); +int ExtractAssociatedIconEx(HINSTANCE hInst,LPTSTR lpIconPath,LPWORD lpiIconIndex,LPWORD lpiIconId); +int ExtractAssociatedIconW(HINSTANCE hInst,LPTSTR szIconPath,LPWORD lpiIcon); +int ExtractIcon(DWORD hInst,DWORD lpszExeFileName,DWORD nIconIndex); +int ExtractIcon(HINSTANCE hInst,LPCTSTR lpszExeFileName,UINT nIconIndex); +int ExtractIconA(HINSTANCE hInst,LPCTSTR lpszExeFileName,UINT nIconIndex); +int ExtractIconEx(LPCTSTR lpszFile,int nIconIndex,HICON* phiconLarge,HICON* phiconSmall,UINT nIcons); +int ExtractIconExW(LPCTSTR lpszFile,int nIconIndex,HICON* phiconLarge,HICON* phiconSmall,UINT nIcons); +int ExtractIconW(HINSTANCE hInst,LPCTSTR lpszExeFileName,UINT nIconIndex); +int FileIconInit(BOOL fRestoreCache); +int FindExecutable(LPCTSTR lpFile,LPCTSTR lpDirectory,LPTSTR lpResult); +int GUIDFromString(LPCTSTR psz,LPGUID pguid); +int GetCurrentProcessExplicitAppUserModelID(PWSTR* AppID); +int GetFileNameFromBrowse(HWND hwnd,LPWSTR pszFilePath,UINT cchFilePath,LPCWSTR pszWorkingDir,LPCWSTR pszDefExt,LPCWSTR pszFilters,LPCWSTR szTitle); +int ILAppendID(PIDLIST_RELATIVE pidl,LPSHITEMID pmkid,BOOL fAppend); +int ILClone(PCUIDLIST_RELATIVE pidl); +int ILCloneFirst(PCUIDLIST_RELATIVE pidl); +int ILCombine(PCIDLIST_ABSOLUTE pidl1,PCUIDLIST_RELATIVE pidl2); +int ILCreateFromPath(LPCSTR pszPath); +int ILFindChild(PCIDLIST_ABSOLUTE pidlParent,PCIDLIST_ABSOLUTE pidlChild); +int ILFindLastID(PCUIDLIST_RELATIVE pidl); +int ILFree(PIDLIST_RELATIVE pidl); +int ILGetNext(PCUIDLIST_RELATIVE pidl); +int ILGetSize(PCUIDLIST_RELATIVE pidl); +int ILIsEqual(PCIDLIST_ABSOLUTE pidl1,PCIDLIST_ABSOLUTE pidl2); +int ILIsParent(PCIDLIST_ABSOLUTE pidl1,PCIDLIST_ABSOLUTE pidl2,BOOL fImmediate); +int ILLoadFromStream(IStream* pstm,PIDLIST_RELATIVE* pidl); +int ILRemoveLastID(PUIDLIST_RELATIVE pidl); +int ILSaveToStream(IStream* pstm,PCUIDLIST_RELATIVE pidl); +int InitNetworkAddressControl(); +int IsNetDrive(int iDrive); +int IsUserAnAdmin(); +int LinkWindow_RegisterClass(); +int LinkWindow_UnregisterClass(); +int NTSHChangeNotifyDeregister(ULONG ulID); +int NTSHChangeNotifyRegister(HWND hwnd,int fSources,LONG fEvents,UINT wMsg,int cEntries,SHChangeNotifyEntry* pfsne); +int OpenRegStream(HKEY hkey,LPCWSTR pszSubkey,LPCWSTR pszValue,DWORD grfMode); +int ParseField(LPCTSTR* szData,int n,LPTSTR* szBuf,int iBufLen); +int PathCleanupSpec(LPCWSTR pszDir,LPWSTR pszSpec); +int PathGetShortPath(LPWSTR pszLongPath); +int PathIsExe(LPCWSTR szfile); +int PathIsSlow(LPCTSTR pszFile,DWORD dwFileAttr); +int PathMakeUniqueName(LPWSTR pszUniqueName,UINT cchMax,LPCWSTR pszTemplate,LPCWSTR pszLongPlate,LPCWSTR pszDir); +int PathProcessCommand(LPCWSTR lpSrc,LPWSTR lpDest,int iDestMax,DWORD dwFlags); +int PathResolve(LPWSTR pszPath,LPCWSTR* dirs,UINT fFlags); +int PathYetAnotherMakeUniqueName(LPWSTR pszUniqueName,LPCWSTR pszPath,LPCWSTR pszShort,LPCWSTR pszFileSpec); +int PickIconDlg(HWND hwnd,LPWSTR pszIconPath,UINT cchIconPath,int* piIconIndex); +int PifMgr_CloseProperties(HANDLE hProps,UINT flOpt); +int PifMgr_GetProperties(HANDLE hProps,LPCSTR pszGroup,VOID* lpProps,int cbProps,UINT flOpt); +int PifMgr_OpenProperties(LPCWSTR pszApp,LPCWSTR lpszPIF,UINT hInf,UINT flOpt); +int PifMgr_SetProperties(HANDLE hProps,LPCSTR pszGroup,VOID* lpProps,int cbProps,UINT flOpt); +int ReadCabinetState(CABINETSTATE* pcs,int cLength); +int RealDriveType(int iDrive,BOOL fOKToHitNet); +int RestartDialog(HWND hParent,LPCWSTR pszPrompt,DWORD dwFlags); +int RestartDialogEx(HWND hParent,LPCWSTR pszPrompt,DWORD dwFlags,HWND dwReasonCode); +int SHAddDefaultPropertiesByExt(PCWSTR pszExt,IPropertyStore* pPropStore); +int SHAddFromPropSheetExtArray(HPSXA hpsxa,LPFNADDPROPSHEETPAGE lpfnAddPage,LPARAM lParam); +int SHAddToRecentDocs(UINT uFlags,LPCVOID pv); +int SHAlloc(SIZE_T cb); +int SHAppBarMessage(DWORD dwMessage,PAPPBARDATA pData); +int SHAssocEnumHandlers(LPCWSTR pszExtra,ASSOC_FILTER afFilter,IEnumAssocHandlers** ppEnumHandler); +int SHAssocEnumHandlersForProtocolByApplication(PCWSTR protocol,REFIID riid,void** enumHandlers); +int SHBindToFolderIDListParent(IShellFolder* psfRoot,PCUIDLIST_RELATIVE pidl,REFIID riid,void** ppv,PCUITEMID_CHILD* ppidlLast); +int SHBindToObject(IShellFolder* psf,PCUIDLIST_RELATIVE pidl,IBindCtx* pbc,REFIID riid,void** ppv); +int SHBindToParent(PCIDLIST_ABSOLUTE pidl,REFIID riid,VOID** ppv,PCUITEMID_CHILD* ppidlLast); +int SHBrowseForFolder(LPBROWSEINFO lpbi); +int SHCLSIDFromString(LPCWSTR psz,CLSID* pclsid); +int SHChangeNotification_Lock(HANDLE hChange,DWORD dwProcId,PIDLIST_ABSOLUTE** pppidl,LONG* plEvent); +int SHChangeNotification_Unlock(HANDLE hLock); +int SHChangeNotify(DWORD wEventId,DWORD uFlags,LPCVOID dwItem1,LPCVOID dwItem2); +int SHChangeNotifyDeregister(ULONG ulID); +int SHChangeNotifyRegister(HWND hwnd,int fSources,LONG fEvents,UINT wMsg,int cEntries,const SHChangeNotifyEntry* pshcne); +int SHChangeNotifyRegisterThread(SCNRT_STATUS status); +int SHCloneSpecialIDList(HWND hwndOwner,DWORD csidl,BOOL fCreate); +int SHCoCreateInstance(LPCWSTR pszCLSID,const CLSID* pclsid,IUnknown* pUnkOuter,REFIID riid,void** ppv); +int SHCreateAssociationRegistration(REFIID riid,void** ppv); +int SHCreateDataObject(PCIDLIST_ABSOLUTE pidlFolder,UINT cidl,PCUITEMID_CHILD_ARRAY apidl,IDataObject* pdtInner,REFIID riid,void** ppv); +int SHCreateDefaultContextMenu(const DEFCONTEXTMENU* pdcm,REFIID riid,void** ppv); +int SHCreateDefaultExtractIcon(REFIID riid,void** ppv); +int SHCreateDefaultPropertiesOp(IShellItem* psi,IFileOperation** ppFileOp); +int SHCreateDirectory(HWND hwnd,LPCWSTR pszPath); +int SHCreateDirectoryEx(HWND hwnd,LPCTSTR pszPath,const SECURITY_ATTRIBUTES* psa); +int SHCreateFileExtractIconW(LPCWSTR pszFile,DWORD dwFileAttributes,REFIID riid,void** ppv); +int SHCreateItemFromIDList(PCIDLIST_ABSOLUTE pidl,REFIID riid,void** ppv); +int SHCreateItemFromParsingName(PCWSTR pszPath,IBindCtx* pbc,REFIID riid,void** ppv); +int SHCreateItemFromRelativeName(IShellItem* psiParent,PCWSTR pszName,IBindCtx* pbc,REFIID riid,void** ppv); +int SHCreateItemInKnownFolder(REFKNOWNFOLDERID kfid,KNOWN_FOLDER_FLAG dwKFFlags,PCWSTR pszItem,REFIID riid,void** ppv); +int SHCreateItemWithParent(PCIDLIST_ABSOLUTE pidlParent,IShellFolder* psfParent,PCUITEMID_CHILD pidl,REFIID riid,void** ppvItem); +int SHCreateProcessAsUserW(PSHCREATEPROCESSINFOW pscpi); +int SHCreatePropSheetExtArray(HKEY hkey,LPCWSTR pszSubkey,UINT max_iface); +int SHCreateQueryCancelAutoPlayMoniker(IMoniker** ppmoniker); +int SHCreateShellFolderView(const SFV_CREATE* pcsfv,IShellView** ppsv); +int SHCreateShellFolderViewEx(LPCSFV pcsfv,IShellView** ppsv); +int SHCreateShellItem(PCIDLIST_ABSOLUTE pidlParent,IShellFolder* psfParent,PCUITEMID_CHILD pidl,IShellItem** ppsi); +int SHCreateShellItemArray(PCIDLIST_ABSOLUTE pidlParent,IShellFolder* psf,UINT cidl,PCUITEMID_CHILD_ARRAY ppidl,IShellItemArray** ppsiItemArray); +int SHCreateShellItemArrayFromDataObject(IDataObject* pdo,REFIID riid,void** ppv); +int SHCreateShellItemArrayFromIDLists(UINT cidl,PCIDLIST_ABSOLUTE_ARRAY rgpidl,IShellItemArray** ppsiItemArray); +int SHCreateShellItemArrayFromShellItem(IShellItem* psi,REFIID riid,void** ppv); +int SHCreateStdEnumFmtEtc(UINT cfmt,IEnumFORMATETC** ppenumFormatEtc); +int SHDefExtractIcon(LPCTSTR pszIconFile,int iIndex,UINT uFlags,HICON* phiconLarge,HICON* phiconSmall,UINT nIconSize); +int SHDestroyPropSheetExtArray(HPSXA hpsxa); +int SHDoDragDrop(HWND hwnd,IDataObject* pdtobj,IDropSource* pdsrc,DWORD dwEffect,DWORD* pdwEffect); +int SHEmptyRecycleBin(HWND hwnd,LPCTSTR pszRootPath,DWORD dwFlags); +int SHEnumerateUnreadMailAccountsW(HKEY hKeyUser,DWORD dwIndex,LPWSTR pszMailAddress,int cchMailAddress); +int SHEvaluateSystemCommandTemplate(PCWSTR pszCmdTemplate,PWSTR* ppszApplication,PWSTR* ppszCommandLine,PWSTR* ppszParameters); +int SHExtractIconsW(LPCWSTR pszFileName,int nIconIndex,int cxIcon,int cyIcon,HICON* phIcon,UINT* pIconId,UINT nIcons,UINT flags); +int SHFileOperation(LPSHFILEOPSTRUCT lpFileOp); +int SHFindFiles(PCIDLIST_ABSOLUTE pidlFolder,PCIDLIST_ABSOLUTE pidlSaveFile); +int SHFind_InitMenuPopup(HMENU hmenu,HWND hwnd,UINT idCmdFirst,UINT idCmdLast); +int SHFlushClipboard(); +int SHFlushSFCache(); +int SHFormatDrive(HWND hwnd,UINT drive,UINT fmtID,UINT options); +int SHFree(void* pv); +int SHFreeNameMappings(HANDLE hNameMappings); +int SHGetAttributesFromDataObject(IDataObject* pdo,DWORD dwAttributeMask,DWORD* pdwAttributes,UINT* pcItems); +int SHGetDataFromIDList(IShellFolder* psf,PCUITEMID_CHILD pidl,DWORD nFormat,PVOID pv,int cb); +int SHGetDesktopFolder(IShellFolder** ppshf); +int SHGetDiskFreeSpace(LPCTSTR pszVolume,ULARGE_INTEGER* pqwFreeCaller,ULARGE_INTEGER* pqwTot,ULARGE_INTEGER* pqwFree); +int SHGetDiskFreeSpaceEx(LPCTSTR pszVolume,ULARGE_INTEGER* pqwFreeCaller,ULARGE_INTEGER* pqwTot,ULARGE_INTEGER* pqwFree); +int SHGetDiskFreeSpaceExW(LPCTSTR pszVolume,ULARGE_INTEGER* pqwFreeCaller,ULARGE_INTEGER* pqwTot,ULARGE_INTEGER* pqwFree); +int SHGetDriveMedia(LPCWSTR pszDrive,DWORD* pdwMediaContent); +int SHGetFileInfo(LPCTSTR szPath,DWORD dwFileAttributes,SHFILEINFO* pSFileInfo,UINT cbFileInfo,UINT uFlags); +int SHGetFileInfoW(LPCTSTR szPath,DWORD dwFileAttributes,SHFILEINFO* pSFileInfo,UINT cbFileInfo,UINT uFlags); +int SHGetFolderLocation(HWND hwndOwner,DWORD nFolder,HANDLE hToken,DWORD dwReserved,PIDLIST_ABSOLUTE* ppidl); +int SHGetFolderPath(HWND hwndOwner,int nFolder,HANDLE hToken,DWORD dwFlags,LPTSTR pszPath); +int SHGetFolderPathA(HWND hwndOwner,int nFolder,HANDLE hToken,DWORD dwReserved,LPTSTR lpBuffer); +int SHGetFolderPathAndSubDir(HWND hwnd,DWORD csidl,HANDLE hToken,DWORD dwFlags,LPCTSTR pszSubDir,LPTSTR pszPath); +int SHGetFolderPathW(HWND hwndOwner,int nFolder,HANDLE hToken,DWORD dwReserved,LPTSTR lpBuffer); +int SHGetIDListFromObject(IUnknown* punk,PIDLIST_ABSOLUTE* ppidl); +int SHGetIconOverlayIndex(LPCTSTR pszIconPath,int iIconIndex); +int SHGetImageList(int iImageList,REFIID riid,void** ppv); +int SHGetInstanceExplorer(IUnknown** ppunk); +int SHGetItemFromDataObject(IDataObject* pdtobj,DATAOBJ_GET_ITEM_FLAGS dwFlags,REFIID riid,void** ppv); +int SHGetItemFromObject(IUnknown* punk,REFIID riid,void** ppv); +int SHGetKnownFolderIDList(REFKNOWNFOLDERID rfid,KNOWN_FOLDER_FLAG dwFlags,HANDLE hToken,PIDLIST_ABSOLUTE* ppidl); +int SHGetKnownFolderItem(REFKNOWNFOLDERID rfid,KNOWN_FOLDER_FLAG dwFlags,HANDLE hToken,REFIID riid,void** ppv); +int SHGetKnownFolderPath(REFKNOWNFOLDERID rfid,DWORD dwFlags,HANDLE hToken,PWSTR* ppszPath); +int SHGetLocalizedName(LPCWSTR pszPath,LPWSTR pszResModule,UINT cch,int* pidsRes); +int SHGetMalloc(LPMALLOC* ppMalloc); +int SHGetNameFromIDList(PCIDLIST_ABSOLUTE pidl,SIGDN sigdnName,PWSTR* ppszName); +int SHGetNameFromPropertyKey(REFPROPERTYKEY propkey,PWSTR* ppszCanonicalName); +int SHGetNewLinkInfo(LPCTSTR pszLinkTo,LPCTSTR pszDir,LPTSTR pszName,BOOL* pfMustCopy,UINT uFlags); +int SHGetPathFromIDList(PCIDLIST_ABSOLUTE pidl,LPTSTR pszPath); +int SHGetPathFromIDListEx(PCIDLIST_ABSOLUTE pidl,PWSTR pszPath,DWORD cchPath,GPFIDL_FLAGS uOpts); +int SHGetPathFromIDListW(PCIDLIST_ABSOLUTE pidlTarget,LPTSTR pszPath); +int SHGetPropertyStoreForWindow(HWND hwnd,REFIID riid,void** ppv); +int SHGetPropertyStoreFromIDList(PCIDLIST_ABSOLUTE pidl,GETPROPERTYSTOREFLAGS flags,REFIID riid,void** ppv); +int SHGetPropertyStoreFromParsingName(PCWSTR pszPath,IBindCtx* pbc,GETPROPERTYSTOREFLAGS flags,REFIID riid,void** ppv); +int SHGetRealIDL(IShellFolder* psf,PCUITEMID_CHILD pidlSimple,PITEMID_CHILD* ppidlReal); +int SHGetSetFolderCustomSettings(LPSHFOLDERCUSTOMSETTINGS pfcs,LPCTSTR pszPath,DWORD dwReadWrite); +int SHGetSetSettings(LPSHELLSTATE lpss,DWORD dwMask,BOOL bSet); +int SHGetSettings(LPSHELLFLAGSTATE lpsfs,DWORD dwMask); +int SHGetShellStyleHInstance(); +int SHGetSpecialFolderLocation(HWND hwndOwner,DWORD nFolder,PIDLIST_ABSOLUTE* pidl); +int SHGetSpecialFolderPath(HWND hwndOwner,LPTSTR lpszPath,DWORD csidl,BOOL fCreate); +int SHGetSpecialFolderPathA(HWND hwnd,LPTSTR pszPath,DWORD csidl,BOOL fCreate); +int SHGetSpecialFolderPathW(HWND hwnd,LPTSTR pszPath,DWORD csidl,BOOL fCreate); +int SHGetStockIconInfo(SHSTOCKICONID siid,UINT uFlags,SHSTOCKICONINFO* psii); +int SHGetTemporaryPropertyForItem(IShellItem* psi,REFPROPERTYKEY pk,PROPVARIANT* ppropvarInk); +int SHGetUnreadMailCountW(HKEY hKeyUser,LPCWSTR pszMailAddress,DWORD* pdwCount,FILETIME* pFileTime,LPCWSTR pszShellExecuteCommand,int cchShellExecuteCommand); +int SHHandleUpdateImage(PCIDLIST_ABSOLUTE pidlExtra); +int SHILCreateFromPath(LPCWSTR pszPath,PIDLIST_ABSOLUTE* ppidl,DWORD* rgflnOut); +int SHInvokePrinterCommand(HWND hwnd,UINT uAction,LPCTSTR lpBuf1,LPCTSTR lpBuf2,BOOL fModal); +int SHIsFileAvailableOffline(LPCWSTR pszPath,LPDWORD pdwStatus); +int SHLimitInputEdit(HWND hwndEdit,IShellFolder* psf); +int SHLoadInProc(REFCLSID rclsid); +int SHLoadNonloadedIconOverlayIdentifiers(); +int SHLoadOLE(LPARAM lParam); +int SHLocalStrDup(LPCWSTR psz,LPWSTR* ppsz); +int SHMapIDListToImageListIndexAsync(IShellTaskScheduler* pts,IShellFolder* psf,LPCITEMIDLIST pidl,UINT flags,PFNASYNCICONTASKBALLBACK pfn,void* pvData,void* pvHint,int* piIndex,int* piIndexSel); +int SHMapPIDLToSystemImageListIndex(IShellFolder* psf,PCUITEMID_CHILD pidl,int* piIndex); +int SHMultiFileProperties(IDataObject* pdtobj,DWORD dwFlags); +int SHObjectProperties(HWND hwnd,DWORD shopObjectType,PCWSTR pszObjectName,PCWSTR pszPropertyPage); +int SHOpenFolderAndSelectItems(PCIDLIST_ABSOLUTE pidlFolder,UINT cidl,PCUITEMID_CHILD_ARRAY* apidl,DWORD dwFlags); +int SHOpenPropSheetW(LPCWSTR pszCaption,UINT ckeys,const CLSID* pclsidDef,IDataObject* pdtobj,IShellBrowser* psb,LPCWSTR pStartPage); +int SHOpenWithDialog(HWND hwndParent,const OPENASINFO* poainfo); +int SHParseDisplayName(LPCWSTR pszName,IBindCtx* pbc,PIDLIST_ABSOLUTE* ppidl,SFGAOF sfgaoIn,SFGAOF* psfgaoOut); +int SHPathPrepareForWrite(HWND hwnd,IUnknown* punkEnableModless,LPCTSTR pszPath,DWORD dwFlags); +int SHPropStgCreate(IPropertySetStorage* psstg,REFFMTID fmtid,const CLSID* pclsid,DWORD grfFlags,DWORD grfMode,DWORD dwDisposition,IPropertyStorage** ppstg,UINT* puCodePage); +int SHPropStgReadMultiple(IPropertyStorage* pps,UINT uCodePage,ULONG cpspec); +int SHPropStgWriteMultiple(IPropertyStorage* pps,UINT* uCodePage,ULONG cpspec,PROPID propidNameFirst); +int SHQueryRecycleBin(LPCTSTR pszRootPath,LPSHQUERYRBINFO pSHQueryRBInfo); +int SHQueryUserNotificationState(QUERY_USER_NOTIFICATION_STATE* pquns); +int SHRemoveLocalizedName(LPCWSTR pszPath); +int SHReplaceFromPropSheetExtArray(HPSXA hpsxa,UINT uPageID,LPFNADDPROPSHEETPAGE lpfnReplaceWith,LPARAM lParam); +int SHResolveLibrary(IShellItem* psiLibrary); +int SHRestricted(RESTRICTIONS rest); +int SHRunControlPanel(LPCWSTR lpcszCmdLine,HWND hwndMsgParent); +int SHSetDefaultProperties(HWND hwnd,IShellItem* psi,DWORD dwFileOpFlags,IFileOperationProgressSink* pfops); +int SHSetFolderPath(DWORD csidl,HANDLE hToken,DWORD dwFlags,LPCTSTR pszPath); +int SHSetInstanceExplorer(IUnknown* punk); +int SHSetKnownFolderPath(REFKNOWNFOLDERID rfid,DWORD dwFlags,HANDLE hToken,PCWSTR pszPath); +int SHSetLocalizedName(LPCWSTR pszPath,LPCWSTR pszResModule,int idsRes); +int SHSetTemporaryPropertyForItem(IShellItem* psi,REFPROPERTYKEY propkey,REFPROPVARIANT propvar); +int SHSetUnreadMailCountW(LPCWSTR pszMailAddress,DWORD dwCount,LPCWSTR pszShellExecuteCommand); +int SHShellFolderView_Message(HWND hwnd,UINT uMsg,LPARAM lparam); +int SHShowManageLibraryUI(IShellItem* psiLibrary,HWND hwndOwner,LPCWSTR pszTitle,LPCWSTR pszInstruction,LIBRARYMANAGEDIALOGOPTIONS lmdOptions); +int SHSimpleIDListFromPath(LPCWSTR pszPath); +int SHStartNetConnectionDialogW(HWND hwnd,LPCWSTR pszRemoteName,DWORD dwType); +int SHTestTokenMembership(HANDLE hToken,ULONG ulRID); +int SHUnlockShared(void* pvData); +int SHUpdateImage(LPCTSTR pszHashItem,int iIndex,UINT uFlags,int iImageIndex); +int SHValidateUNC(HWND hwndOwner,LPWSTR pszFile,UINT fConnect); +int SetCurrentProcessExplicitAppUserModelID(PCWSTR AppID); +int ShellAbout(HWND hWnd,LPCTSTR szApp,LPCTSTR szOtherStuff,HICON hIcon); +int ShellAboutA(HWND hWnd,LPCTSTR szApp,LPCTSTR szOtherStuff,HICON hIcon); +int ShellAboutW(HWND hWnd,LPCTSTR szApp,LPCTSTR szOtherStuff,HICON hIcon); +int ShellExecute(HWND hwnd,LPCTSTR lpOperation,LPCTSTR lpFile,LPCTSTR lpParameters,LPCTSTR lpDirectory,INT nShowCmd); +int ShellExecuteA(HWND hWnd,LPCTSTR lpOperation,LPCTSTR lpFile,LPCTSTR lpParameters,LPCTSTR lpDirectory,INT nShowCmd); +int ShellExecuteEx(LPSHELLEXECUTEINFO lpExecInfo); +int ShellExecuteExW(LPSHELLEXECUTEINFO lpExecInfo); +int ShellExecuteW(HWND hWnd,LPCTSTR lpOperation,LPCTSTR lpFile,LPCTSTR lpParameters,LPCTSTR lpDirectory,INT nShowCmd); +int Shell_GetCachedImageIndex(LPCWSTR pwszIconPath,int iIconIndex,UINT uIconFlags); +int Shell_GetImageLists(HIMAGELIST* phiml,HIMAGELIST* phimlSmall); +int Shell_MergeMenus(HMENU hmDst,HMENU hmSrc,UINT uInsert,UINT uIDAdjust,UINT uIDAdjustMax,ULONG uFlags); +int Shell_NotifyIcon(DWORD dwMessage,PNOTIFYICONDATA pnid); +int Shell_NotifyIconGetRect(const NOTIFYICONIDENTIFIER* identifier,RECT* iconLocation); +int Shell_NotifyIconW(DWORD dwMessage,PNOTIFYICONDATA pnid); +int SignalFileOpen(PCIDLIST_ABSOLUTE pidl); +int StgMakeUniqueName(IStorage* pstgParent,PCWSTR pszFileSpec,DWORD grfMode,REFIID riid,void** ppv); +int WOWShellExecute(HWND hwnd,LPCTSTR lpOperation,LPCTSTR lpFile,LPCTSTR lpParameters,LPCTSTR lpDirectory,INT nShowCmd,void* lpfnCBWinExec); +int Win32DeleteFile(LPCTSTR pszFileName); +int WriteCabinetState(CABINETSTATE* pcs); \ No newline at end of file diff --git a/x64_dbg_gui/Project/Data/stdio.txt b/x64_dbg_gui/Project/Data/stdio.txt new file mode 100644 index 00000000..0f206671 --- /dev/null +++ b/x64_dbg_gui/Project/Data/stdio.txt @@ -0,0 +1,61 @@ +int printf(constchar *, ...); +int _scanf(char * format, ...); +char * strchr(char *,char); +void * memcpy(void *, constvoid *, size_t); +int memcmp(constvoid *, constvoid *, size_t); +void * memset(void *,int, size_t); +char * _strset(char *,int); +char * strcpy(char *, constchar *); +char * strcat(char *, constchar *); +int strcmp(constchar *, constchar *); +size_t strlen(constchar *); +int _chdir(constchar *); +char * _getcwd(char *,int); +int _mkdir(constchar *); +int _rmdir(constchar *); +char * _fullpath(char *, constchar *, size_t); +void _splitpath(constchar *,char *,char *,char *,char *); +void _makepath(char *, constchar *, constchar *, constchar *, constchar *); +long _findfirst(constchar *, struct _finddata_t *); +int _findnext(long, struct _finddata_t *); +long _findfirst(constchar *, DWORD *); +int _findnext(long, DWORD *); +int _findclose(long); +void * memccpy(void *, constvoid *,int, unsignedint); +int memicmp(constvoid *, constvoid *, unsignedint); +void * memccpy(void *, constvoid *,int, DWORD); +int memicmp(constvoid *, constvoid *, DWORD); +int strcmpi(constchar *, constchar *); +int stricmp(constchar *, constchar *); +char * strdup(constchar *); +char * strlwr(char *); +int strnicmp(constchar *, constchar *, size_t); +char * strnset(char *,int, size_t); +char * strrev(char *); +char * strset(char *,int); +char * strupr(char *); +char * strchr(constchar *,int); +int _strcmpi(constchar *, constchar *); +int _stricmp(constchar *, constchar *); +int strcoll(constchar *, constchar *); +int _stricoll(constchar *, constchar *); +int _strncoll(constchar *, constchar *, size_t); +int _strnicoll(constchar *, constchar *, size_t); +size_t strcspn(constchar *, constchar *); +char * _strdup(constchar *); +char * _strerror(constchar *); +char * strerror(int); +char * _strlwr(char *); +char * strncat(char *, constchar *, size_t); +int strncmp(constchar *, constchar *, size_t); +int _strnicmp(constchar *, constchar *, size_t); +char * strncpy(char *, constchar *, size_t); +char * _strnset(char *,int, size_t); +char * strpbrk(constchar *, constchar *); +char * strrchr(constchar *,int); +char * _strrev(char *); +size_t strspn(constchar *, constchar *); +char * strstr(constchar *, constchar *); +char * strtok(char *, constchar *); +char * _strupr(char *); +size_t strxfrm (char *, constchar *, size_t); diff --git a/x64_dbg_gui/Project/Data/user32.txt b/x64_dbg_gui/Project/Data/user32.txt new file mode 100644 index 00000000..dac74ceb --- /dev/null +++ b/x64_dbg_gui/Project/Data/user32.txt @@ -0,0 +1,719 @@ +BOOL DestroyWindow(HWND hWnd); +BOOL EndDialog(HWND hDlg,int nResult); +BOOL EndPaint(HWND hWnd,const PAINTSTRUCT *lpPaint); +BOOL GetClientRect(HWND hWnd,LPRECT lpRect); +BOOL GetWindowRect(HWND hWnd,RECT * lpRect); +BOOL ShowWindow(HWND hWnd,int nCmdShow); +BOOL TranslateMessage(const MSG *lpMsg); +BOOL UpdateWindow(HWND hWnd); +COLORREF SetPixel(HDC,int,int,COLORREF); +HDC BeginPaint(HWND hWnd,PAINTSTRUCT *lpPaint); +HLOCAL LocalFree(HLOCAL hMem); +HMODULE GetModuleHandleA(LPCSTR lpModuleName); +int DrawTextA(HDC hDC,LPCSTR lpString,int nCount,LPRECT lpRect,UINT uFormat); +void PostQuitMessage(int nExitCode); +void GetStartupInfo(LPSTARTUPINFO lpStartupInfo); +void GetStartupInfoA(LPSTARTUPINFO lpStartupInfo); +void GetStartupInfoW(LPSTARTUPINFO lpStartupInfo); +int EditWndProc(DWORD hWnd,DWORD uMsg,DWORD wParam,DWORD lParam); +int ActivateKeyboardLayout(KeyboardLayoutHandle hkl,UINT Flags); +int AddClipboardFormatListener(HWND hwnd); +int AdjustWindowRect(LPRECT lpRect,DWORD dwWinStyle,BOOL bMenu); +int AdjustWindowRectEx(LPRECT lpRect,DWORD dwWinStyle,BOOL bMenu,DWORD dwEsStyle); +int AllowActivateDetachQueuesSetFocus(); +int AllowSetForegroundWindow(DWORD dwProcessId); +int AnimateWindow(HWND hWnd,DWORD dwTime,DWORD dwFlags); +int AnyPopup(); +int AppendMenu(HMENU hMenu,UINT uFlags,UINT_PTR uIDNewItem,LPCTSTR lpNewItem); +int AppendMenuA(HMENU hMenu,UINT wFlags,UINT_PTR wIDNewItem,LPCTSTR lpNewItem); +int AppendMenuW(HMENU hMenu,UINT wFlags,UINT_PTR wIDNewItem,LPCTSTR lpNewItem); +int ArrangeIconicWindows(HWND hwnd); +int AttachThreadInput(DWORD idAttach,DWORD idAttachTo,BOOL fAttach); +int BeginDeferWindowPos(int nNumWindows); +int BeginPaint(HWND hwnd,LPPAINTSTRUCT lpPaint); +int BlockInput(BOOL fBlockIt); +int BringWindowToTop(HWND hWnd); +int BroadcastSystemMessage(DWORD dwFlags,LPDWORD lpdwRecipients,UINT uiMessage,WPARAM wParam,LPARAM Param); +int BroadcastSystemMessageEx(DWORD dwFlags,LPDWORD lpdwRecipients,UINT uiMessage,WPARAM wParam,LPARAM lParam,PBSMINFO pBSMInfo); +int CalculatePopupWindowPosition(const POINT* anchorPoint,const SIZE* windowSize,UINT flags,RECT* excludeRect,RECT* popupWindowPosition); +int CallMsgFilter(LPMSG lpMsg,int nCode); +int CallNextHookEx(HHOOK hhk,int nCode,WPARAM wParam,LPARAM lParam); +int CallWindowProc(WNDPROC lpPrevWndFunc,HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam); +int CallWindowProcA(WNDPROC lpPrevWndFunc,HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam); +int CallWindowProcW(WNDPROC lpPrevWndFunc,HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam); +int CascadeWindows(HWND hwndParent,UINT wHow,const RECT* lpRect,UINT cKids,const HWND* lpKids); +int ChangeClipboardChain(HWND hWndRemove,HWND hWndNewNext); +int ChangeDisplaySettings(DEVMODE* lpDevMode,DWORD dwflags); +int ChangeDisplaySettingsEx(LPCTSTR lpszDeviceName,DEVMODE* lpDevMode,HWND hwnd,DWORD dwflags,LPVOID lParam); +int ChangeWindowMessageFilter(UINT message,DWORD dwFlag); +int ChangeWindowMessageFilterEx(HWND hWnd,UINT message,DWORD action,PCHANGEFILTERSTRUCT pChangeFilterStruct); +int CharLower(LPTSTR lpsz); +int CharLowerA(LPTSTR lpsz); +int CharLowerBuff(LPTSTR lpsz,DWORD cchLength); +int CharLowerBuffA(LPTSTR lpsz,DWORD cchLength); +int CharLowerBuffW(LPTSTR lpsz,DWORD cchLength); +int CharLowerW(LPTSTR lpsz); +int CharNext(LPCTSTR lpsz); +int CharNextA(LPCTSTR lpsz); +int CharNextExA(WORD CodePage,LPCSTR lpCurrentChar,DWORD dwFlags); +int CharNextW(LPCTSTR lpsz); +int CharPrev(LPCTSTR lpszStart,LPCTSTR lpszCurrent); +int CharPrevA(LPCTSTR lpszStart,LPCTSTR lpszCurrent); +int CharPrevExA(WORD CodePage,LPCSTR lpStart,LPCSTR lpCurrentChar,DWORD dwFlags); +int CharToOem(LPCTSTR lpszSrc,LPSTR lpszDst); +int CharToOemA(LPCTSTR lpszSrc,LPSTR lpszDst); +int CharToOemBuff(LPCTSTR lpszSrc,LPSTR lpszDst,DWORD cchDstLength); +int CharToOemW(LPCTSTR lpszSrc,LPSTR lpszDst); +int CharUpper(LPTSTR lpsz); +int CharUpperA(LPTSTR lpsz); +int CharUpperBuff(LPTSTR lpsz,DWORD cchLength); +int CharUpperBuffA(LPTSTR lpsz,DWORD cchLength); +int CharUpperBuffW(LPTSTR lpsz,DWORD cchLength); +int CharUpperW(LPTSTR lpsz); +int CheckDlgButton(HWND hDlg,int nIDButton,UINT uCheck); +int CheckMenuItem(HMENU hmenu,UINT uIDCheckItem,UINT uCheck); +int CheckMenuRadioItem(HMENU hmenu,UINT idFirst,UINT idLast,UINT idCheck,DWORD uFlags); +int CheckRadioButton(HWND hDlg,int nIDFirstButton,int nIDLastButton,int nIDCheckButton); +int ChildWindowFromPoint(HWND hWndParent,POINT Point); +int ChildWindowFromPointEx(HWND hwndParent,POINT pt,UINT uFlags); +int ClientToScreen(HWND hWnd,LPPOINT lpPoint); +int ClipCursor(const RECT* lpRect); +int CloseClipboard(); +int CloseDesktop(HDESK hDesktop); +int CloseGestureInfoHandle(HGESTUREINFO hGestureInfo); +int CloseTouchInputHandle(HTOUCHINPUT hTouchInput); +int CloseWindow(HWND hWnd); +int CloseWindowStation(HWINSTA hWinSta); +int CopyAcceleratorTable(HACCEL hAccelSrc,LPACCEL lpAccelDst,int cAccelEntries); +int CopyAcceleratorTableA(HACCEL hAccelSrc,LPACCEL IpAcceIDst,int cAccelEntries); +int CopyAcceleratorTableW(HACCEL hAccelSrc,LPACCEL IpAcceIDst,int cAccelEntries); +int CopyCursor(HCURSOR pcur); +int CopyIcon(HICON hIcon); +int CopyImage(HANDLE hImage,UINT uType,int cxDesired,int cyDesired,UINT fuFlags); +int CopyRect(LPRECT lprcDst,const RECT* lprcSrc); +int CountClipboardFormats(); +int CreateAcceleratorTable(LPACCEL lpaccl,int cEntries); +int CreateAcceleratorTableW(LPACCEL lpaccl,int cEntries); +int CreateCaret(HWND hWnd,HBITMAP hBitmap,int nWidth,int nHeight); +int CreateCursor(HINSTANCE hInst,int xHotSpot,int yHotSpot,int nWidth,int nHeight,const VOID* pvANDPlane,const VOID* pvXORPlane); +int CreateDesktop(LPCTSTR lpszDesktop,LPCTSTR lpszDevice,LPDEVMODE pDevmode,DWORD dwFlags,DWORD dwDesiredAccess,LPSECURITY_ATTRIBUTES lpsa); +int CreateDesktopEx(LPCTSTR lpszDesktop,LPCTSTR lpszDevice,LPDEVMODE pDevmode,DWORD dwFlags,DWORD dwDesiredAccess,LPSECURITY_ATTRIBUTES lpsa,ULONG ulHeapSize,PVOID pvoid); +int CreateDialogIndirectParam(HINSTANCE hInstance,LPCDLGTEMPLATE lpTemplate,HWND hWndParent,DLGPROC lpDialogFunc,LPARAM lParamInit); +int CreateDialogIndirectParamA(HINSTANCE hInstance,LPCDLGTEMPLATE lpTemplate,HWND hWndParent,DLGPROC lpDialogFun,LPARAM lParamInit); +int CreateDialogIndirectParamW(HINSTANCE hInstance,LPCDLGTEMPLATE lpTemplate,HWND hWndParent,DLGPROC lpDialogFun,LPARAM lParamInit); +int CreateDialogParam(HINSTANCE hInstance,LPCTSTR lpTemplateName,HWND hWndParent,DLGPROC lpDialogFunc,LPARAM lParamInit); +int CreateDialogParamA(HINSTANCE hInstance,LPCTSTR lpTemplateName,HWND hWndParent,DLGPROC lpDialogFunc,LPARAM dwInitParam); +int CreateDialogParamW(HINSTANCE hInstance,LPCTSTR lpTemplateName,HWND hWndParent,DLGPROC lpDialogFunc,LPARAM dwInitParam); +int CreateIcon(HINSTANCE hInstance,int nWidth,int Height,BYTE cPlanes,BYTE cBitsPixel,const BYTE* lpbANDbits,const BYTE* lpbXORbits); +int CreateIconFromResource(PBYTE presbits,DWORD dwResSize,BOOL fIcon,DWORD dwVersion); +int CreateIconFromResourceEx(PBYTE pbIconBits,DWORD cbIconBits,BOOL fIcon,DWORD dwVersion,int cxDesired,int cyDesired,UINT uFlags); +int CreateIconIndirect(PICONINFO piconinfo); +int CreateMDIWindow(LPCTSTR lpClassName,LPCTSTR lpWindowName,DWORD dwStyle,int X,int Y,int nWidth,int nHeight,HWND hWndParent,HINSTANCE hInstance,LPARAM lParam); +int CreateMDIWindowA(LPCTSTR lpClassName,LPCTSTR lpWindowName,DWORD dwStyle,int X,int Y,int nWidth,int nHeight,HWND hWndParent,HINSTANCE hInstance,LPARAM lParam); +int CreateMDIWindowW(LPCTSTR lpClassName,LPCTSTR lpWindowName,DWORD dwStyle,int X,int Y,int nWidth,int nHeight,HWND hWndParent,HINSTANCE hInstance,LPARAM lParam); +int CreateMenu(); +int CreatePopupMenu(); +int CreateWindow(LPCTSTR lpClassName,LPCTSTR lpWindowName,DWORD dwStyle,int x,int y,int nWidth,int nHeight,HWND hWndParent,HMENU hMenu,HINSTANCE hInstance,LPVOID lpParam); +HWND CreateWindowEx(DWORD dwExStyle,LPCSTR lpClassName,LPCSTR lpWindowName,DWORD dwStyle,int X,int Y,int nWidth,int nHeight,HWND hWndParent,HMENU hMenu,HINSTANCE hInstance,LPVOID lpParam); +HWND CreateWindowExA(DWORD dwExStyle,LPCSTR lpClassName,LPCSTR lpWindowName,DWORD dwStyle,int X,int Y,int nWidth,int nHeight,HWND hWndParent,HMENU hMenu,HINSTANCE hInstance,LPVOID lpParam); +HWND CreateWindowExW(DWORD dwExStyle,LPCWSTR lpClassName,LPCWSTR lpWindowName,DWORD dwStyle,int X,int Y,int nWidth,int nHeight,HWND hWndParent ,HMENU hMenu,HINSTANCE hInstance,LPVOID lpParam); +int CreateWindowStation(LPCTSTR lpwinsta,DWORD dwFlags,DWORD dwDesiredAccess,LPSECURITY_ATTRIBUTES lpsa); +int DdeAbandonTransaction(DWORD idInst,HCONV hConv,DWORD idTransaction); +int DdeAccessData(HDDEDATA hData,LPDWORD pcbDataSize); +int DdeAddData(HDDEDATA hData,LPBYTE pSrc,DWORD cb,DWORD cbOff); +int DdeClientTransaction(LPBYTE pData,DWORD cbData,HCONV hConv,HSZ hszItem,UINT wFmt,UINT wType,DWORD dwTimeout,LPDWORD pdwResult); +int DdeCmpStringHandles(HSZ hsz1,HSZ hsz2); +int DdeConnect(DWORD idInst,HSZ hszService,HSZ hszTopic,PCONVCONTEXT pCC); +int DdeConnectList(DWORD idInst,HSZ hszService,HSZ hszTopic,HCONVLIST hConvList,PCONVCONTEXT pCC); +int DdeCreateDataHandle(DWORD idInst,LPBYTE pSrc,DWORD cb,DWORD cbOff,HSZ hszItem,UINT wFmt,UINT afCmd); +int DdeCreateStringHandle(DWORD idInst,LPTSTR psz,int iCodePage); +int DdeDisconnect(HCONV hConv); +int DdeDisconnectList(HCONVLIST hConvList); +int DdeEnableCallback(DWORD idInst,HCONV hConv,UINT wCmd); +int DdeFreeDataHandle(HDDEDATA hData); +int DdeFreeStringHandle(DWORD idInst,HSZ hsz); +int DdeGetData(HDDEDATA hData,LPBYTE pDst,DWORD cbMax,DWORD cbOff); +int DdeGetLastError(DWORD idInst); +int DdeImpersonateClient(HCONV hConv); +int DdeInitialize(LPDWORD pidInst,PFNCALLBACK pfnCallback,DWORD afCmd,DWORD ulRes); +int DdeKeepStringHandle(DWORD idInst,HSZ hsz); +int DdeNameService(DWORD idInst,UINT hsz1,UINT hsz2,UINT afCmd); +int DdePostAdvise(DWORD idInst,HSZ hszTopic,HSZ hszItem); +int DdeQueryConvInfo(HCONV hConv,DWORD idTransaction,PCONVINFO pConvInfo); +int DdeQueryNextServer(HCONVLIST hConvList,HCONV hConvPrev); +int DdeQueryString(DWORD idInst,HSZ hsz,LPTSTR psz,DWORD cchMax,int iCodePage); +int DdeReconnect(HCONV hConv); +int DdeSetQualityOfService(HWND hwndClient,const SECURITY_QUALITY_OF_SERVICE* pqosNew,PSECURITY_QUALITY_OF_SERVICE pqosPrev); +int DdeSetUserHandle(HCONV hConv,DWORD id,DWORD_PTR hUser); +int DdeUnaccessData(HDDEDATA hData); +int DdeUninitialize(DWORD idInst); +int DefDlgProc(HWND hDlg,UINT Msg,WPARAM wParam,LPARAM lParam); +int DefDlgProcW(HWND hDlg,UINT Msg,WPARAM wParam,LPARAM lParam); +int DefFrameProc(HWND hWnd,HWND hWndMDIClient,UINT uMsg,WPARAM wParam,LPARAM lParam); +int DefFrameProcA(HWND hWnd,HWND hWndMDIClient,UINT uMsg,WPARAM wParam,LPARAM lParam); +int DefFrameProcW(HWND hWnd,HWND hWndMDIClient,UINT uMsg,WPARAM wParam,LPARAM lParam); +int DefMDIChildProc(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam); +int DefMDIChildProcA(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam); +int DefRawInputProc(PRAWINPUT* paRawInput,INT nInput,UINT cbSizeHeader); +LRESULT DefWindowProc(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam); +LRESULT DefWindowProcA(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam); +LRESULT DefWindowProcW(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam); +int DeferWindowPos(HDWP hWinPosInfo,HWND hWnd,HWND hWndInsertAfter,int x,int y,int cx,int cy,UINT uFlags); +int DeleteMenu(HMENU hMenu,UINT uPosition,UINT uFlags); +int DeregisterShellHookWindow(HWND hWnd); +int DestroyAcceleratorTable(HACCEL hAccel); +int DestroyCaret(); +int DestroyCursor(HCURSOR hCursor); +int DestroyIcon(HICON hIcon); +int DestroyMenu(HMENU hMenu); +int DestroyWindow(HWND hWnd); +int DialogBoxIndirectParam(HINSTANCE hInstance,LPCDLGTEMPLATE hDialogTemplate,HWND hWndParent,DLGPROC lpDialogFunc,LPARAM dwInitParam); +int DialogBoxIndirectParamA(HINSTANCE hInstance,LPCDLGTEMPLATE hDialogTemplate,HWND hWndParent,DLGPROC pDialogFunc,LPARAM dwInitParam); +int DialogBoxIndirectParamW(HINSTANCE hInstance,LPCDLGTEMPLATE hDialogTemplate,HWND hWndParent,DLGPROC pDialogFunc,LPARAM dwInitParam); +int DialogBoxParam(HINSTANCE hInstance,LPCTSTR lpTemplateName,HWND hWndParent,DLGPROC lpDialogFunc,LPARAM dwInitParam); +int DialogBoxParamA(HINSTANCE hInstance,LPCTSTR lpTemplateName,HWND hWnd,DLGPROC lpDialogFunc,LPARAM dwInitParam); +int DialogBoxParamW(HINSTANCE hInstance,LPCTSTR lpTemplateName,HWND hWnd,DLGPROC lpDialogFunc,LPARAM dwInitParam); +long DispatchMessage(const MSG *lpMsg); +long DispatchMessageA(const MSG *lpMsg); +long DispatchMessageW(const MSG *lpMsg); +int DlgDirList(HWND hDlg,LPTSTR lpPathSpec,int nIDListBox,int nIDStaticPath,UINT uFileType); +int DlgDirListComboBox(HWND hDlg,LPTSTR lpPathSpec,int nIDComboBox,int nIDStaticPath,UINT uFiletype); +int DlgDirSelectComboBoxEx(HWND hDlg,LPTSTR lpString,int nCount,int nIDComboBox); +int DlgDirSelectEx(HWND hDlg,LPTSTR lpString,int nCount,int nIDListBox); +int DragDetect(HWND hwnd,POINT pt); +int DrawAnimatedRects(HWND hWnd,int dAni,const RECT* lprcFrom,const RECT* lprcTo); +int DrawCaption(HWND hwnd,HDC hdc,LPCRECT lprc,UINT uFlags); +int DrawEdge(HDC hDC,LPRECT qrc,UINT edge,UINT grfFlags); +int DrawFocusRect(HDC hDC,const RECT* lprc); +int DrawFrameControl(HDC hDC,LPRECT lprc,UINT uType,UINT uState); +int DrawIcon(HDC hDC,int X,int Y,HICON hIcon); +int DrawIconEx(HDC hDC,int xLeft,int yTop,HICON hIcon,int cxWidth,int cyWidth,UINT istepIfAniCur,HBRUSH hbrFlickerFreeDraw,UINT diFlags); +int DrawMenuBar(HWND hWnd); +int DrawState(HDC hdc,HBRUSH hbr,DRAWSTATEPROC lpOutputFunc,LPARAM lData,WPARAM wData,int x,int y,int cx,int cy,UINT fuFlags); +int DrawStateA(HDC hDC,HBRUSH hbr,DRAWSTATEPROC lpOutputFunc,LPARAM lData,WPARAM wData,int X,int Y,int cx,int cy,UINT fuFlags); +int DrawStateW(HDC hDC,HBRUSH hbr,DRAWSTATEPROC lpOutputFunc,LPARAM lData,WPARAM wData,int X,int Y,int cx,int cy,UINT fuFlags); +int DrawText(HDC hDC,LPCTSTR lpchText,int nCount,LPRECT lpRect,UINT uFormat); +int DrawTextA(HDC hDC,LPCTSTR lpString,int nCount,LPRECT lpRect,UINT uFormat); +int DrawTextEx(HDC hdc,LPTSTR lpchText,int cchText,LPRECT lprc,UINT dwDTFormat,LPDRAWTEXTPARAMS lpDTParams); +int DrawTextExA(HDC hDC,LPTSTR lpchText,int cchText,LPRECT lprc,UINT dwDTFormat,LPDRAWTEXTPARAMS lpDTParams); +int DrawTextExW(HDC hDC,LPTSTR lpchText,int cchText,LPRECT lprc,UINT dwDTFormat,LPDRAWTEXTPARAMS lpDTParams); +int DrawTextW(HDC hDC,LPCTSTR lpString,int nCount,LPRECT lpRect,UINT uFormat); +int EmptyClipboard(); +int EnableMenuItem(HMENU hMenu,UINT uIDEnableItem,UINT uEnable); +int EnableScrollBar(HWND hWnd,UINT WSBflags,UINT wArrows); +int EnableWindow(HWND hWnd,BOOL bEnable); +int EndDeferWindowPos(HDWP hWinPosInfo); +int EndDialog(HWND hDlg,INT_PTR nResult); +int EndMenu(); +int EndPaint(HWND hWnd,const PAINTSTRUCT* lpPaint); +int EndTask(HWND hWnd,BOOL fShutDown,BOOL fForce); +int EnumChildWindows(HWND hWndParent,WNDENUMPROC lpEnumFunc,LPARAM lParam); +int EnumClipboardFormats(UINT format); +int EnumDesktopWindows(HDESK hDesktop,WNDENUMPROC lpfn,LPARAM lParam); +int EnumDesktops(HWINSTA hwinsta,DESKTOPENUMPROC lpEnumFunc,LPARAM lParam); +int EnumDisplayDevices(LPCTSTR lpReserved,DWORD iDeviceNum,PDISPLAY_DEVICE pDisplayDevice,DWORD dwFlags); +int EnumDisplayMonitors(DWORD hDesktop,DWORD lpfn,DWORD lParam); +int EnumDisplayMonitors(HDC hdc,LPCRECT lprcClip,MONITORENUMPROC lpfnEnum,LPARAM dwData); +int EnumDisplaySettings(LPCTSTR lpszDeviceName,int iModeNum,DEVMODE* lpDevMode); +int EnumDisplaySettingsA(LPCTSTR lpszDeviceName,int iModeNum,DEVMODE* lpDevMode); +int EnumDisplaySettingsEx(LPCTSTR lpszDeviceName,DWORD iModeNum,DEVMODE* lpDevMode,DWORD dwFlags); +int EnumProps(HWND hWnd,PROPENUMPROC lpEnumFunc); +int EnumPropsEx(HWND hWnd,PROPENUMPROCEX lpEnumFunc,LPARAM lParam); +int EnumThreadWindows(DWORD dwThreadId,WNDENUMPROC lpfn,LPARAM lParam); +int EnumWindowStations(WINSTAENUMPROC lpEnumFunc,LPARAM lParam); +int EnumWindows(WNDENUMPROC lpEnumFunc,LPARAM lParam); +int EqualRect(const RECT* lprc1,const RECT* lprc2); +int ExcludeUpdateRgn(HDC hDC,HWND hWnd); +int ExitWindowsEx(UINT uFlags,DWORD dwReserved); +int FillRect(HDC hDC,const RECT* lprc,HBRUSH hbr); +int FindWindow(LPCTSTR lpClassName,LPCTSTR lpWindowName); +int FindWindowA(LPCTSTR lpClassName,LPCTSTR lpWindowName); +int FindWindowEx(HWND hwndParent,HWND hwndChildAfter,LPCTSTR lpszClass,LPCTSTR lpszWindow); +int FindWindowExA(HWND hwndParent,HWND hwndChildAfter,LPCTSTR lpszClass,LPCTSTR pszWindow); +int FindWindowExW(HWND hwndParent,HWND hwndChildAfter,LPCTSTR lpszClass,LPCTSTR pszWindow); +int FindWindowW(LPCTSTR lpClassName,LPCTSTR lpWindowName); +int FlashWindow(HWND hWnd,BOOL bInvert); +int FlashWindowEx(PFLASHWINFO pfwi); +int FrameRect(HDC hDC,const RECT* lprc,HBRUSH hbr); +int FreeDDElParam(UINT msg,LPARAM lParam); +int GetActiveWindow(); +int GetAltTabInfo(HWND hwnd,int iItem,PALTTABINFO pati,LPTSTR pszItemText,UINT cchItemText); +int GetAncestor(HWND hwnd,DWORD gaFlags); +int GetAsyncKeyState(int vKey); +int GetCapture(); +int GetCaretBlinkTime(); +int GetCaretPos(LPPOINT lpPoint); +int GetClassInfo(HINSTANCE hInstance,LPCTSTR lpClassName,LPWNDCLASS lpWndClass); +int GetClassInfoA(HINSTANCE hInstance,LPCTSTR lpClassName,LPWNDCLASS lpWndClass); +int GetClassInfoEx(HINSTANCE hinst,LPCTSTR lpszClass,LPWNDCLASSEX lpwcx); +int GetClassInfoExA(HINSTANCE hinst,LPCTSTR lpszClass,LPWNDCLASSEX lpwcx); +int GetClassInfoExW(HINSTANCE hinst,LPCTSTR lpszClass,LPWNDCLASSEX lpwcx); +int GetClassInfoW(HINSTANCE hInstance,LPCTSTR lpClassName,LPWNDCLASS lpWndClass); +int GetClassLong(HWND hWnd,int nIndex); +int GetClassLongA(HWND hWnd,int nIndex); +int GetClassLongW(HWND hWnd,int nIndex); +int GetClassName(HWND hWnd,LPTSTR lpClassName,int nMaxCount); +int GetClassNameA(HWND hWnd,LPTSTR lpBuffer,int nBufferSize); +int GetClassNameW(HWND hWnd,LPTSTR lpBuffer,int nBufferSize); +int GetClassWord(HWND hWnd,int nIndex); +int GetClientRect(HWND hWnd,LPRECT lpRect); +int GetClipCursor(LPRECT lpRect); +int GetClipboardData(UINT uFormat); +int GetClipboardFormatName(UINT format,LPTSTR lpszFormatName,int cchMaxCount); +int GetClipboardFormatNameA(UINT format,LPTSTR lpBuffer,int cchMaxCount); +int GetClipboardOwner(); +int GetClipboardSequenceNumber(); +int GetClipboardViewer(); +int GetComboBoxInfo(HWND hWndCombo,PCOMBOBOXINFO pcbi); +int GetCursor(); +int GetCursorInfo(PCURSORINFO pci); +int GetCursorPos(LPPOINT lpPoint); +int GetDC(HWND hwnd); +int GetDCEx(HWND hWnd,HRGN hrgnClip,UINT flags); +HWND GetDesktopWindow(); +int GetDialogBaseUnits(); +int GetDlgCtrlID(HWND hwndCtl); +int GetDlgItem(HWND hDlg,int nIDDlgItem); +int GetDlgItemInt(HWND hDlg,int nIDDlgItem,BOOL* lpTranslated,BOOL bSigned); +int GetDlgItemText(HWND hDlg,int nIDDlgItem,LPTSTR lpString,int nMaxCount); +int GetDlgItemTextA(HWND hDlg,int nIDDlgItem,LPTSTR lpBuffer,int nBufferSize); +int GetDlgItemTextW(HWND hDlg,int nIDDlgItem,LPTSTR lpBuffer,int nBufferSize); +int GetDoubleClickTime(); +int GetFocus(); +int GetForegroundWindow(); +int GetGUIThreadInfo(DWORD idThread,LPGUITHREADINFO lpgui); +int GetGestureConfig(HWND hwnd,DWORD dwReserved,DWORD dwFlags,PUINT pcIDs,PGESTURECONFIG pGestureConfig,UINT cbSize); +int GetGestureExtraArgs(HGESTUREINFO hGestureInfo,UINT cbExtraArgs,PBYTE pExtraArgs); +int GetGestureInfo(HGESTUREINFO hGestureInfo,PGESTUREINFO pGestureInfo); +int GetGuiResources(HANDLE hProcess,DWORD uiFlags); +int GetIconInfo(HICON hIcon,PICONINFO piconinfo); +int GetIconInfoEx(HICON hIcon,PICONINFOEX piconinfoex); +int GetInputState(); +int GetKBCodePage(); +int GetKeyNameText(LONG lParam,LPTSTR lpString,int nSize); +int GetKeyNameTextA(LONG lParam,LPTSTR lpString,int nSize); +int GetKeyNameTextW(LONG lParam,LPTSTR lpString,int nSize); +int GetKeyState(int nVirtKey); +int GetKeyboardLayout(DWORD dwLayout); +int GetKeyboardLayoutList(int nBuff,HKL* lpList); +int GetKeyboardLayoutName(LPTSTR pwszKLID); +int GetKeyboardLayoutNameA(LPTSTR pwszKLID); +int GetKeyboardLayoutNameW(LPTSTR pwszKLID); +int GetKeyboardState(PBYTE lpKeyState); +int GetKeyboardType(int nTypeFlag); +int GetLastActivePopup(HWND hWnd); +int GetLastInputInfo(PLASTINPUTINFO plii); +int GetLayeredWindowAttributes(HWND hwnd,COLORREF* pcrKey,BYTE* pbAlpha,DWORD pdwFlags); +int GetListBoxInfo(HWND hwnd); +int GetMenu(HWND hWnd); +int GetMenuBarInfo(HWND hwnd,UINT idObject,LONG idItem,PMENUBARINFO pmbi); +int GetMenuCheckMarkDimensions(); +int GetMenuContextHelpId(HMENU hmenu); +int GetMenuDefaultItem(HMENU hMenu,UINT fByPos,UINT gmdiFlags); +int GetMenuInfo(HMENU hMenu,LPCMENUINFO lpcMenuInfo); +int GetMenuItemCount(HMENU hMenu); +int GetMenuItemID(HMENU hMenu,int nPos); +int GetMenuItemInfo(HMENU hMenu,UINT uItem,BOOL fByPosition,LPMENUITEMINFO lpmii); +int GetMenuItemInfoA(HMENU hMenu,UINT uItem,BOOL fByPosition,LPMENUITEMINFO lpmii); +int GetMenuItemInfoW(HMENU hMenu,UINT uItem,BOOL fByPosition,LPMENUITEMINFO lpmii); +int GetMenuItemRect(HWND hWnd,HMENU hMenu,UINT uItem,LPRECT lprcItem); +int GetMenuState(HMENU hMenu,UINT uId,UINT uFlags); +int GetMenuString(HMENU hMenu,UINT uIDItem,LPTSTR lpString,int nMaxCount,UINT uFlag); +int GetMenuStringA(HMENU hMenu,UINT uIDItem,LPTSTR lpBuffer,int nBufferSize,UINT uFlag); +int GetMenuStringW(HMENU hMenu,UINT uIDItem,LPTSTR lpBuffer,int nBufferSize,UINT uFlag); +bool GetMessage(LPMSG lpMsg,HWND hWnd,UINT wMsgFilterMin,UINT wMsgFilterMax); +BOOL GetMessageA(LPMSG lpMsg,HWND hWnd,UINT wMsgFilterMin,UINT wMsgFilterMax); +int GetMessageExtraInfo(); +int GetMessagePos(); +int GetMessageTime(); +BOOL GetMessageW(LPMSG lpMsg,HWND hWnd,UINT wMsgFilterMin,UINT wMsgFilterMax); +int GetMonitorInfo(HMONITOR hMonitor,LPMONITORINFO lpmi); +int GetMonitorInfoW(HMONITOR hMonitor,LPMONITORINFO lpMonitorIfno); +int GetMouseMovePointsEx(UINT cbSize,LPMOUSEMOVEPOINT lppt,LPMOUSEMOVEPOINT lpptBuf,int nBufPoints,DWORD resolution); +int GetNextDlgGroupItem(HWND hDlg,HWND hCtl,BOOL bPrevious); +int GetNextDlgTabItem(HWND hDlg,HWND hCtl,BOOL bPrevious); +int GetOpenClipboardWindow(); +int GetParent(HWND hWnd); +int GetPhysicalCursorPos(LPPOINT lpPoint); +int GetPriorityClipboardFormat(UINT* paFormatPriorityList,int cFormats); +int GetProcessDefaultLayout(DWORD* pdwDefaultLayout); +int GetProcessWindowStation(); +int GetProp(HWND hWnd,LPCTSTR lpString); +int GetPropA(HWND hWnd,LPCTSTR lpString); +int GetPropW(HWND hWnd,LPCTSTR lpString); +int GetQueueStatus(DWORD flags); +int GetRawInputBuffer(PRAWINPUT pData,PUINT pcbSize,UINT cbSizeHeader); +int GetRawInputData(HRAWINPUT hRawInput,UINT uiCommand,LPVOID pData,PUINT pcbSize,UINT cbSizeHeader); +int GetRawInputDeviceInfo(HANDLE hDevice,UINT uiCommand,LPVOID pData,PUINT pcbSize); +int GetRawInputDeviceList(PRAWINPUTDEVICELIST pRawInputDeviceList,PUINT puiNumDevices,UINT cbSize); +int GetRegisteredRawInputDevices(PRAWINPUTDEVICE pRawInputDevices,PUINT puiNumDevices,UINT cbSize); +int GetScrollBarInfo(HWND hWnd,UINT fnBar,PSCROLLBARINFO lpsi); +int GetScrollInfo(HWND hWnd,int fnBar,LPSCROLLINFO lpScorllInfo); +int GetScrollPos(HWND hWnd,int nBar); +int GetScrollRange(HWND hWnd,int nBar,LPINT lpMinPos,LPINT lpMaxPos); +int GetShellWindow(); +int GetSubMenu(HMENU hMenu,int nPos); +int GetSysColor(int nIndex); +int GetSysColorBrush(int nIndex); +int GetSystemMenu(HWND hWnd,BOOL bRevert); +int GetSystemMetrics(int nIndex); +int GetTabbedTextExtent(HDC hDC,LPCTSTR lpString,int nCount,int nTabPositions,const LPINT lpnTabStopPositions); +int GetTabbedTextExtentA(HDC hDC,LPCTSTR lpString,int nCount,int nTabPositions,const LPINT lpnTabStopPositions); +int GetTabbedTextExtentW(HDC hDC,LPCTSTR lpString,int nCount,int nTabPositions,const LPINT lpnTabStopPositions); +int GetThreadDesktop(DWORD dwThreadId); +int GetTitleBarInfo(HWND hwnd,PTITLEBARINFO pti); +int GetTopWindow(HWND hWnd); +int GetTouchInputInfo(HTOUCHINPUT hTouchInput,UINT cInputs,PTOUCHINPUT pInputs,int cbSize); +int GetUpdateRect(HWND hWnd,LPRECT lpRect,BOOL bErase); +int GetUpdateRgn(HWND hWnd,HRGN hRgn,BOOL bErase); +int GetUpdatedClipboardFormats(PUINT lpuiFormats,UINT cFormats,PUINT pcFormatsOut); +int GetUserObjectInformation(HANDLE hObj,UINT nIndex,PVOID pvInfo,DWORD nLength,LPDWORD lpnLengthNeeded); +int GetUserObjectInformationA(HANDLE hActiveDesktop,UINT nIndex,PVOID pvInfo,DWORD nBuffLen,LPDWORD dwSize); +int GetUserObjectSecurity(HANDLE hObj,PSECURITY_INFORMATION pSIRequested,PSECURITY_DESCRIPTOR pSD,DWORD nLength,LPDWORD lpnLengthNeeded); +int GetWindow(HWND hWnd,UINT uCmd); +int GetWindowContextHelpId(HWND hWnd); +int GetWindowDC(HWND hWnd); +int GetWindowDisplayAffinity(HWND hWnd,DWORD* dwAffinity); +int GetWindowInfo(HWND hwnd,PWINDOWINFO pwi); +int GetWindowLong(HWND hWnd,int nIndex); +int GetWindowLongA(HWND hWnd,int nIndex); +int GetWindowLongW(HWND hWnd,int nIndex); +int GetWindowModuleFileName(HWND hwnd,LPTSTR lpszFileName,UINT cchFileNameMax); +int GetWindowPlacement(HWND hWnd,WINDOWPLACEMENT* lpwndpl); +int GetWindowRect(HWND hWnd,LPRECT lpRect); +int GetWindowRgn(HWND hWnd,HRGN hRgn); +int GetWindowRgnBox(HWND hWnd,LPRECT lprc); +int GetWindowText(HWND hWnd,LPTSTR lpString,int nMaxCount); +int GetWindowTextA(HWND hWnd,LPTSTR lpString,int nMaxCount); +int GetWindowTextLength(HWND hWnd); +int GetWindowTextLengthA(HWND hWnd); +int GetWindowTextLengthW(HWND hWnd); +int GetWindowTextW(HWND hWnd,LPTSTR lpString,int nMaxCount); +int GetWindowThreadProcessId(HWND hWnd,LPDWORD lpdwProcessId); +int GrayString(HDC hDC,HBRUSH hBrush,GRAYSTRINGPROC lpOutputFunc,LPARAM lpData,int nCount,int X,int Y,int nWidth,int nHeight); +int GrayStringA(HDC hDC,HBRUSH hBrush,GRAYSTRINGPROC lpOutputFunc,LPARAM lpData,int nCount,int X,int Y,int nWidth,int nHeight); +int GrayStringW(HDC hDC,HBRUSH hBrush,GRAYSTRINGPROC lpOutputFunc,LPARAM lpData,int nCount,int X,int Y,int nWidth,int nHeight); +int HideCaret(HWND hWnd); +int HiliteMenuItem(HWND hwnd,HMENU hmenu,UINT uItemHilite,UINT uHilite); +int ImpersonateDdeClientWindow(HWND hWndClient,HWND hWndServer); +int InSendMessage(); +int InSendMessageEx(LPVOID lpReserved); +int InflateRect(LPRECT lpRect,int x,int y); +int InsertMenu(HMENU hMenu,UINT uPosition,UINT uFlags,UINT_PTR uIDNewItem,LPCTSTR lpNewItem); +int InsertMenuA(HMENU hMenu,UINT nPosition,UINT wFlags,UINT_PTR wIDNewItem,LPCTSTR lpNewItem); +int InsertMenuItem(HMENU hMenu,UINT uItem,BOOL fByPosition,LPCMENUITEMINFO lpmii); +int InsertMenuItemA(HMENU hMenu,UINT uItem,BOOL fByPosition,LPCMENUITEMINFO lpmii); +int InsertMenuItemW(HMENU hMenu,UINT uItem,BOOL fByPosition,LPCMENUITEMINFO lpmii); +int InsertMenuW(HMENU hMenu,UINT nPosition,UINT wFlags,UINT_PTR wIDNewItem,LPCTSTR lpNewItem); +int InternalGetWindowText(HWND hWnd,LPWSTR lpString,int nMaxCount); +int IntersectRect(LPRECT lprcDst,const RECT* lprcSrc1,const RECT* lprcSrc2); +int InvalidateRect(HWND hWnd,const RECT* lpRect,BOOL bErase); +int InvalidateRgn(HWND hWnd,HRGN hRgn,BOOL bErase); +int InvertRect(HDC hDC,const RECT* lprc); +int IsCharAlpha(TCHAR ch); +int IsCharAlphaNumeric(TCHAR ch); +int IsCharAlphaNumericA(TCHAR char); +int IsCharAlphaNumericW(TCHAR char); +int IsCharLower(TCHAR ch); +int IsCharLowerA(TCHAR char); +int IsCharUpper(TCHAR ch); +int IsChild(HWND hWndParent,HWND hWnd); +int IsClipboardFormatAvailable(UINT format); +BOOL IsDialogMessage(HWND hDlg,LPMSG lpMsg); +BOOL IsDialogMessageA(HWND hDlg,LPMSG lpMsg); +BOOL IsDialogMessageW(HWND hDlg,LPMSG lpMsg); +int IsDlgButtonChecked(HWND hDlg,int nIDButton); +int IsGUIThread(BOOL bConvert); +int IsHungAppWindow(HWND hWnd); +int IsIconic(HWND hWnd); +int IsMenu(HMENU hMenu); +int IsProcessDPIAware(); +int IsRectEmpty(const RECT* lprc); +int IsTouchWindow(HWND hWnd,PULONG pulFlags); +int IsWinEventHookInstalled(DWORD event); +int IsWindow(HWND hWnd); +int IsWindowEnabled(HWND hWnd); +int IsWindowUnicode(HWND hWnd); +int IsWindowVisible(HWND hWnd); +int IsWow64Message(); +int IsZoomed(HWND hWnd); +int KillTimer(HWND hWnd,UINT_PTR nIDEvent); +HACCEL LoadAccelerators(HINSTANCE hInstance,LPCSTR lpTableName); +HACCEL LoadAcceleratorsA(HINSTANCE hInstance,LPCSTR lpTableName); +HACCEL LoadAcceleratorsW(HINSTANCE hInstance,LPCWSTR lpTableName); +int LoadBitmap(HINSTANCE hInstance,LPCTSTR lpBitmapName); +int LoadBitmapA(HINSTANCE hInstance,LPCTSTR lpBitmapName); +int LoadBitmapW(HINSTANCE hInstance,LPCTSTR lpBitmapName); +HCURSOR LoadCursor(HINSTANCE hInstance,LPCTSTR lpCursorName); +HCURSOR LoadCursorA(HINSTANCE hInstance,LPCTSTR lpCursorName); +int LoadCursorFromFile(LPCTSTR lpFileName); +int LoadCursorFromFileA(LPCTSTR lpFileName); +int LoadCursorFromFileW(LPCTSTR lpFileName); +HCURSOR LoadCursorW(HINSTANCE hInstance,LPCTSTR lpCursorName); +HICON LoadIcon(HINSTANCE hInstance,LPCSTR lpIconName); +HICON LoadIconA(HINSTANCE hInstance,LPCSTR lpIconName); +HICON LoadIconW(HINSTANCE hInstance,LPCSTR lpIconName); +int LoadImage(HINSTANCE hinst,LPCTSTR lpszName,UINT uType,int cxDesired,int cyDesired,UINT fuLoad); +int LoadImageA(HINSTANCE hinst,LPCTSTR lpszName,UINT uType,int Width,int Height,UINT Options); +int LoadImageW(HINSTANCE hinst,LPCTSTR lpszName,UINT uType,int Width,int Height,UINT Options); +int LoadKeyboardLayout(LPCTSTR pwszKLID,UINT Flags); +int LoadKeyboardLayoutA(LPCTSTR lpwszKLID,UINT Flags); +int LoadKeyboardLayoutW(LPCTSTR lpwszKLID,UINT Flags); +int LoadMenu(HINSTANCE hInstance,LPCTSTR lpMenuName); +int LoadMenuA(HINSTANCE hInstance,LPCTSTR lpMenuName); +int LoadMenuIndirect(CONST MENUTEMPLATE* lpMenuTemplate); +int LoadMenuIndirectA(CONST MENUTEMPLATE* lpMenuTemplate); +int LoadMenuIndirectW(CONST MENUTEMPLATE* lpMenuTemplate); +int LoadMenuW(HINSTANCE hInstance,LPCTSTR lpMenuName); +int LoadString(HINSTANCE hInstance,UINT uID,LPTSTR lpBuffer,int nBufferMax); +int LoadStringA(HINSTANCE hInstance,UINT uID,LPTSTR lpBuffer,int nBufferMax); +int LoadStringW(HINSTANCE hInstance,UINT uID,LPTSTR lpBuffer,int nBufferMax); +int LockSetForegroundWindow(UINT uLockCode); +int LockWindowUpdate(HWND hWndLock); +int LockWorkStation(); +int LogicalToPhysicalPoint(HWND hWnd,LPPOINT lpPoint); +int LookupIconIdFromDirectory(PBYTE presbits,BOOL fIcon); +int LookupIconIdFromDirectoryEx(PBYTE presbits,BOOL fIcon,int cxDesired,int cyDesired,UINT Flags); +int MapDialogRect(HWND hDlg,LPRECT IpRect); +int MapVirtualKey(UINT uCode,UINT uMapType); +int MapVirtualKeyA(UINT uCode,UINT uMapType); +int MapVirtualKeyEx(UINT uCode,UINT uMapType,HKL dwhkl); +int MapVirtualKeyExA(UINT uCode,UINT uMapType,HKL dwhkl); +int MapVirtualKeyExW(UINT uCode,UINT uMapType,HKL dwhkl); +int MapVirtualKeyW(UINT uCode,UINT uMapType); +int MapWindowPoints(HWND hWndFrom,HWND hWndTo,LPPOINT lpPoints,UINT cPoints); +int MenuItemFromPoint(HWND hWnd,HMENU hMenu,POINT ptScreen); +int MessageBeep(UINT uType); +int MessageBox(HWND hWnd,LPCTSTR lpText,LPCTSTR lpCaption,UINT uType); +int MessageBoxA(HWND hWnd,LPCTSTR lpText,LPCTSTR lpCaption,UINT uType); +int MessageBoxEx(HWND hWnd,LPCTSTR lpText,LPCTSTR lpCaption,UINT uType,WORD wLanguageId); +int MessageBoxExA(HWND hWnd,LPCTSTR lpText,LPCTSTR lpCaption,UINT uType,WORD wLanguageId); +int MessageBoxExW(HWND hWnd,LPCTSTR lpText,LPCTSTR lpCaption,UINT uType,WORD wLanguageId); +int MessageBoxIndirect(const LPMSGBOXPARAMS lpMsgBoxParams); +int MessageBoxIndirectA(const LPMSGBOXPARAMS lpMsgBoxParams); +int MessageBoxIndirectW(const LPMSGBOXPARAMS lpMsgBoxParamsW); +int MessageBoxTimeout(HWND hWnd,LPCTSTR lpText,LPCTSTR lpCaption,UINT uType,WORD wLanguageId,DWORD dwMilliseconds); +int MessageBoxW(HWND hWnd,LPCTSTR lpText,LPCTSTR lpCaption,UINT uType); +int ModifyMenu(HMENU hMnu,UINT uPosition,UINT uFlags,UINT_PTR uIDNewItem,LPCTSTR lpNewItem); +int ModifyMenuA(HMENU hMenu,UINT uPosition,UINT uFlags,UINT_PTR uIDNewItem,LPCTSTR lpNewItem); +int ModifyMenuW(HMENU hMenu,UINT uPosition,UINT uFlags,UINT_PTR uIDNewItem,LPCTSTR lpNewItem); +int MonitorFromPoint(POINT pt,DWORD dwFlags); +int MonitorFromRect(LPCRECT lprc,DWORD dwFlags); +int MonitorFromWindow(DWORD hWnd,DWORD dwFlags); +int MonitorFromWindow(HWND hwnd,DWORD dwFlags); +int MoveWindow(HWND hWnd,int X,int Y,int nWidth,int nHeight,BOOL bRepaint); +int MsgWaitForMultipleObjects(DWORD nCount,const HANDLE* pHandles,BOOL fWaitAll,DWORD dwMilliseconds,DWORD dwWakeMask); +int MsgWaitForMultipleObjectsEx(DWORD nCount,const HANDLE* pHandles,DWORD dwMilliseconds,DWORD dwWakeMask,DWORD dwFlags); +int NotifyWinEvent(DWORD event,HWND hwnd,LONG idObject,LONG idChild); +int OemKeyScan(WORD wOemChar); +int OemToChar(LPCSTR lpszSrc,LPTSTR lpszDst); +int OemToCharA(LPCSTR lpszSrc,LPTSTR lpszDst); +int OemToCharBuff(LPCTSTR lpszSrc,LPTSTR lpszDst,DWORD cchDstLength); +int OemToCharBuffA(LPCTSTR lpszSrc,LPTSTR lpszDst,DWORD cchDstLength); +int OemToCharBuffW(LPCTSTR lpszSrc,LPTSTR lpszDst,DWORD cchDstLength); +int OemToCharW(LPCSTR lpszSrc,LPTSTR lpszDst); +int OffsetRect(LPRECT lprc,int dx,int dy); +int OpenClipboard(HWND hWndNewOwner); +int OpenDesktop(LPTSTR lpszDesktop,DWORD dwFlags,BOOL fInherit,DWORD dwDesiredAccess); +int OpenIcon(HWND hWnd); +int OpenInputDesktop(DWORD dwFlags,BOOL fInherit,DWORD dwDesiredAccess); +int OpenWindowStation(LPTSTR lpszWinSta,BOOL fInherit,DWORD dwDesiredAccess); +int PackDDElParam(UINT msg,UINT_PTR uiLo,UINT_PTR uiHi); +int PaintDesktop(HDC hDC); +int PeekMessage(LPMSG lpMsg,HWND hWnd,UINT wMsgFilterMin,UINT wMsgFilterMax,UINT wRemoveMsg); +int PeekMessageA(LPMSG lpMsg,HWND hWnd,UINT wMsgFilterMin,UINT wMsgFilterMax,UINT wRemoveMsg); +int PeekMessageW(LPMSG lpMsg,HWND hWnd,UINT wMsgFilterMin,UINT wMsgFilterMax,UINT wRemoveMsg); +int PhysicalToLogicalPoint(HWND hWnd,LPPOINT lpPoint); +int PostMessage(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam); +int PostMessageA(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM Param); +int PostMessageW(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM Param); +int PostQuitMessage(int nExitCode); +int PostThreadMessage(DWORD idThread,UINT Msg,WPARAM wParam,LPARAM lParam); +int PostThreadMessageA(DWORD idThread,UINT Msg,WPARAM wParam,LPARAM lParam); +int PostThreadMessageW(DWORD idThread,UINT Msg,WPARAM wParam,LPARAM lParam); +int PrintWindow(HWND hwnd,HDC hdcBlt,UINT nFlags); +int PrivateExtractIcons(LPCTSTR lpszFile,int nIconIndex,int cxIcon,int cyIcon,HICON* phicon,UINT* piconid,UINT nIcons,UINT flags); +int PtInRect(const RECT* lprc,POINT pt); +int RealChildWindowFromPoint(HWND hwndParent,POINT ptParentClientCoords); +int RealGetWindowClass(HWND hwnd,LPTSTR pszType,UINT cchType); +int RedrawWindow(HWND hWnd,const RECT* lprcUpdate,HRGN hrgnUpdate,UINT flags); +ATOM RegisterClass(CONST WNDCLASS* lpWndClass); +ATOM RegisterClassA(CONST WNDCLASS* lpWndClass); +ATOM RegisterClassW(const WNDCLASS* lpWndClass); +ATOM RegisterClassEx(CONST WNDCLASSEX* lpwcx); +ATOM RegisterClassExA(CONST WNDCLASSEX* lpWndClassEx); +ATOM RegisterClassExW(CONST WNDCLASSEX* lpWndClassEx); +int RegisterClassW(CONST WNDCLASS* lpWndClass); +int RegisterClipboardFormat(LPCTSTR lpszFormat); +int RegisterClipboardFormatA(LPCTSTR lpszFormat); +int RegisterClipboardFormatW(LPCTSTR lpszFormat); +int RegisterDeviceNotification(HANDLE hRecipient,LPVOID NotificationFilter,UINT Flags); +int RegisterHotKey(HWND hWnd,int id,UINT fsModifiers,UINT vk); +int RegisterPowerSettingNotification(HANDLE hRecipient,LPCGUID PowerSettingGuid,UINT Flags); +int RegisterRawInputDevices(PCRAWINPUTDEVICE pRawInputDevices,UINT uiNumDevices,UINT cbSize); +int RegisterShellHookWindow(HWND hWnd); +int RegisterTouchWindow(HWND hWnd,ULONG ulFlags); +int RegisterWindowMessage(LPCTSTR lpString); +int RegisterWindowMessageA(LPCTSTR lpString); +int RegisterWindowMessageW(LPCTSTR lpString); +int ReleaseCapture(); +int ReleaseDC(HWND hWnd,HDC hDC); +int RemoveClipboardFormatListener(HWND hwnd); +int RemoveMenu(HMENU hMenu,UINT uPosition,UINT uFlags); +int RemoveProp(HWND hWnd,LPCTSTR lpString); +int RemovePropA(HWND hWnd,LPCTSTR lpString); +int RemovePropW(HWND hWnd,LPCTSTR lpString); +int ReplyMessage(LRESULT lResult); +int ReuseDDElParam(LPARAM lParam,UINT msgIn,UINT msgOut,UINT_PTR uiLo,UINT_PTR uiHi); +int ScreenToClient(HWND hWnd,LPPOINT lpPoint); +int ScrollDC(HDC hDC,int dx,int dy,const RECT* lprcScroll,const RECT* lprcClip,HRGN hrgnUpdate,LPRECT lprcUpdate); +int ScrollWindow(HWND hWnd,int XAmount,int YAmount,const RECT* lpRect,const RECT* lpClipRect); +int ScrollWindowEx(HWND hWnd,int dx,int dy,const RECT* prcScroll,const RECT* prcClip,HRGN hrgnUpdate,LPRECT prcUpdate,UINT flags); +int SendDlgItemMessage(HWND hDlg,int nIDDlgItem,UINT Msg,WPARAM wParam,LPARAM lParam); +int SendDlgItemMessageA(HWND hDlg,int nIDDlgItem,UINT Msg,WPARAM wParam,LPARAM lParam); +int SendInput(UINT nInputs,LPINPUT pInputs,int cbSize); +int SendMessage(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam); +int SendMessageA(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM Param); +int SendMessageCallback(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam,SENDASYNCPROC lpCallBack,ULONG_PTR dwData); +int SendMessageCallbackA(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam,SENDASYNCPROC lpResultCallBack,ULONG_PTR dwData); +int SendMessageCallbackW(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam,SENDASYNCPROC lpResultCallBack,ULONG_PTR dwData); +int SendMessageTimeout(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam,UINT fuFlags,UINT uTimeout,PDWORD_PTR lpdwResult); +int SendMessageTimeoutA(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam,UINT fuFlags,UINT uTimeout,PDWORD_PTR lpdwResult); +int SendMessageTimeoutW(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam,UINT fuFlags,UINT uTimeout,PDWORD_PTR lpdwResult); +int SendMessageW(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM Param); +int SendNotifyMessage(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam); +int SendNotifyMessageA(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam); +int SendNotifyMessageW(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam); +int SetActiveWindow(HWND hWnd); +int SetCapture(HWND hWnd); +int SetCaretBlinkTime(UINT uMSeconds); +int SetCaretPos(int X,int Y); +int SetClassLong(HWND hWnd,int nIndex,LONG dwNewLong); +int SetClassLongA(HWND hWnd,int nIndex,LONG dwNewLong); +int SetClassLongW(HWND hWnd,int nIndex,LONG dwNewLong); +int SetClassWord(HWND hWnd,int nIndex,WORD wNewWord); +int SetClipboardData(UINT uFormat,HANDLE hMem); +int SetClipboardViewer(HWND hWndNewViewer); +int SetCursor(HCURSOR hCursor); +int SetCursorPos(int X,int Y); +int SetDlgItemInt(HWND hDlg,int nIDDlgItem,UINT uValue,BOOL bSigned); +int SetDlgItemText(HWND hDlg,int nIDDlgItem,LPCTSTR lpString); +int SetDlgItemTextA(HWND hDlg,int nIDDlgItem,LPCTSTR lpString); +int SetDlgItemTextW(HWND hDlg,int nIDDlgItem,LPCTSTR lpString); +int SetDoubleClickTime(UINT uInterval); +int SetFocus(HWND hWnd); +int SetForegroundWindow(HWND hWnd); +int SetGestureConfig(HWND hwnd,DWORD dwReserved,UINT cIDs,PGESTURECONFIG pGestureConfig,UINT cbSize); +int SetKeyboardState(LPBYTE lpKeyState); +int SetLastErrorEx(DWORD dwErrCode,DWORD dwType); +int SetLayeredWindowAttributes(HWND hWnd,COLORREF crKey,BYTE bAlpha,DWORD dwFlags); +int SetMenu(HWND hWnd,HMENU hMenu); +int SetMenuContextHelpId(HMENU hmenu,DWORD dwContextHelpId); +int SetMenuDefaultItem(HMENU hMenu,UINT uItem,UINT fByPos); +int SetMenuInfo(HMENU hmenu,LPCMENUINFO lpcmi); +int SetMenuItemBitmaps(HMENU hMenu,UINT uPosition,UINT uFlags,HBITMAP hBitmapUnchecked,HBITMAP hBitmapChecked); +int SetMenuItemInfo(HMENU hMenu,UINT uItem,BOOL fByPosition,LPMENUITEMINFO lpmii); +int SetMenuItemInfoA(HMENU hMenu,UINT uItem,BOOL fByPosition,LPMENUITEMINFO lpmii); +int SetMenuItemInfoW(HMENU hMenu,UINT uItem,BOOL fByPosition,LPMENUITEMINFO lpmii); +int SetMessageExtraInfo(LPARAM lParam); +int SetParent(HWND hWndChild,HWND hWndNewParent); +int SetPhysicalCursorPos(int X,int Y); +int SetProcessDPIAware(); +int SetProcessDefaultLayout(DWORD dwDefaultLayout); +int SetProcessWindowStation(HWINSTA hWinSta); +int SetProp(HWND hWnd,LPCTSTR lpString,HANDLE hData); +int SetPropA(HWND hWnd,LPCTSTR lpString,HANDLE hData); +int SetPropW(HWND hWnd,LPCTSTR lpString,HANDLE hData); +int SetRect(LPRECT lprc,int xLeft,int yTop,int xRight,int yBottom); +int SetRectEmpty(LPRECT lprc); +int SetScrollInfo(HWND hWnd,int fnBar,LPCSCROLLINFO lpsi,BOOL fRedraw); +int SetScrollPos(HWND hWnd,int nBar,int nPos,BOOL bRedraw); +int SetScrollRange(HWND hWnd,int nBar,int nMinPos,int nMaxPos,BOOL bRedraw); +int SetSysColors(int cElements,const INT* lpaElements,const COLORREF* lpaRgbValues); +int SetSystemCursor(HCURSOR hcur,DWORD id); +int SetThreadDesktop(HDESK hDesktop); +int SetTimer(HWND hWnd,UINT_PTR nIDEvent,UINT uElapse,TIMERPROC lpTimerFunc); +int SetUserObjectInformation(HANDLE hObj,int nIndex,PVOID pvInfo,DWORD nLength); +int SetUserObjectSecurity(HANDLE hObj,PSECURITY_INFORMATION pSIRequested,PSECURITY_DESCRIPTOR pSID); +int SetWinEventHook(UINT eventMin,UINT eventMax,HMODULE hmodWinEventProc,WINEVENTPROC lpfnWinEventProc,DWORD idProcess,DWORD idThread,DWORD dwflags); +int SetWindowContextHelpId(HWND hWnd,DWORD dwContextHelpId); +int SetWindowDisplayAffinity(HWND hWnd,DWORD dwAffinity); +int SetWindowLong(HWND hWnd,int nIndex,LONG dwNewLong); +int SetWindowLongA(HWND hWnd,int nIndex,LONG dwNewLong); +int SetWindowLongW(HWND hWnd,int nIndex,LONG dwNewLong); +int SetWindowPlacement(HWND hWnd,WINDOWPLACEMENT* lpwndpl); +int SetWindowPos(HWND hWnd,HWND hWndInsertAfter,int X,int Y,int cx,int cy,UINT uFlags); +int SetWindowRgn(HWND hWnd,HRGN hRgn,BOOL bRedraw); +int SetWindowText(HWND hWnd,LPCTSTR lpString); +int SetWindowTextA(HWND hwnd,LPCTSTR lpString); +int SetWindowTextW(HWND hwnd,LPCTSTR lpString); +int SetWindowsHookEx(int idHook,HOOKPROC lpfn,HINSTANCE hMod,DWORD dwThreadId); +int SetWindowsHookExA(int idHook,HOOKPROC lpfn,HINSTANCE hMod,DWORD dwThreadId); +int SetWindowsHookExW(int idHook,HOOKPROC lpfn,HINSTANCE hMod,DWORD dwThreadId); +int ShowCaret(HWND hWnd); +int ShowCursor(BOOL bShow); +int ShowOwnedPopups(HWND hWnd,BOOL fShow); +int ShowScrollBar(HWND hWnd,int wBar,BOOL bShow); +int ShowWindow(HWND hWnd,int nCmdShow); +int ShowWindowAsync(HWND hWnd,int nCmdShow); +int ShutdownBlockReasonCreate(HWND hWnd,LPCWSTR pwszReason); +int ShutdownBlockReasonDestroy(HWND hWnd); +int ShutdownBlockReasonQuery(HWND hWnd,LPWSTR pwszBuff,DWORD* pcchBuff); +int SoundSentry(); +int SubtractRect(LPRECT lprcDst,const RECT* lprcSrc1,const RECT* lprcSrc2); +int SwapMouseButton(BOOL fSwap); +int SwitchDesktop(HDESK hDesktop); +int SwitchToThisWindow(HWND hWnd,BOOL fAltTab); +int SystemParametersInfo(long uiAction,UINT uiParam,PVOID pvParam,long fWinIni); +int SystemParametersInfoA(long uiAction,UINT uiParam,PVOID pvParam,long fWinIni); +int SystemParametersInfoW(long uiAction,UINT uiParam,PVOID pvParam,long fWinIni); +int TabbedTextOut(HDC hDC,int X,int Y,LPCTSTR lpString,int nCount,int nTabPositions,const LPINT lpnTabStopPositions,int nTabOrigin); +int TabbedTextOutA(HDC hDC,int X,int Y,LPCTSTR lpString,int nCount,int nTabPositions,const LPINT lpnTabStopPositions,int nTabOrigin); +int TabbedTextOutW(HDC hDC,int X,int Y,LPCTSTR lpString,int nCount,int nTabPositions,const LPINT lpnTabStopPositions,int nTabOrigin); +int TileWindows(HWND hwndParent,UINT wHow,RECT* lpRect,UINT cKids,const HWND* lpKids); +int ToAscii(UINT uVirtKey,UINT uScanCode,PBYTE lpKeyState,LPWORD lpChar,UINT uFlags); +int ToAsciiEx(UINT uVirtKey,UINT uScanCode,PBYTE lpKeyState,LPWORD lpChar,UINT uFlags,HKL dwhkl); +int ToUnicode(UINT wVirtKey,UINT wScanCode,const PBYTE lpKeyState,LPWSTR pwszBuff,int cchBuff,UINT wFlags); +int ToUnicodeEx(UINT wVirtKey,UINT wScanCode,const PBYTE lpKeyState,LPWSTR pwszBuff,int cchBuff,UINT wFlags,HKL dwhkl); +int TrackMouseEvent(LPTRACKMOUSEEVENT pTrackMouseEvent); +int TrackPopupMenu(HMENU hMenu,UINT uFlags,int X,int Y,int nReserved,HWND hWnd,CONST RECT* prcRect); +int TrackPopupMenuEx(HMENU hmenu,UINT fuFlags,int x,int Y,HWND hWnd,LPTPMPARAMS lptpm); +int TranslateAcceleratorA(HWND hWnd,HACCEL hAccTable,LPMSG lpMsg); +int TranslateAcceleratorW(HWND hWnd,HACCEL hAccTable,LPMSG lpMsg); +int TranslateAccelerator(HWND hWnd,HACCEL hAccTable,LPMSG lpMsg); +int TranslateMDISysAccel(HWND hWndClient,LPMSG lpMsg); +int TranslateMessage(const MSG* lpMsg); +int UnhookWinEvent(HWINEVENTHOOK hWinEventHook); +int UnhookWindowsHookEx(HHOOK hhk); +int UnionRect(LPRECT lprcDst,const RECT* lprcSrc1,const RECT* lprcSrc2); +int UnloadKeyboardLayout(HKL hkl); +int UnpackDDElParam(UINT msg,LPARAM lParam,PUINT_PTR puiLo,PUINT_PTR puiHi); +int UnregisterClass(LPCTSTR lpClassName,HINSTANCE hInstance); +int UnregisterClassA(DWORD lpClassName,DWORD hInstance); +int UnregisterClassA(LPCTSTR lpClassName,HINSTANCE hInstance); +int UnregisterClassW(LPCTSTR lpClassName,HINSTANCE hInstance); +int UnregisterDeviceNotification(HDEVNOTIFY Handle); +int UnregisterHotKey(HWND hWnd,int id); +int UnregisterPowerSettingNotification(HPOWERNOTIFY Handle); +int UnregisterTouchWindow(HWND hWnd); +int UpdateLayeredWindow(HWND hwnd,HDC hdcDst,POINT* pptDst,SIZE* psize,HDC hdcSrc,POINT* pptSrc,COLORREF crKey,BLENDFUNCTION* pblend,DWORD dwFlags); +int UpdateLayeredWindowIndirect(HWND hwnd,const UPDATELAYEREDWINDOWINFO* pULWInfo); +int UpdateWindow(HWND hWnd); +int UserHandleGrantAccess(HANDLE hUserHandle,HANDLE hJob,BOOL bGrant); +int ValidateRect(HWND hWnd,const RECT* lpRect); +int ValidateRgn(HWND hWnd,HRGN hRgn); +int VkKeyScan(TCHAR ch); +int VkKeyScanA(TCHAR ch); +int VkKeyScanEx(TCHAR ch,HKL dwhkl); +int VkKeyScanW(TCHAR ch); +int WaitForInputIdle(HANDLE hProcess,DWORD dwMilliseconds); +int WaitMessage(); +int WinHelp(HWND hWndMain,LPCTSTR lpszHelp,UINT uCommand,ULONG_PTR dwData); +int WinHelpA(HWND hWndMain,LPCTSTR lpszHelp,UINT uCommand,ULONG_PTR wData); +int WinHelpW(HWND hWndMain,LPCTSTR lpszHelp,UINT uCommand,ULONG_PTR wData); +int WindowFromDC(HDC hDC); +int WindowFromPhysicalPoint(POINT Point); +int WindowFromPoint(POINT Point); +int keybd_event(BYTE bVk,BYTE bScan,DWORD dwFlags,ULONG_PTR dwExtraInfo); +int mouse_event(DWORD dwFlags,DWORD dx,DWORD dy,DWORD dwData,ULONG_PTR dwExtraInfo); +int toascii(DWORD char); \ No newline at end of file diff --git a/x64_dbg_gui/Project/DebuggerX64.pro b/x64_dbg_gui/Project/DebuggerX64.pro index ce80abbe..03a2446f 100644 --- a/x64_dbg_gui/Project/DebuggerX64.pro +++ b/x64_dbg_gui/Project/DebuggerX64.pro @@ -66,7 +66,8 @@ SOURCES += \ Src/BasicView/CommandHelpView.cpp \ Src/BasicView/HistoryLineEdit.cpp \ Src/Gui/CPUJumps.cpp \ - Src/Gui/Configuration.cpp + Src/Gui/Configuration.cpp \ + Src/Utils/ApiFingerprints.cpp HEADERS += \ @@ -113,7 +114,8 @@ HEADERS += \ Src/BasicView/CommandHelpView.h \ Src/BasicView/HistoryLineEdit.h \ Src/Gui/CPUJumps.h \ - Src/Gui/Configuration.h + Src/Gui/Configuration.h \ + Src/Utils/ApiFingerprints.h INCLUDEPATH += \ diff --git a/x64_dbg_gui/Project/Src/Gui/CPUJumps.cpp b/x64_dbg_gui/Project/Src/Gui/CPUJumps.cpp index 78a542b6..d7240cbd 100644 --- a/x64_dbg_gui/Project/Src/Gui/CPUJumps.cpp +++ b/x64_dbg_gui/Project/Src/Gui/CPUJumps.cpp @@ -116,6 +116,13 @@ void CPUJumps::paintEvent(QPaintEvent *event) cond, DbgIsJumpGoingToExecute(InstrBuffer->at(line).rva+CodePtr->getBase())&&CodePtr->currentEIP() == InstrBuffer->at(line).rva, selectedVA == InstrBuffer->at(line).rva+CodePtr->getBase()); + }else if(destRVA < first_va){ + drawJump(line, + -6, + jumpoffset, + cond, + DbgIsJumpGoingToExecute(InstrBuffer->at(line).rva+CodePtr->getBase())&&CodePtr->currentEIP() == InstrBuffer->at(line).rva, + selectedVA == InstrBuffer->at(line).rva+CodePtr->getBase()); } } diff --git a/x64_dbg_gui/Project/Src/Gui/Configuration.cpp b/x64_dbg_gui/Project/Src/Gui/Configuration.cpp index 99d83b2a..271208f5 100644 --- a/x64_dbg_gui/Project/Src/Gui/Configuration.cpp +++ b/x64_dbg_gui/Project/Src/Gui/Configuration.cpp @@ -23,13 +23,12 @@ void Configuration::load(QString filename){ if (!configfile.open(QIODevice::ReadOnly)) { qWarning("Couldn't open config file."); return ; - }else{ - qDebug() << "load succ"; } QByteArray saveData = configfile.readAll(); Config = QJsonDocument(QJsonDocument::fromJson(saveData)).object(); readColors(); + } void Configuration::readColors() { @@ -39,11 +38,22 @@ void Configuration::readColors() { for (int idx = 0; idx < ColorArray.size(); ++idx) { QJsonArray colorObj = ColorArray[idx].toArray(); Colors.insert(colorObj.at(0).toString(),QColor( colorObj.at(1).toString())); - qDebug() << "read color "< Configuration::ApiFingerprints(){ + QList files; + QJsonArray APIArray = Config["apifingerprints"].toArray(); + for (int idx = 0; idx < APIArray.size(); ++idx) { + QString filename = "data/"+APIArray.at(idx).toString()+".txt"; + QFile mFile(filename); + if(mFile.open(QFile::ReadOnly | QFile::Text)){ + files.append(APIArray.at(idx).toString()); + mFile.close(); + } - + } + return files; } const QColor Configuration::color(QString id) const diff --git a/x64_dbg_gui/Project/Src/Gui/Configuration.h b/x64_dbg_gui/Project/Src/Gui/Configuration.h index c1ea4b1d..26782673 100644 --- a/x64_dbg_gui/Project/Src/Gui/Configuration.h +++ b/x64_dbg_gui/Project/Src/Gui/Configuration.h @@ -25,6 +25,7 @@ public: void readColors(); const QColor color(QString id) const; void load(QString filename); + QList ApiFingerprints(); }; #endif // CONFIGURATION_H diff --git a/x64_dbg_gui/Project/Src/Gui/MainWindow.cpp b/x64_dbg_gui/Project/Src/Gui/MainWindow.cpp index 551346ba..943da761 100644 --- a/x64_dbg_gui/Project/Src/Gui/MainWindow.cpp +++ b/x64_dbg_gui/Project/Src/Gui/MainWindow.cpp @@ -24,6 +24,8 @@ MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWi // load config file mConfiguration = new Configuration; + mAPIFingerprints = new ApiFingerprints; + //Load recent files loadMRUList(16); diff --git a/x64_dbg_gui/Project/Src/Gui/MainWindow.h b/x64_dbg_gui/Project/Src/Gui/MainWindow.h index 3efec87b..83cb4ad9 100644 --- a/x64_dbg_gui/Project/Src/Gui/MainWindow.h +++ b/x64_dbg_gui/Project/Src/Gui/MainWindow.h @@ -19,6 +19,7 @@ #include "SettingsDialog.h" #include "tabwidget.h" #include "Configuration.h" +#include "ApiFingerprints.h" namespace Ui { class MainWindow; @@ -89,6 +90,7 @@ private: StatusLabel* mLastLogLabel; Configuration* mConfiguration; + ApiFingerprints* mAPIFingerprints; const char* mWindowMainTitle; diff --git a/x64_dbg_gui/Project/Src/Utils/ApiFingerprints.cpp b/x64_dbg_gui/Project/Src/Utils/ApiFingerprints.cpp new file mode 100644 index 00000000..94427096 --- /dev/null +++ b/x64_dbg_gui/Project/Src/Utils/ApiFingerprints.cpp @@ -0,0 +1,110 @@ +#include "ApiFingerprints.h" +#include "Configuration.h" + + + +/** + * @brief retrieves information (name, arguments) for given api function from database + * @param name of dll without ".dll" + * @param name of function + * @remark upper or lower case doesn't matter + * @return + */ +const APIFunction ApiFingerprints::function(QString dllname,QString functionname) const{ + return Library.constFind(dllname.toLower().trimmed()).value().constFind(functionname.toLower().trimmed()).value(); + /* + * example + * -------------------- + * "int MessageBoxA(HWND hWnd,LPCTSTR lpText,LPCTSTR lpCaption,UINT uType)" + * + * APIFunction f = function("UsEr32 ","messAgebOxa"); + * f.Name = "MessageBoxA"; + * f.DLLName = "user32"; + * f.ReturnType = "int" + * f.Arguments.at(0).Name = "hWnd"; + * f.Arguments.at(0).Type = "HWND"; + * f.Arguments.at(1).Name = "lpText"; + * f.Arguments.at(1).Type = "LPCTSTR"; + * ... + * + * upper / lower case doesn't matter and additional whitespace will be trimmed + */ + + +} + + +ApiFingerprints::ApiFingerprints() +{ + // the config file should contain a list of possible data files for api calls + QList files = Configuration::instance()->ApiFingerprints(); + + // iterate all given files + foreach(QString file, files){ + QFile mFile("data/"+file+".txt"); + if(mFile.open(QFile::ReadOnly | QFile::Text)){ + // if file exists --> parse file + + QMap Functions; + QTextStream in(&mFile); + while ( !in.atEnd() ) + { + // reads raw line like "int;MessageBoxA;HWND hWnd;LPCTSTR lpText;LPCTSTR lpCaption;UINT uType;" + QString rawFunctionDescr = in.readLine(); + QStringList functionParts = rawFunctionDescr.split(";"); + // format : retType;FunctionName;Arg1;Arg2;Arg3;... + + + if(functionParts.count()<2){ + // each function description needs at least a return type and a name + // if not, we ignore the data + continue; + } + + // function data + APIFunction func; + func.DLLName = file; + func.ReturnType = functionParts.at(0); + func.Name = functionParts.at(1); + + // read parameters + for(int i=2;i use "*" to split type and name of argument + QStringList par = rawArgument.split("*"); + APIArgument arg; + if(par.count() > 1){ + arg.Name = par.at(1).trimmed(); + arg.Type = par.at(0).trimmed()+"*"; + + }else{ + // current argument is no pointer --> use " " to split + par = rawArgument.split(" "); + if(par.count()>1){ + arg.Name = par.at(1).trimmed(); + arg.Type = par.at(0).trimmed(); + }else{ + // we assume that there is only the type + arg.Name = ""; + arg.Type = rawArgument.trimmed(); + } + } + + func.Arguments.append(arg); + + } + + Functions.insert(func.Name.toLower().trimmed(),func); + + } + + Library.insert(file,Functions); + mFile.close(); + } + + } + +} diff --git a/x64_dbg_gui/Project/Src/Utils/ApiFingerprints.h b/x64_dbg_gui/Project/Src/Utils/ApiFingerprints.h new file mode 100644 index 00000000..c30dcda4 --- /dev/null +++ b/x64_dbg_gui/Project/Src/Utils/ApiFingerprints.h @@ -0,0 +1,28 @@ +#ifndef APIFINGERPRINTS_H +#define APIFINGERPRINTS_H + +#include +#include +#include + +struct APIArgument{ + QString Type; + QString Name; +}; + +struct APIFunction{ + QString DLLName; + QString ReturnType; + QString Name; + QList Arguments; +}; + +class ApiFingerprints +{ + QMap> Library; +public: + ApiFingerprints(); + const APIFunction function(QString dllname, QString functionname) const; +}; + +#endif // APIFINGERPRINTS_H diff --git a/x64_dbg_gui/Project/Src/config.json b/x64_dbg_gui/Project/Src/config.json new file mode 100644 index 00000000..7485bfcb --- /dev/null +++ b/x64_dbg_gui/Project/Src/config.json @@ -0,0 +1,18 @@ +{ + "colors": [ + ["DisassemblyCipColor","#000000"], + ["DisassemblyMainBpColor","#FF0000"], + ["DisassemblyOtherBpColor","#FFFBF0"], + ["DisassemblyBookmarkColor","#FEE970"], + ["DisassemblyMainLabelColor","#FF0000"], + ["blackaddress","#000000"], + ["DisassemblySelectedAddressColor","#000000"], + ["DisassemblyBytesColor","#000000"], + ["DisassemblyCommentColor","#000000"], + ["EIPLabel","#ffffff"], + ["EIPLabelBG","#4040ff"] + ], + "apifingerprints":[ + "gdi32","kernel32","shell32","stdio","user32" + ] +} \ No newline at end of file