From 556b0edec893c633877246e5b6e6454615726817 Mon Sep 17 00:00:00 2001 From: Timo Kreuzer Date: Wed, 19 Dec 2007 21:11:06 +0000 Subject: [PATCH] - update dbghelp.h and cvconst.h from wine - update mscvpdb.h, winbase16.h and windef16.h wine headers - create wine/winbase.h containing SYSLEVEL struct - add regex.h to include/wine svn path=/trunk/; revision=31337 --- reactos/include/psdk/cvconst.h | 133 +- reactos/include/psdk/dbghelp.h | 916 +++++++++--- reactos/include/reactos/wine/mscvpdb.h | 1714 ++++++++++++++++++++++ reactos/include/reactos/wine/regex.h | 572 ++++++++ reactos/include/reactos/wine/winbase.h | 15 + reactos/include/reactos/wine/winbase16.h | 506 ++++++- reactos/include/reactos/wine/windef16.h | 27 +- 7 files changed, 3661 insertions(+), 222 deletions(-) create mode 100644 reactos/include/reactos/wine/mscvpdb.h create mode 100644 reactos/include/reactos/wine/regex.h create mode 100644 reactos/include/reactos/wine/winbase.h diff --git a/reactos/include/psdk/cvconst.h b/reactos/include/psdk/cvconst.h index 59fc1831d7c..2005aae8c3c 100644 --- a/reactos/include/psdk/cvconst.h +++ b/reactos/include/psdk/cvconst.h @@ -15,7 +15,7 @@ * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ /* information in this file is highly derivated from MSDN DIA information pages */ @@ -121,7 +121,7 @@ enum DataKind /* values for registers (on different CPUs) */ enum CV_HREG_e { - /* those values are common to all supported CPUs (and CPU independant) */ + /* those values are common to all supported CPUs (and CPU independent) */ CV_ALLREG_ERR = 30000, CV_ALLREG_TEB = 30001, CV_ALLREG_TIMER = 30002, @@ -420,6 +420,114 @@ enum CV_HREG_e CV_M32R_ACHI = 32, CV_M32R_ACLO = 33, CV_M32R_PC = 34, + + /* AMD/Intel x86_64 CPU */ + CV_AMD64_NONE = CV_REG_NONE, + CV_AMD64_AL = CV_REG_AL, + CV_AMD64_CL = CV_REG_CL, + CV_AMD64_DL = CV_REG_DL, + CV_AMD64_BL = CV_REG_BL, + CV_AMD64_AH = CV_REG_AH, + CV_AMD64_CH = CV_REG_CH, + CV_AMD64_DH = CV_REG_DH, + CV_AMD64_BH = CV_REG_BH, + CV_AMD64_AX = CV_REG_AX, + CV_AMD64_CX = CV_REG_CX, + CV_AMD64_DX = CV_REG_DX, + CV_AMD64_BX = CV_REG_BX, + CV_AMD64_SP = CV_REG_SP, + CV_AMD64_BP = CV_REG_BP, + CV_AMD64_SI = CV_REG_SI, + CV_AMD64_DI = CV_REG_DI, + CV_AMD64_EAX = CV_REG_EAX, + CV_AMD64_ECX = CV_REG_ECX, + CV_AMD64_EDX = CV_REG_EDX, + CV_AMD64_EBX = CV_REG_EBX, + CV_AMD64_ESP = CV_REG_ESP, + CV_AMD64_EBP = CV_REG_EBP, + CV_AMD64_ESI = CV_REG_ESI, + CV_AMD64_EDI = CV_REG_EDI, + CV_AMD64_ES = CV_REG_ES, + CV_AMD64_CS = CV_REG_CS, + CV_AMD64_SS = CV_REG_SS, + CV_AMD64_DS = CV_REG_DS, + CV_AMD64_FS = CV_REG_FS, + CV_AMD64_GS = CV_REG_GS, + CV_AMD64_FLAGS = CV_REG_FLAGS, + CV_AMD64_RIP = CV_REG_EIP, + CV_AMD64_EFLAGS = CV_REG_EFLAGS, + + /* */ + CV_AMD64_TEMP = CV_REG_TEMP, + CV_AMD64_TEMPH = CV_REG_TEMPH, + CV_AMD64_QUOTE = CV_REG_QUOTE, + CV_AMD64_PCDR3 = CV_REG_PCDR3, /* this includes PCDR4 to PCDR7 */ + CV_AMD64_CR0 = CV_REG_CR0, /* this includes CR1 to CR4 */ + CV_AMD64_DR0 = CV_REG_DR0, /* this includes DR1 to DR7 */ + /* */ + + CV_AMD64_GDTR = CV_REG_GDTR, + CV_AMD64_GDTL = CV_REG_GDTL, + CV_AMD64_IDTR = CV_REG_IDTR, + CV_AMD64_IDTL = CV_REG_IDTL, + CV_AMD64_LDTR = CV_REG_LDTR, + CV_AMD64_TR = CV_REG_TR, + + CV_AMD64_PSEUDO1 = CV_REG_PSEUDO1, /* this includes Pseudo02 to Pseuso09 */ + CV_AMD64_ST0 = CV_REG_ST0, /* this includes ST1 to ST7 */ + CV_AMD64_CTRL = CV_REG_CTRL, + CV_AMD64_STAT = CV_REG_STAT, + CV_AMD64_TAG = CV_REG_TAG, + CV_AMD64_FPIP = CV_REG_FPIP, + CV_AMD64_FPCS = CV_REG_FPCS, + CV_AMD64_FPDO = CV_REG_FPDO, + CV_AMD64_FPDS = CV_REG_FPDS, + CV_AMD64_ISEM = CV_REG_ISEM, + CV_AMD64_FPEIP = CV_REG_FPEIP, + CV_AMD64_FPEDO = CV_REG_FPEDO, + CV_AMD64_MM0 = CV_REG_MM0, /* this includes MM1 to MM7 */ + CV_AMD64_XMM0 = CV_REG_XMM0, /* this includes XMM1 to XMM7 */ + CV_AMD64_XMM00 = CV_REG_XMM00, + CV_AMD64_XMM0L = CV_REG_XMM0L, /* this includes XMM1L to XMM7L */ + CV_AMD64_XMM0H = CV_REG_XMM0H, /* this includes XMM1H to XMM7H */ + CV_AMD64_MXCSR = CV_REG_MXCSR, + CV_AMD64_EDXEAX = CV_REG_EDXEAX, + CV_AMD64_EMM0L = CV_REG_EMM0L, + CV_AMD64_EMM0H = CV_REG_EMM0H, + CV_AMD64_MM00 = CV_REG_MM00, + CV_AMD64_MM01 = CV_REG_MM01, + CV_AMD64_MM10 = CV_REG_MM10, + CV_AMD64_MM11 = CV_REG_MM11, + CV_AMD64_MM20 = CV_REG_MM20, + CV_AMD64_MM21 = CV_REG_MM21, + CV_AMD64_MM30 = CV_REG_MM30, + CV_AMD64_MM31 = CV_REG_MM31, + CV_AMD64_MM40 = CV_REG_MM40, + CV_AMD64_MM41 = CV_REG_MM41, + CV_AMD64_MM50 = CV_REG_MM50, + CV_AMD64_MM51 = CV_REG_MM51, + CV_AMD64_MM60 = CV_REG_MM60, + CV_AMD64_MM61 = CV_REG_MM61, + CV_AMD64_MM70 = CV_REG_MM70, + CV_AMD64_MM71 = CV_REG_MM71, + + CV_AMD64_RAX = 328, + CV_AMD64_RBX = 329, + CV_AMD64_RCX = 330, + CV_AMD64_RDX = 331, + CV_AMD64_RSI = 332, + CV_AMD64_RDI = 333, + CV_AMD64_RBP = 334, + CV_AMD64_RSP = 335, + + CV_AMD64_R8 = 336, + CV_AMD64_R9 = 337, + CV_AMD64_R10 = 338, + CV_AMD64_R11 = 339, + CV_AMD64_R12 = 340, + CV_AMD64_R13 = 341, + CV_AMD64_R14 = 342, + CV_AMD64_R15 = 343, } CV_HREG_e; typedef enum @@ -430,3 +538,24 @@ typedef enum THUNK_ORDINAL_PCODE, THUNK_ORDINAL_LOAD } THUNK_ORDINAL; + +typedef enum CV_call_e +{ + CV_CALL_NEAR_C, + CV_CALL_FAR_C, + CV_CALL_NEAR_PASCAL, + CV_CALL_FAR_PASCAL, + CV_CALL_NEAR_FAST, + CV_CALL_FAR_FAST, + CV_CALL_SKIPPED, + CV_CALL_NEAR_STD, + CV_CALL_FAR_STD, + CV_CALL_NEAR_SYS, + CV_CALL_FAR_SYS, + CV_CALL_THISCALL, + CV_CALL_MIPSCALL, + CV_CALL_GENERIC, + CV_CALL_ALPHACALL, + CV_CALL_PPCCALL, + CV_CALL_RESERVED, +} CV_call_e; diff --git a/reactos/include/psdk/dbghelp.h b/reactos/include/psdk/dbghelp.h index 6098efe6a03..552c101e5b2 100644 --- a/reactos/include/psdk/dbghelp.h +++ b/reactos/include/psdk/dbghelp.h @@ -15,7 +15,7 @@ * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #ifndef __WINE_DBGHELP_H @@ -25,9 +25,12 @@ extern "C" { #endif /* defined(__cplusplus) */ +#define IMAGEAPI WINAPI +#define DBHLPAPI IMAGEAPI + typedef struct _LOADED_IMAGE { - LPSTR ModuleName; + PSTR ModuleName; HANDLE hFile; PUCHAR MappedAddress; PIMAGE_NT_HEADERS FileHeader; @@ -37,6 +40,8 @@ typedef struct _LOADED_IMAGE ULONG Characteristics; BOOLEAN fSystemImage; BOOLEAN fDOSImage; + BOOLEAN fReadOnly; + UCHAR Version; LIST_ENTRY Links; ULONG SizeOfImage; } LOADED_IMAGE, *PLOADED_IMAGE; @@ -60,6 +65,13 @@ typedef struct _tagADDRESS ADDRESS_MODE Mode; } ADDRESS, *LPADDRESS; +typedef struct _tagADDRESS64 +{ + DWORD64 Offset; + WORD Segment; + ADDRESS_MODE Mode; +} ADDRESS64, *LPADDRESS64; + #define SYMF_OMAP_GENERATED 0x00000001 #define SYMF_OMAP_MODIFIED 0x00000002 #define SYMF_USER_GENERATED 0x00000004 @@ -86,6 +98,7 @@ typedef enum SymDeferred, SymSym, SymDia, + SymVirtual, NumSymTypes } SYM_TYPE; @@ -99,6 +112,26 @@ typedef struct _IMAGEHLP_SYMBOL CHAR Name[1]; } IMAGEHLP_SYMBOL, *PIMAGEHLP_SYMBOL; +typedef struct _IMAGEHLP_SYMBOL64 +{ + DWORD SizeOfStruct; + DWORD64 Address; + DWORD Size; + DWORD Flags; + DWORD MaxNameLength; + CHAR Name[1]; +} IMAGEHLP_SYMBOL64, *PIMAGEHLP_SYMBOL64; + +typedef struct _IMAGEHLP_SYMBOLW64 +{ + DWORD SizeOfStruct; + DWORD64 Address; + DWORD Size; + DWORD Flags; + DWORD MaxNameLength; + WCHAR Name[1]; +} IMAGEHLP_SYMBOLW64, *PIMAGEHLP_SYMBOLW64; + typedef struct _IMAGEHLP_MODULE { DWORD SizeOfStruct; @@ -113,7 +146,8 @@ typedef struct _IMAGEHLP_MODULE CHAR LoadedImageName[256]; } IMAGEHLP_MODULE, *PIMAGEHLP_MODULE; -typedef struct _IMAGEHLP_MODULEW { +typedef struct _IMAGEHLP_MODULEW +{ DWORD SizeOfStruct; DWORD BaseOfImage; DWORD ImageSize; @@ -126,6 +160,60 @@ typedef struct _IMAGEHLP_MODULEW { WCHAR LoadedImageName[256]; } IMAGEHLP_MODULEW, *PIMAGEHLP_MODULEW; +typedef struct _IMAGEHLP_MODULE64 +{ + DWORD SizeOfStruct; + DWORD64 BaseOfImage; + DWORD ImageSize; + DWORD TimeDateStamp; + DWORD CheckSum; + DWORD NumSyms; + SYM_TYPE SymType; + CHAR ModuleName[32]; + CHAR ImageName[256]; + CHAR LoadedImageName[256]; + CHAR LoadedPdbName[256]; + DWORD CVSig; + CHAR CVData[MAX_PATH*3]; + DWORD PdbSig; + GUID PdbSig70; + DWORD PdbAge; + BOOL PdbUnmatched; + BOOL DbgUnmatched; + BOOL LineNumbers; + BOOL GlobalSymbols; + BOOL TypeInfo; + BOOL SourceIndexed; + BOOL Publics; +} IMAGEHLP_MODULE64, *PIMAGEHLP_MODULE64; + +typedef struct _IMAGEHLP_MODULEW64 +{ + DWORD SizeOfStruct; + DWORD64 BaseOfImage; + DWORD ImageSize; + DWORD TimeDateStamp; + DWORD CheckSum; + DWORD NumSyms; + SYM_TYPE SymType; + WCHAR ModuleName[32]; + WCHAR ImageName[256]; + WCHAR LoadedImageName[256]; + WCHAR LoadedPdbName[256]; + DWORD CVSig; + WCHAR CVData[MAX_PATH*3]; + DWORD PdbSig; + GUID PdbSig70; + DWORD PdbAge; + BOOL PdbUnmatched; + BOOL DbgUnmatched; + BOOL LineNumbers; + BOOL GlobalSymbols; + BOOL TypeInfo; + BOOL SourceIndexed; + BOOL Publics; +} IMAGEHLP_MODULEW64, *PIMAGEHLP_MODULEW64; + typedef struct _IMAGEHLP_LINE { DWORD SizeOfStruct; @@ -135,12 +223,45 @@ typedef struct _IMAGEHLP_LINE DWORD Address; } IMAGEHLP_LINE, *PIMAGEHLP_LINE; +typedef struct _IMAGEHLP_LINEW +{ + DWORD SizeOfStruct; + PVOID Key; + DWORD LineNumber; + PWSTR FileName; + DWORD Address; +} IMAGEHLP_LINEW, *PIMAGEHLP_LINEW; + +typedef struct _IMAGEHLP_LINE64 +{ + DWORD SizeOfStruct; + PVOID Key; + DWORD LineNumber; + PCHAR FileName; + DWORD64 Address; +} IMAGEHLP_LINE64, *PIMAGEHLP_LINE64; + +typedef struct _IMAGEHLP_LINEW64 +{ + DWORD SizeOfStruct; + PVOID Key; + DWORD LineNumber; + PWSTR FileName; + DWORD64 Address; +} IMAGEHLP_LINEW64, *PIMAGEHLP_LINEW64; + typedef struct _SOURCEFILE { - DWORD ModBase; + DWORD64 ModBase; PCHAR FileName; } SOURCEFILE, *PSOURCEFILE; +typedef struct _SOURCEFILEW +{ + DWORD64 ModBase; + PWSTR FileName; +} SOURCEFILEW, *PSOURCEFILEW; + #define CBA_DEFERRED_SYMBOL_LOAD_START 0x00000001 #define CBA_DEFERRED_SYMBOL_LOAD_COMPLETE 0x00000002 #define CBA_DEFERRED_SYMBOL_LOAD_FAILURE 0x00000003 @@ -150,6 +271,7 @@ typedef struct _SOURCEFILE #define CBA_DEFERRED_SYMBOL_LOAD_CANCEL 0x00000007 #define CBA_SET_OPTIONS 0x00000008 #define CBA_EVENT 0x00000010 +#define CBA_DEFERRED_SYMBOL_LOAD_PARTIAL 0x00000020 #define CBA_DEBUG_INFO 0x10000000 typedef struct _IMAGEHLP_CBA_READ_MEMORY @@ -160,7 +282,8 @@ typedef struct _IMAGEHLP_CBA_READ_MEMORY DWORD *bytesread; } IMAGEHLP_CBA_READ_MEMORY, *PIMAGEHLP_CBA_READ_MEMORY; -enum { +enum +{ sevInfo = 0, sevProblem, sevAttn, @@ -168,15 +291,38 @@ enum { sevMax }; +#define EVENT_SRCSPEW_START 100 +#define EVENT_SRCSPEW 100 +#define EVENT_SRCSPEW_END 199 + typedef struct _IMAGEHLP_CBA_EVENT { - DWORD severity; - DWORD code; - PCHAR desc; - PVOID object; + DWORD severity; + DWORD code; + PCHAR desc; + PVOID object; } IMAGEHLP_CBA_EVENT, *PIMAGEHLP_CBA_EVENT; +typedef struct _IMAGEHLP_CBA_EVENTW +{ + DWORD severity; + DWORD code; + PCWSTR desc; + PVOID object; +} IMAGEHLP_CBA_EVENTW, *PIMAGEHLP_CBA_EVENTW; + typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD +{ + DWORD SizeOfStruct; + DWORD BaseOfImage; + DWORD CheckSum; + DWORD TimeDateStamp; + CHAR FileName[MAX_PATH]; + BOOLEAN Reparse; + HANDLE hFile; +} IMAGEHLP_DEFERRED_SYMBOL_LOAD, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD; + +typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD64 { DWORD SizeOfStruct; DWORD64 BaseOfImage; @@ -184,7 +330,21 @@ typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD DWORD TimeDateStamp; CHAR FileName[MAX_PATH]; BOOLEAN Reparse; -} IMAGEHLP_DEFERRED_SYMBOL_LOAD, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD; + HANDLE hFile; + DWORD Flags; +} IMAGEHLP_DEFERRED_SYMBOL_LOAD64, *PIMAGEHLP_DEFERRED_SYMBOL_LOAD64; + +typedef struct _IMAGEHLP_DEFERRED_SYMBOL_LOADW64 +{ + DWORD SizeOfStruct; + DWORD64 BaseOfImage; + DWORD CheckSum; + DWORD TimeDateStamp; + WCHAR FileName[MAX_PATH + 1]; + BOOLEAN Reparse; + HANDLE hFile; + DWORD Flags; +} IMAGEHLP_DEFERRED_SYMBOL_LOADW64, *PIMAGEHLP_DEFERRED_SYMBOL_LOADW64; typedef struct _IMAGEHLP_DUPLICATE_SYMBOL { @@ -194,6 +354,14 @@ typedef struct _IMAGEHLP_DUPLICATE_SYMBOL DWORD SelectedSymbol; } IMAGEHLP_DUPLICATE_SYMBOL, *PIMAGEHLP_DUPLICATE_SYMBOL; +typedef struct _IMAGEHLP_DUPLICATE_SYMBOL64 +{ + DWORD SizeOfStruct; + DWORD NumberOfDups; + PIMAGEHLP_SYMBOL64 Symbol; + DWORD SelectedSymbol; +} IMAGEHLP_DUPLICATE_SYMBOL64, *PIMAGEHLP_DUPLICATE_SYMBOL64; + #define SYMOPT_CASE_INSENSITIVE 0x00000001 #define SYMOPT_UNDNAME 0x00000002 #define SYMOPT_DEFERRED_LOADS 0x00000004 @@ -207,6 +375,10 @@ typedef struct _IMAGEHLP_DUPLICATE_SYMBOL #define SYMOPT_EXACT_SYMBOLS 0x00000400 #define SYMOPT_WILD_UNDERSCORE 0x00000800 #define SYMOPT_USE_DEFAULTS 0x00001000 +/* latest SDK defines: */ +#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS 0x00000800 +#define SYMOPT_IGNORE_NT_SYMPATH 0x00001000 + #define SYMOPT_INCLUDE_32BIT_MODULES 0x00002000 #define SYMOPT_PUBLICS_ONLY 0x00004000 #define SYMOPT_NO_PUBLICS 0x00008000 @@ -214,6 +386,8 @@ typedef struct _IMAGEHLP_DUPLICATE_SYMBOL #define SYMOPT_NO_IMAGE_SEARCH 0x00020000 #define SYMOPT_SECURE 0x00040000 #define SYMOPT_NO_PROMPTS 0x00080000 +#define SYMOPT_OVERWRITE 0x00100000 +#define SYMOPT_IGNORE_IMAGEDIR 0x00200000 #define SYMOPT_DEBUG 0x80000000 @@ -247,9 +421,10 @@ typedef struct _DBGHELP_MODLOAD_DATA * MiniDUMP * *************************/ +#include /* DebugHelp */ -#define MINIDUMP_SIGNATURE 0x4D444D50 /* 'PMDM' */ +#define MINIDUMP_SIGNATURE 0x504D444D /* 'MDMP' */ #define MINIDUMP_VERSION (42899) typedef DWORD RVA; @@ -257,12 +432,21 @@ typedef ULONG64 RVA64; typedef enum _MINIDUMP_TYPE { - MiniDumpNormal = 0x0000, - MiniDumpWithDataSegs = 0x0001, - MiniDumpWithFullMemory = 0x0002, - MiniDumpWithHandleData = 0x0004, - MiniDumpFilterMemory = 0x0008, - MiniDumpScanMemory = 0x0010 + MiniDumpNormal = 0x0000, + MiniDumpWithDataSegs = 0x0001, + MiniDumpWithFullMemory = 0x0002, + MiniDumpWithHandleData = 0x0004, + MiniDumpFilterMemory = 0x0008, + MiniDumpScanMemory = 0x0010, + MiniDumpWithUnloadedModules = 0x0020, + MiniDumpWithIndirectlyReferencedMemory = 0x0040, + MiniDumpFilterModulePaths = 0x0080, + MiniDumpWithProcessThreadData = 0x0100, + MiniDumpWithPrivateReadWriteMemory = 0x0200, + MiniDumpWithoutOptionalData = 0x0400, + MiniDumpWithFullMemoryInfo = 0x0800, + MiniDumpWithThreadInfo = 0x1000, + MiniDumpWithCodeSegs = 0x2000 } MINIDUMP_TYPE; typedef enum _MINIDUMP_CALLBACK_TYPE @@ -272,6 +456,7 @@ typedef enum _MINIDUMP_CALLBACK_TYPE ThreadExCallback, IncludeThreadCallback, IncludeModuleCallback, + MemoryCallback, } MINIDUMP_CALLBACK_TYPE; typedef struct _MINIDUMP_THREAD_CALLBACK @@ -280,7 +465,7 @@ typedef struct _MINIDUMP_THREAD_CALLBACK HANDLE ThreadHandle; CONTEXT Context; ULONG SizeOfContext; - ULONGLONG StackBase; + ULONG64 StackBase; ULONG64 StackEnd; } MINIDUMP_THREAD_CALLBACK, *PMINIDUMP_THREAD_CALLBACK; @@ -290,10 +475,10 @@ typedef struct _MINIDUMP_THREAD_EX_CALLBACK HANDLE ThreadHandle; CONTEXT Context; ULONG SizeOfContext; - ULONGLONG StackBase; - ULONGLONG StackEnd; - ULONGLONG BackingStoreBase; - ULONGLONG BackingStoreEnd; + ULONG64 StackBase; + ULONG64 StackEnd; + ULONG64 BackingStoreBase; + ULONG64 BackingStoreEnd; } MINIDUMP_THREAD_EX_CALLBACK, *PMINIDUMP_THREAD_EX_CALLBACK; typedef struct _MINIDUMP_INCLUDE_THREAD_CALLBACK @@ -307,13 +492,15 @@ typedef enum _THREAD_WRITE_FLAGS ThreadWriteStack = 0x0002, ThreadWriteContext = 0x0004, ThreadWriteBackingStore = 0x0008, - ThreadWriteInstructionWindow = 0x0010 + ThreadWriteInstructionWindow = 0x0010, + ThreadWriteThreadData = 0x0020, + ThreadWriteThreadInfo = 0x0040 } THREAD_WRITE_FLAGS; typedef struct _MINIDUMP_MODULE_CALLBACK { PWCHAR FullPath; - ULONGLONG BaseOfImage; + ULONG64 BaseOfImage; ULONG SizeOfImage; ULONG CheckSum; ULONG TimeDateStamp; @@ -335,7 +522,9 @@ typedef enum _MODULE_WRITE_FLAGS ModuleWriteDataSeg = 0x0002, ModuleWriteMiscRecord = 0x0004, ModuleWriteCvRecord = 0x0008, - ModuleReferencedByMemory = 0x0010 + ModuleReferencedByMemory = 0x0010, + ModuleWriteTlsData = 0x0020, + ModuleWriteCodeSegs = 0x0040, } MODULE_WRITE_FLAGS; typedef struct _MINIDUMP_CALLBACK_INPUT @@ -350,7 +539,7 @@ typedef struct _MINIDUMP_CALLBACK_INPUT MINIDUMP_MODULE_CALLBACK Module; MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread; MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule; - } u; + } DUMMYUNIONNAME; } MINIDUMP_CALLBACK_INPUT, *PMINIDUMP_CALLBACK_INPUT; typedef struct _MINIDUMP_CALLBACK_OUTPUT @@ -359,12 +548,15 @@ typedef struct _MINIDUMP_CALLBACK_OUTPUT { ULONG ModuleWriteFlags; ULONG ThreadWriteFlags; - } u; + struct + { + ULONG64 MemoryBase; + ULONG MemorySize; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; } MINIDUMP_CALLBACK_OUTPUT, *PMINIDUMP_CALLBACK_OUTPUT; -typedef BOOL (WINAPI* MINIDUMP_CALLBACK_ROUTINE)(PVOID CallbackParam, - const PMINIDUMP_CALLBACK_INPUT CallbackInput, - PMINIDUMP_CALLBACK_OUTPUT CallbackOutput); +typedef BOOL (WINAPI* MINIDUMP_CALLBACK_ROUTINE)(PVOID, const PMINIDUMP_CALLBACK_INPUT, PMINIDUMP_CALLBACK_OUTPUT); typedef struct _MINIDUMP_CALLBACK_INFORMATION { @@ -378,7 +570,13 @@ typedef struct _MINIDUMP_LOCATION_DESCRIPTOR RVA Rva; } MINIDUMP_LOCATION_DESCRIPTOR; -typedef struct _MINIDUMP_DIRECTORY +typedef struct _MINIDUMP_LOCATION_DESCRIPTOR64 +{ + ULONG64 DataSize; + RVA64 Rva; +} MINIDUMP_LOCATION_DESCRIPTOR64; + +typedef struct _MINIDUMP_DIRECTORY { ULONG StreamType; MINIDUMP_LOCATION_DESCRIPTOR Location; @@ -388,11 +586,11 @@ typedef struct _MINIDUMP_EXCEPTION { ULONG ExceptionCode; ULONG ExceptionFlags; - ULONGLONG ExceptionRecord; - ULONGLONG ExceptionAddress; + ULONG64 ExceptionRecord; + ULONG64 ExceptionAddress; ULONG NumberParameters; ULONG __unusedAlignment; - ULONGLONG ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS]; + ULONG64 ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS]; } MINIDUMP_EXCEPTION, *PMINIDUMP_EXCEPTION; typedef struct _MINIDUMP_EXCEPTION_INFORMATION @@ -402,7 +600,7 @@ typedef struct _MINIDUMP_EXCEPTION_INFORMATION BOOL ClientPointers; } MINIDUMP_EXCEPTION_INFORMATION, *PMINIDUMP_EXCEPTION_INFORMATION; -typedef struct MINIDUMP_EXCEPTION_STREAM +typedef struct MINIDUMP_EXCEPTION_STREAM { ULONG ThreadId; ULONG __alignment; @@ -410,7 +608,7 @@ typedef struct MINIDUMP_EXCEPTION_STREAM MINIDUMP_LOCATION_DESCRIPTOR ThreadContext; } MINIDUMP_EXCEPTION_STREAM, *PMINIDUMP_EXCEPTION_STREAM; -typedef struct _MINIDUMP_HEADER +typedef struct _MINIDUMP_HEADER { DWORD Signature; DWORD Version; @@ -421,19 +619,38 @@ typedef struct _MINIDUMP_HEADER { DWORD Reserved; DWORD TimeDateStamp; - } u; - ULONGLONG Flags; + } DUMMYUNIONNAME; + ULONG64 Flags; } MINIDUMP_HEADER, *PMINIDUMP_HEADER; -typedef struct _MINIDUMP_MEMORY_DESCRIPTOR +typedef struct _MINIDUMP_MEMORY_DESCRIPTOR { - ULONGLONG StartOfMemoryRange; + ULONG64 StartOfMemoryRange; MINIDUMP_LOCATION_DESCRIPTOR Memory; } MINIDUMP_MEMORY_DESCRIPTOR, *PMINIDUMP_MEMORY_DESCRIPTOR; +typedef struct _MINIDUMP_MEMORY_LIST +{ + ULONG NumberOfMemoryRanges; + MINIDUMP_MEMORY_DESCRIPTOR MemoryRanges[1]; /* FIXME: 0-sized array not supported */ +} MINIDUMP_MEMORY_LIST, *PMINIDUMP_MEMORY_LIST; + +#define MINIDUMP_MISC1_PROCESS_ID 0x00000001 +#define MINIDUMP_MISC1_PROCESS_TIMES 0x00000002 + +typedef struct _MINIDUMP_MISC_INFO +{ + ULONG SizeOfInfo; + ULONG Flags1; + ULONG ProcessId; + ULONG ProcessCreateTime; + ULONG ProcessUserTime; + ULONG ProcessKernelTime; +} MINIDUMP_MISC_INFO, *PMINIDUMP_MISC_INFO; + typedef struct _MINIDUMP_MODULE { - ULONGLONG BaseOfImage; + ULONG64 BaseOfImage; ULONG SizeOfImage; ULONG CheckSum; ULONG TimeDateStamp; @@ -441,8 +658,8 @@ typedef struct _MINIDUMP_MODULE VS_FIXEDFILEINFO VersionInfo; MINIDUMP_LOCATION_DESCRIPTOR CvRecord; MINIDUMP_LOCATION_DESCRIPTOR MiscRecord; - ULONGLONG Reserved0; - ULONGLONG Reserved1; + ULONG64 Reserved0; + ULONG64 Reserved1; } MINIDUMP_MODULE, *PMINIDUMP_MODULE; typedef struct _MINIDUMP_MODULE_LIST @@ -451,6 +668,76 @@ typedef struct _MINIDUMP_MODULE_LIST MINIDUMP_MODULE Modules[1]; /* FIXME: 0-sized array not supported */ } MINIDUMP_MODULE_LIST, *PMINIDUMP_MODULE_LIST; +typedef struct _MINIDUMP_STRING +{ + ULONG Length; + WCHAR Buffer[1]; /* FIXME: O-sized array not supported */ +} MINIDUMP_STRING, *PMINIDUMP_STRING; + +typedef struct _MINIDUMP_SYSTEM_INFO +{ + USHORT ProcessorArchitecture; + USHORT ProcessorLevel; + USHORT ProcessorRevision; + union + { + USHORT Reserved0; + struct + { + UCHAR NumberOfProcessors; + UCHAR ProductType; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; + + ULONG MajorVersion; + ULONG MinorVersion; + ULONG BuildNumber; + ULONG PlatformId; + + RVA CSDVersionRva; + union + { + ULONG Reserved1; + struct + { + USHORT SuiteMask; + USHORT Reserved2; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME1; + union _CPU_INFORMATION + { + struct + { + ULONG VendorId[3]; + ULONG VersionInformation; + ULONG FeatureInformation; + ULONG AMDExtendedCpuFeatures; + } X86CpuInfo; + struct + { + ULONG64 ProcessorFeatures[2]; + } OtherCpuInfo; + } Cpu; + +} MINIDUMP_SYSTEM_INFO, *PMINIDUMP_SYSTEM_INFO; + +typedef struct _MINIDUMP_THREAD +{ + ULONG ThreadId; + ULONG SuspendCount; + ULONG PriorityClass; + ULONG Priority; + ULONG64 Teb; + MINIDUMP_MEMORY_DESCRIPTOR Stack; + MINIDUMP_LOCATION_DESCRIPTOR ThreadContext; +} MINIDUMP_THREAD, *PMINIDUMP_THREAD; + +typedef struct _MINIDUMP_THREAD_LIST +{ + ULONG NumberOfThreads; + MINIDUMP_THREAD Threads[1]; /* FIXME: no support of 0 sized array */ +} MINIDUMP_THREAD_LIST, *PMINIDUMP_THREAD_LIST; + typedef struct _MINIDUMP_USER_STREAM { ULONG Type; @@ -480,87 +767,57 @@ typedef enum _MINIDUMP_STREAM_TYPE CommentStreamW = 11, HandleDataStream = 12, FunctionTableStream = 13, + UnloadedModuleListStream = 14, + MiscInfoStream = 15, + MemoryInfoListStream = 16, + ThreadInfoListStream = 17, LastReservedStream = 0xffff } MINIDUMP_STREAM_TYPE; -typedef struct _MINIDUMP_SYSTEM_INFO -{ - USHORT ProcessorArchitecture; - USHORT ProcessorLevel; - USHORT ProcessorRevision; - USHORT Reserved0; - - ULONG MajorVersion; - ULONG MinorVersion; - ULONG BuildNumber; - ULONG PlatformId; - - RVA CSDVersionRva; - ULONG Reserved1; - union _CPU_INFORMATION - { - struct - { - ULONG VendorId[3]; - ULONG VersionInformation; - ULONG FeatureInformation; - ULONG AMDExtendedCpuFeatures; - } X86CpuInfo; - struct - { - ULONGLONG ProcessorFeatures[2]; - } OtherCpuInfo; - } Cpu; - -} MINIDUMP_SYSTEM_INFO, *PMINIDUMP_SYSTEM_INFO; - -typedef struct _MINIDUMP_THREAD -{ - ULONG ThreadId; - ULONG SuspendCount; - ULONG PriorityClass; - ULONG Priority; - ULONGLONG Teb; - MINIDUMP_MEMORY_DESCRIPTOR Stack; - MINIDUMP_LOCATION_DESCRIPTOR ThreadContext; -} MINIDUMP_THREAD, *PMINIDUMP_THREAD; - -typedef struct _MINIDUMP_THREAD_LIST -{ - ULONG NumberOfThreads; - MINIDUMP_THREAD Threads[1]; /* FIXME: no support of 0 sized array */ -} MINIDUMP_THREAD_LIST, *PMINIDUMP_THREAD_LIST; - -BOOL WINAPI MiniDumpWriteDump(HANDLE,DWORD,HANDLE,MINIDUMP_TYPE,const PMINIDUMP_EXCEPTION_INFORMATION, - const PMINIDUMP_USER_STREAM_INFORMATION,const PMINIDUMP_CALLBACK_INFORMATION); -BOOL WINAPI MiniDumpReadDumpStream(PVOID,ULONG,PMINIDUMP_DIRECTORY*,PVOID*,ULONG*); +BOOL WINAPI MiniDumpWriteDump(HANDLE, DWORD, HANDLE, MINIDUMP_TYPE, + const PMINIDUMP_EXCEPTION_INFORMATION, + const PMINIDUMP_USER_STREAM_INFORMATION, + const PMINIDUMP_CALLBACK_INFORMATION); +BOOL WINAPI MiniDumpReadDumpStream(PVOID, ULONG, PMINIDUMP_DIRECTORY*, PVOID*, + ULONG*); +#include /************************* * MODULE handling * *************************/ -typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(PSTR ModuleName, DWORD ModuleBase, - ULONG ModuleSize, PVOID UserContext); -BOOL WINAPI EnumerateLoadedModules(HANDLE hProcess, - PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback, - PVOID UserContext); -typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK)(PSTR ModuleName, DWORD BaseOfDll, - PVOID UserContext); -BOOL WINAPI SymEnumerateModules(HANDLE hProcess, - PSYM_ENUMMODULES_CALLBACK EnumModulesCallback, - PVOID UserContext); -BOOL WINAPI SymGetModuleInfo(HANDLE hProcess, DWORD dwAddr, - PIMAGEHLP_MODULE ModuleInfo); -BOOL WINAPI SymGetModuleInfoW(HANDLE hProcess, DWORD dwAddr, - PIMAGEHLP_MODULEW ModuleInfo); -DWORD WINAPI SymGetModuleBase(HANDLE hProcess, DWORD dwAddr); -DWORD WINAPI SymLoadModule(HANDLE hProcess, HANDLE hFile, PSTR ImageName, - PSTR ModuleName, DWORD BaseOfDll, DWORD SizeOfDll); -DWORD64 WINAPI SymLoadModuleEx(HANDLE hProcess, HANDLE hFile, PSTR ImageName, - PSTR ModuleName, DWORD64 BaseOfDll, DWORD DllSize, - PMODLOAD_DATA Data, DWORD Flags); -BOOL WINAPI SymUnloadModule(HANDLE hProcess, DWORD BaseOfDll); + +/* flags for SymLoadModuleEx */ +#define SLMFLAG_VIRTUAL 0x1 +#define SLMFLAG_NO_SYMBOLS 0x4 + +typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(PCSTR, ULONG, ULONG, PVOID); +BOOL WINAPI EnumerateLoadedModules(HANDLE, PENUMLOADED_MODULES_CALLBACK, PVOID); +typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK64)(PCSTR, DWORD64, ULONG, PVOID); +BOOL WINAPI EnumerateLoadedModules64(HANDLE, PENUMLOADED_MODULES_CALLBACK64, PVOID); +typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACKW64)(PCWSTR, DWORD64, ULONG, PVOID); +BOOL WINAPI EnumerateLoadedModulesW64(HANDLE, PENUMLOADED_MODULES_CALLBACKW64, PVOID); +typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK)(PCSTR, ULONG, PVOID); +BOOL WINAPI SymEnumerateModules(HANDLE, PSYM_ENUMMODULES_CALLBACK, PVOID); +typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK64)(PCSTR, DWORD64, PVOID); +BOOL WINAPI SymEnumerateModules64(HANDLE, PSYM_ENUMMODULES_CALLBACK64, PVOID); +typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACKW64)(PCWSTR, DWORD64, PVOID); +BOOL WINAPI SymEnumerateModulesW64(HANDLE, PSYM_ENUMMODULES_CALLBACKW64, PVOID); +BOOL WINAPI SymGetModuleInfo(HANDLE, DWORD, PIMAGEHLP_MODULE); +BOOL WINAPI SymGetModuleInfoW(HANDLE, DWORD, PIMAGEHLP_MODULEW); +BOOL WINAPI SymGetModuleInfo64(HANDLE, DWORD64, PIMAGEHLP_MODULE64); +BOOL WINAPI SymGetModuleInfoW64(HANDLE, DWORD64, PIMAGEHLP_MODULEW64); +DWORD WINAPI SymGetModuleBase(HANDLE, DWORD); +DWORD64 WINAPI SymGetModuleBase64(HANDLE, DWORD64); +DWORD WINAPI SymLoadModule(HANDLE, HANDLE, PCSTR, PCSTR, DWORD, DWORD); +DWORD64 WINAPI SymLoadModule64(HANDLE, HANDLE, PCSTR, PCSTR, DWORD64, DWORD); +DWORD64 WINAPI SymLoadModuleEx(HANDLE, HANDLE, PCSTR, PCSTR, DWORD64, DWORD, + PMODLOAD_DATA, DWORD); +DWORD64 WINAPI SymLoadModuleExW(HANDLE, HANDLE, PCWSTR, PCWSTR, DWORD64, DWORD, + PMODLOAD_DATA, DWORD); +BOOL WINAPI SymUnloadModule(HANDLE, DWORD); +BOOL WINAPI SymUnloadModule64(HANDLE, DWORD64); /************************* * Symbol Handling * @@ -588,6 +845,9 @@ BOOL WINAPI SymUnloadModule(HANDLE hProcess, DWORD BaseOfDll); #define SYMFLAG_VIRTUAL 0x00001000 #define SYMFLAG_THUNK 0x00002000 #define SYMFLAG_TLSREL 0x00004000 +#define SYMFLAG_SLOT 0x00008000 + +#define MAX_SYM_NAME 2000 typedef struct _SYMBOL_INFO { @@ -608,6 +868,37 @@ typedef struct _SYMBOL_INFO CHAR Name[1]; } SYMBOL_INFO, *PSYMBOL_INFO; +typedef struct _SYMBOL_INFOW +{ + ULONG SizeOfStruct; + ULONG TypeIndex; + ULONG64 Reserved[2]; + ULONG Index; + ULONG Size; + ULONG64 ModBase; + ULONG Flags; + ULONG64 Value; + ULONG64 Address; + ULONG Register; + ULONG Scope; + ULONG Tag; + ULONG NameLen; + ULONG MaxNameLen; + WCHAR Name[1]; +} SYMBOL_INFOW, *PSYMBOL_INFOW; + +typedef struct _SYMBOL_INFO_PACKAGE +{ + SYMBOL_INFO si; + CHAR name[MAX_SYM_NAME+1]; +} SYMBOL_INFO_PACKAGE, *PSYMBOL_INFO_PACKAGE; + +typedef struct _SYMBOL_INFO_PACKAGEW +{ + SYMBOL_INFOW si; + WCHAR name[MAX_SYM_NAME+1]; +} SYMBOL_INFO_PACKAGEW, *PSYMBOL_INFO_PACKAGEW; + typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO { TI_GET_SYMTAG, @@ -639,6 +930,30 @@ typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO TI_GET_CALLING_CONVENTION, } IMAGEHLP_SYMBOL_TYPE_INFO; +#define IMAGEHLP_GET_TYPE_INFO_UNCACHED 0x00000001 +#define IMAGEHLP_GET_TYPE_INFO_CHILDREN 0x00000002 +typedef struct _IMAGEHLP_GET_TYPE_INFO_PARAMS +{ + ULONG SizeOfStruct; + ULONG Flags; + ULONG NumIds; + PULONG TypeIds; + ULONG64 TagFilter; + ULONG NumReqs; + IMAGEHLP_SYMBOL_TYPE_INFO* ReqKinds; + PULONG_PTR ReqOffsets; + PULONG ReqSizes; + ULONG_PTR ReqStride; + ULONG_PTR BufferSize; + PVOID Buffer; + ULONG EntriesMatched; + ULONG EntriesFilled; + ULONG64 TagsFound; + ULONG64 AllReqsValid; + ULONG NumReqsValid; + PULONG64 ReqsValid; +} IMAGEHLP_GET_TYPE_INFO_PARAMS, *PIMAGEHLP_GET_TYPE_INFO_PARAMS; + typedef struct _TI_FINDCHILDREN_PARAMS { ULONG Count; @@ -664,101 +979,197 @@ typedef struct _TI_FINDCHILDREN_PARAMS #define UNDNAME_NO_ARGUMENTS (0x2000) #define UNDNAME_NO_SPECIAL_SYMS (0x4000) -BOOL WINAPI SymGetTypeInfo(HANDLE hProcess, DWORD64 ModBase, ULONG TypeId, - IMAGEHLP_SYMBOL_TYPE_INFO GetType, PVOID); -typedef BOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(PSYMBOL_INFO pSymInfo, - ULONG SymbolSize, PVOID UserContext); -BOOL WINAPI SymEnumTypes(HANDLE hProcess, ULONG64 BaseOfDll, - PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, - PVOID UserContext); -BOOL WINAPI SymFromAddr(HANDLE hProcess, DWORD64 addr, DWORD64* displacement, - SYMBOL_INFO* sym_info); -BOOL WINAPI SymFromName(HANDLE hProcess, LPSTR Name, PSYMBOL_INFO Symbol); -BOOL WINAPI SymGetSymFromAddr(HANDLE,DWORD,PDWORD,PIMAGEHLP_SYMBOL); -BOOL WINAPI SymGetSymFromName(HANDLE,PSTR,PIMAGEHLP_SYMBOL); -BOOL WINAPI SymGetTypeFromName(HANDLE hProcess, ULONG64 BaseOfDll, LPSTR Name, - PSYMBOL_INFO Symbol); -BOOL WINAPI SymGetSymNext(HANDLE,PIMAGEHLP_SYMBOL); -BOOL WINAPI SymGetSymPrev(HANDLE,PIMAGEHLP_SYMBOL); -BOOL WINAPI SymEnumSymbols(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR Mask, - PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, - PVOID UserContext); -typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(PSTR SymbolName, DWORD SymbolAddress, - ULONG SymbolSize, PVOID UserContext); -BOOL WINAPI SymEnumerateSymbols(HANDLE hProcess, DWORD BaseOfDll, - PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback, - PVOID UserContext); -typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(HANDLE hProcess, ULONG ActionCode, - PVOID CallbackData, PVOID UserContext); -BOOL WINAPI SymRegisterCallback(HANDLE hProcess, - PSYMBOL_REGISTERED_CALLBACK CallbackFunction, - PVOID UserContext); -BOOL WINAPI SymUnDName(PIMAGEHLP_SYMBOL,PSTR,DWORD); -DWORD WINAPI UnDecorateSymbolName(LPCSTR DecoratedName, LPSTR UnDecoratedName, - DWORD UndecoratedLength, DWORD Flags); +#define SYMSEARCH_MASKOBJS 0x01 +#define SYMSEARCH_RECURSE 0x02 +#define SYMSEARCH_GLOBALSONLY 0x04 + +BOOL WINAPI SymGetTypeInfo(HANDLE, DWORD64, ULONG, IMAGEHLP_SYMBOL_TYPE_INFO, PVOID); +BOOL WINAPI SymGetTypeInfoEx(HANDLE, DWORD64, PIMAGEHLP_GET_TYPE_INFO_PARAMS); +typedef BOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACK)(PSYMBOL_INFO, ULONG, PVOID); +typedef BOOL (CALLBACK *PSYM_ENUMERATESYMBOLS_CALLBACKW)(PSYMBOL_INFOW, ULONG, PVOID); +BOOL WINAPI SymEnumTypes(HANDLE, ULONG64, PSYM_ENUMERATESYMBOLS_CALLBACK, PVOID); +BOOL WINAPI SymEnumTypesW(HANDLE, ULONG64, PSYM_ENUMERATESYMBOLS_CALLBACKW, PVOID); +BOOL WINAPI SymFromAddr(HANDLE, DWORD64, DWORD64*, SYMBOL_INFO*); +BOOL WINAPI SymFromAddrW(HANDLE, DWORD64, DWORD64*, SYMBOL_INFOW*); +BOOL WINAPI SymFromToken(HANDLE, DWORD64, DWORD, PSYMBOL_INFO); +BOOL WINAPI SymFromTokenW(HANDLE, DWORD64, DWORD, PSYMBOL_INFOW); +BOOL WINAPI SymFromName(HANDLE, PCSTR, PSYMBOL_INFO); +BOOL WINAPI SymFromNameW(HANDLE, PCWSTR, PSYMBOL_INFOW); +BOOL WINAPI SymGetSymFromAddr(HANDLE, DWORD, PDWORD, PIMAGEHLP_SYMBOL); +BOOL WINAPI SymGetSymFromAddr64(HANDLE, DWORD64, PDWORD64, PIMAGEHLP_SYMBOL64); +BOOL WINAPI SymGetSymFromName(HANDLE, PCSTR, PIMAGEHLP_SYMBOL); +BOOL WINAPI SymGetSymFromName64(HANDLE, PCSTR, PIMAGEHLP_SYMBOL64); +BOOL WINAPI SymGetTypeFromName(HANDLE, ULONG64, PCSTR, PSYMBOL_INFO); +BOOL WINAPI SymGetTypeFromNameW(HANDLE, ULONG64, PCWSTR, PSYMBOL_INFOW); +BOOL WINAPI SymGetSymNext(HANDLE, PIMAGEHLP_SYMBOL); +BOOL WINAPI SymGetSymNext64(HANDLE, PIMAGEHLP_SYMBOL64); +BOOL WINAPI SymGetSymNextW64(HANDLE, PIMAGEHLP_SYMBOLW64); +BOOL WINAPI SymGetSymPrev(HANDLE, PIMAGEHLP_SYMBOL); +BOOL WINAPI SymGetSymPrev64(HANDLE, PIMAGEHLP_SYMBOL64); +BOOL WINAPI SymGetSymPrevW64(HANDLE, PIMAGEHLP_SYMBOLW64); +BOOL WINAPI SymEnumSym(HANDLE,ULONG64,PSYM_ENUMERATESYMBOLS_CALLBACK,PVOID); +BOOL WINAPI SymEnumSymbols(HANDLE, ULONG64, PCSTR, PSYM_ENUMERATESYMBOLS_CALLBACK, + PVOID); +BOOL WINAPI SymEnumSymbolsW(HANDLE, ULONG64, PCWSTR, PSYM_ENUMERATESYMBOLS_CALLBACKW, + PVOID); +typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(PCSTR, ULONG, ULONG, PVOID); +typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACKW)(PCWSTR, ULONG, ULONG, PVOID); +BOOL WINAPI SymEnumerateSymbols(HANDLE, ULONG, PSYM_ENUMSYMBOLS_CALLBACK, PVOID); +BOOL WINAPI SymEnumerateSymbolsW(HANDLE, ULONG, PSYM_ENUMSYMBOLS_CALLBACKW, PVOID); +typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64)(PCSTR, DWORD64, ULONG, PVOID); +typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK64W)(PCWSTR, DWORD64, ULONG, PVOID); +BOOL WINAPI SymEnumerateSymbols64(HANDLE, ULONG64, PSYM_ENUMSYMBOLS_CALLBACK64, PVOID); +BOOL WINAPI SymEnumerateSymbolsW64(HANDLE, ULONG64, PSYM_ENUMSYMBOLS_CALLBACK64W, PVOID); +BOOL WINAPI SymEnumSymbolsForAddr(HANDLE, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACK, PVOID); +BOOL WINAPI SymEnumSymbolsForAddrW(HANDLE, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACKW, PVOID); +typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(HANDLE, ULONG, PVOID, PVOID); +BOOL WINAPI SymRegisterCallback(HANDLE, PSYMBOL_REGISTERED_CALLBACK, PVOID); +typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK64)(HANDLE, ULONG, ULONG64, ULONG64); +BOOL WINAPI SymRegisterCallback64(HANDLE, PSYMBOL_REGISTERED_CALLBACK64, ULONG64); +BOOL WINAPI SymRegisterCallbackW64(HANDLE, PSYMBOL_REGISTERED_CALLBACK64, ULONG64); +BOOL WINAPI SymUnDName(PIMAGEHLP_SYMBOL, PSTR, DWORD); +BOOL WINAPI SymUnDName64(PIMAGEHLP_SYMBOL64, PSTR, DWORD); +BOOL WINAPI SymMatchString(PCSTR, PCSTR, BOOL); +BOOL WINAPI SymMatchStringA(PCSTR, PCSTR, BOOL); +BOOL WINAPI SymMatchStringW(PCWSTR, PCWSTR, BOOL); +BOOL WINAPI SymSearch(HANDLE, ULONG64, DWORD, DWORD, PCSTR, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACK, PVOID, DWORD); +BOOL WINAPI SymSearchW(HANDLE, ULONG64, DWORD, DWORD, PCWSTR, DWORD64, PSYM_ENUMERATESYMBOLS_CALLBACKW, PVOID, DWORD); +DWORD WINAPI UnDecorateSymbolName(PCSTR, PSTR, DWORD, DWORD); +DWORD WINAPI UnDecorateSymbolNameW(PCWSTR, PWSTR, DWORD, DWORD); +BOOL WINAPI SymGetScope(HANDLE, ULONG64, DWORD, PSYMBOL_INFO); +BOOL WINAPI SymGetScopeW(HANDLE, ULONG64, DWORD, PSYMBOL_INFOW); +BOOL WINAPI SymFromIndex(HANDLE, ULONG64, DWORD, PSYMBOL_INFO); +BOOL WINAPI SymFromIndexW(HANDLE, ULONG64, DWORD, PSYMBOL_INFOW); +BOOL WINAPI SymAddSymbol(HANDLE, ULONG64, PCSTR, DWORD64, DWORD, DWORD); +BOOL WINAPI SymAddSymbolW(HANDLE, ULONG64, PCWSTR, DWORD64, DWORD, DWORD); +BOOL WINAPI SymDeleteSymbol(HANDLE, ULONG64, PCSTR, DWORD64, DWORD); +BOOL WINAPI SymDeleteSymbolW(HANDLE, ULONG64, PCWSTR, DWORD64, DWORD); /************************* * Source Files * *************************/ -typedef BOOL (CALLBACK *PSYM_ENUMSOURCFILES_CALLBACK)(PSOURCEFILE pSourceFile, - PVOID UserContext); +typedef BOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACK)(PSOURCEFILE, PVOID); +typedef BOOL (CALLBACK *PSYM_ENUMSOURCEFILES_CALLBACKW)(PSOURCEFILEW, PVOID); -BOOL WINAPI SymEnumSourceFiles(HANDLE hProcess, ULONG64 ModBase, LPSTR Mask, - PSYM_ENUMSOURCFILES_CALLBACK cbSrcFiles, - PVOID UserContext); -BOOL WINAPI SymGetLineFromAddr(HANDLE hProcess, DWORD dwAddr, - PDWORD pdwDisplacement, PIMAGEHLP_LINE Line); -BOOL WINAPI SymGetLinePrev(HANDLE hProcess, PIMAGEHLP_LINE Line); -BOOL WINAPI SymGetLineNext(HANDLE hProcess, PIMAGEHLP_LINE Line); +BOOL WINAPI SymEnumSourceFiles(HANDLE, ULONG64, PCSTR, PSYM_ENUMSOURCEFILES_CALLBACK, + PVOID); +BOOL WINAPI SymEnumSourceFilesW(HANDLE, ULONG64, PCWSTR, PSYM_ENUMSOURCEFILES_CALLBACKW, PVOID); +BOOL WINAPI SymGetLineFromAddr(HANDLE, DWORD, PDWORD, PIMAGEHLP_LINE); +BOOL WINAPI SymGetLineFromAddrW(HANDLE, DWORD, PDWORD, PIMAGEHLP_LINEW); +BOOL WINAPI SymGetLineFromAddr64(HANDLE, DWORD64, PDWORD, PIMAGEHLP_LINE64); +BOOL WINAPI SymGetLineFromAddrW64(HANDLE, DWORD64, PDWORD, PIMAGEHLP_LINEW64); +BOOL WINAPI SymGetLinePrev(HANDLE, PIMAGEHLP_LINE); +BOOL WINAPI SymGetLinePrevW(HANDLE, PIMAGEHLP_LINEW); +BOOL WINAPI SymGetLinePrev64(HANDLE, PIMAGEHLP_LINE64); +BOOL WINAPI SymGetLinePrevW64(HANDLE, PIMAGEHLP_LINEW64); +BOOL WINAPI SymGetLineNext(HANDLE, PIMAGEHLP_LINE); +BOOL WINAPI SymGetLineNextW(HANDLE, PIMAGEHLP_LINEW); +BOOL WINAPI SymGetLineNext64(HANDLE, PIMAGEHLP_LINE64); +BOOL WINAPI SymGetLineNextW64(HANDLE, PIMAGEHLP_LINEW64); +BOOL WINAPI SymGetLineFromName(HANDLE, PCSTR, PCSTR, DWORD, PLONG, PIMAGEHLP_LINE); +BOOL WINAPI SymGetLineFromName64(HANDLE, PCSTR, PCSTR, DWORD, PLONG, PIMAGEHLP_LINE64); +BOOL WINAPI SymGetLineFromNameW64(HANDLE, PCWSTR, PCWSTR, DWORD, PLONG, PIMAGEHLP_LINEW64); +ULONG WINAPI SymGetFileLineOffsets64(HANDLE, PCSTR, PCSTR, PDWORD64, ULONG); +BOOL WINAPI SymGetSourceFile(HANDLE, ULONG64, PCSTR, PCSTR, PSTR, DWORD); +BOOL WINAPI SymGetSourceFileW(HANDLE, ULONG64, PCWSTR, PCWSTR, PWSTR, DWORD); +BOOL WINAPI SymGetSourceFileToken(HANDLE, ULONG64, PCSTR, PVOID*, DWORD*); +BOOL WINAPI SymGetSourceFileTokenW(HANDLE, ULONG64, PCWSTR, PVOID*, DWORD*); +BOOL WINAPI SymGetSourceFileFromToken(HANDLE, PVOID, PCSTR, PSTR, DWORD); +BOOL WINAPI SymGetSourceFileFromTokenW(HANDLE, PVOID, PCWSTR, PWSTR, DWORD); +BOOL WINAPI SymGetSourceVarFromToken(HANDLE, PVOID, PCSTR, PCSTR, PSTR, DWORD); +BOOL WINAPI SymGetSourceVarFromTokenW(HANDLE, PVOID, PCWSTR, PCWSTR, PWSTR, DWORD); + +typedef struct _SRCCODEINFO +{ + DWORD SizeOfStruct; + PVOID Key; + DWORD64 ModBase; + CHAR Obj[MAX_PATH+1]; + CHAR FileName[MAX_PATH+1]; + DWORD LineNumber; + DWORD64 Address; +} SRCCODEINFO, *PSRCCODEINFO; + +typedef struct _SRCCODEINFOW +{ + DWORD SizeOfStruct; + PVOID Key; + DWORD64 ModBase; + WCHAR Obj[MAX_PATH+1]; + WCHAR FileName[MAX_PATH+1]; + DWORD LineNumber; + DWORD64 Address; +} SRCCODEINFOW, *PSRCCODEINFOW; + +typedef BOOL (CALLBACK* PSYM_ENUMLINES_CALLBACK)(PSRCCODEINFO, PVOID); +typedef BOOL (CALLBACK* PSYM_ENUMLINES_CALLBACKW)(PSRCCODEINFOW, PVOID); +BOOL WINAPI SymEnumLines(HANDLE, ULONG64, PCSTR, PCSTR, PSYM_ENUMLINES_CALLBACK, PVOID); +BOOL WINAPI SymEnumLinesW(HANDLE, ULONG64, PCWSTR, PCWSTR, PSYM_ENUMLINES_CALLBACKW, PVOID); +BOOL WINAPI SymEnumSourceLines(HANDLE, ULONG64, PCSTR, PCSTR, DWORD, DWORD, PSYM_ENUMLINES_CALLBACK, PVOID); +BOOL WINAPI SymEnumSourceLinesW(HANDLE, ULONG64, PCWSTR, PCWSTR, DWORD, DWORD, PSYM_ENUMLINES_CALLBACKW, PVOID); /************************* * File & image handling * *************************/ -BOOL WINAPI SymInitialize(HANDLE hProcess, PSTR UserSearchPath, BOOL fInvadeProcess); -BOOL WINAPI SymCleanup(HANDLE hProcess); +BOOL WINAPI SymInitialize(HANDLE, PCSTR, BOOL); +BOOL WINAPI SymInitializeW(HANDLE, PCWSTR, BOOL); +BOOL WINAPI SymCleanup(HANDLE); -HANDLE WINAPI FindDebugInfoFile(PSTR FileName, PSTR SymbolPath, PSTR DebugFilePath); -typedef BOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACK)(HANDLE FileHandle, PSTR FileName, - PVOID CallerData); -HANDLE WINAPI FindDebugInfoFileEx(PSTR FileName, PSTR SymbolPath, PSTR DebugFilePath, - PFIND_DEBUG_FILE_CALLBACK Callback, PVOID CallerData); -typedef BOOL (CALLBACK *PFINDFILEINPATHCALLBACK)(PSTR filename, PVOID context); - -BOOL WINAPI SymFindFileInPath(HANDLE hProcess, LPSTR searchPath, LPSTR FileName, - PVOID id, DWORD two, DWORD three, DWORD flags, - LPSTR FilePath, PFINDFILEINPATHCALLBACK callback, - PVOID context); -HANDLE WINAPI FindExecutableImage(PSTR FileName, PSTR SymbolPath, PSTR ImageFilePath); -typedef BOOL (CALLBACK *PFIND_EXE_FILE_CALLBACK)(HANDLE FileHandle, PSTR FileName, - PVOID CallerData); -HANDLE WINAPI FindExecutableImageEx(PSTR FileName, PSTR SymbolPath, PSTR ImageFilePath, - PFIND_EXE_FILE_CALLBACK Callback, PVOID CallerData); -PIMAGE_NT_HEADERS WINAPI ImageNtHeader(PVOID Base); - -PVOID WINAPI ImageDirectoryEntryToDataEx(PVOID Base, BOOLEAN MappedAsImage, - USHORT DirectoryEntry, PULONG Size, - PIMAGE_SECTION_HEADER *FoundHeader); -PVOID WINAPI ImageDirectoryEntryToData(PVOID Base, BOOLEAN MappedAsImage, - USHORT DirectoryEntry, PULONG Size); -PIMAGE_SECTION_HEADER WINAPI ImageRvaToSection(PIMAGE_NT_HEADERS NtHeaders, - PVOID Base, ULONG Rva); -PVOID WINAPI ImageRvaToVa(PIMAGE_NT_HEADERS NtHeaders, PVOID Base, - ULONG Rva, OUT PIMAGE_SECTION_HEADER *LastRvaSection); -BOOL WINAPI SymGetSearchPath(HANDLE,PSTR,DWORD); -BOOL WINAPI SymSetSearchPath(HANDLE,PSTR); +HANDLE WINAPI FindDebugInfoFile(PCSTR, PCSTR, PSTR); +typedef BOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACK)(HANDLE, PCSTR, PVOID); +typedef BOOL (CALLBACK *PFIND_DEBUG_FILE_CALLBACKW)(HANDLE, PCWSTR, PVOID); +HANDLE WINAPI FindDebugInfoFileEx(PCSTR, PCSTR, PSTR, PFIND_DEBUG_FILE_CALLBACK, PVOID); +HANDLE WINAPI FindDebugInfoFileExW(PCWSTR, PCWSTR, PWSTR, PFIND_DEBUG_FILE_CALLBACKW, PVOID); +HANDLE WINAPI SymFindDebugInfoFile(HANDLE, PCSTR, PSTR, PFIND_DEBUG_FILE_CALLBACK, PVOID); +HANDLE WINAPI SymFindDebugInfoFileW(HANDLE, PCWSTR, PWSTR, PFIND_DEBUG_FILE_CALLBACKW, PVOID); +typedef BOOL (CALLBACK *PFINDFILEINPATHCALLBACK)(PCSTR, PVOID); +typedef BOOL (CALLBACK *PFINDFILEINPATHCALLBACKW)(PCWSTR, PVOID); +BOOL WINAPI FindFileInPath(HANDLE, PCSTR, PCSTR, PVOID, DWORD, DWORD, DWORD, + PSTR, PFINDFILEINPATHCALLBACK, PVOID); +BOOL WINAPI SymFindFileInPath(HANDLE, PCSTR, PCSTR, PVOID, DWORD, DWORD, DWORD, + PSTR, PFINDFILEINPATHCALLBACK, PVOID); +BOOL WINAPI SymFindFileInPathW(HANDLE, PCWSTR, PCWSTR, PVOID, DWORD, DWORD, DWORD, + PWSTR, PFINDFILEINPATHCALLBACKW, PVOID); +HANDLE WINAPI FindExecutableImage(PCSTR, PCSTR, PSTR); +typedef BOOL (CALLBACK *PFIND_EXE_FILE_CALLBACK)(HANDLE, PCSTR, PVOID); +typedef BOOL (CALLBACK *PFIND_EXE_FILE_CALLBACKW)(HANDLE, PCWSTR, PVOID); +HANDLE WINAPI FindExecutableImageEx(PCSTR, PCSTR, PSTR, PFIND_EXE_FILE_CALLBACK, PVOID); +HANDLE WINAPI FindExecutableImageExW(PCWSTR, PCWSTR, PWSTR, PFIND_EXE_FILE_CALLBACKW, PVOID); +HANDLE WINAPI SymFindExecutableImage(HANDLE, PCSTR, PSTR, PFIND_EXE_FILE_CALLBACK, PVOID); +HANDLE WINAPI SymFindExecutableImageW(HANDLE, PCWSTR, PWSTR, PFIND_EXE_FILE_CALLBACKW, PVOID); +PIMAGE_NT_HEADERS WINAPI ImageNtHeader(PVOID); +PVOID WINAPI ImageDirectoryEntryToDataEx(PVOID, BOOLEAN, USHORT, PULONG, + PIMAGE_SECTION_HEADER *); +PVOID WINAPI ImageDirectoryEntryToData(PVOID, BOOLEAN, USHORT, PULONG); +PIMAGE_SECTION_HEADER WINAPI ImageRvaToSection(PIMAGE_NT_HEADERS, PVOID, ULONG); +PVOID WINAPI ImageRvaToVa(PIMAGE_NT_HEADERS, PVOID, ULONG, PIMAGE_SECTION_HEADER*); +BOOL WINAPI SymGetSearchPath(HANDLE, PSTR, DWORD); +BOOL WINAPI SymGetSearchPathW(HANDLE, PWSTR, DWORD); +BOOL WINAPI SymSetSearchPath(HANDLE, PCSTR); +BOOL WINAPI SymSetSearchPathW(HANDLE, PCWSTR); DWORD WINAPI GetTimestampForLoadedLibrary(HMODULE); BOOL WINAPI MakeSureDirectoryPathExists(PCSTR); -BOOL WINAPI SearchTreeForFile(PSTR,PSTR,PSTR); -typedef BOOL (CALLBACK *PENUMDIRTREE_CALLBACK)(LPCSTR path, PVOID user); -BOOL WINAPI EnumDirTree(HANDLE hProcess, PCSTR root, PCSTR file, - LPSTR buffer, PENUMDIRTREE_CALLBACK cb, void* user); -BOOL WINAPI SymMatchFileName(LPSTR file, LPSTR match, LPSTR* filestop, LPSTR* matchstop); +BOOL WINAPI SearchTreeForFile(PCSTR, PCSTR, PSTR); +BOOL WINAPI SearchTreeForFileW(PCWSTR, PCWSTR, PWSTR); +typedef BOOL (CALLBACK *PENUMDIRTREE_CALLBACK)(PCSTR, PVOID); +typedef BOOL (CALLBACK *PENUMDIRTREE_CALLBACKW)(PCWSTR, PVOID); +BOOL WINAPI EnumDirTree(HANDLE, PCSTR, PCSTR, PSTR, PENUMDIRTREE_CALLBACK, PVOID); +BOOL WINAPI EnumDirTreeW(HANDLE, PCWSTR, PCWSTR, PWSTR, PENUMDIRTREE_CALLBACKW, PVOID); +BOOL WINAPI SymMatchFileName(PCSTR, PCSTR, PSTR*, PSTR*); +BOOL WINAPI SymMatchFileNameW(PCWSTR, PCWSTR, PWSTR*, PWSTR*); +PCHAR WINAPI SymSetHomeDirectory(HANDLE, PCSTR); +PWSTR WINAPI SymSetHomeDirectoryW(HANDLE, PCWSTR); +PCHAR WINAPI SymGetHomeDirectory(DWORD, PSTR, size_t); +PWSTR WINAPI SymGetHomeDirectoryW(DWORD, PWSTR, size_t); +#define hdBase 0 +#define hdSym 1 +#define hdSrc 2 +#define hdMax 3 /************************* * Context management * *************************/ -BOOL WINAPI SymSetContext(HANDLE hProcess, PIMAGEHLP_STACK_FRAME StackFrame, - PIMAGEHLP_CONTEXT Context); +BOOL WINAPI SymSetContext(HANDLE, PIMAGEHLP_STACK_FRAME, PIMAGEHLP_CONTEXT); /************************* @@ -776,6 +1187,19 @@ typedef struct _KDHELP DWORD SystemRangeStart; } KDHELP, *PKDHELP; +typedef struct _KDHELP64 +{ + DWORD64 Thread; + DWORD ThCallbackStack; + DWORD ThCallbackBStore; + DWORD NextCallback; + DWORD FramePointer; + DWORD64 KiCallUserMode; + DWORD64 KeUserCallbackDispatcher; + DWORD64 SystemRangeStart; + DWORD64 Reserved[8]; +} KDHELP64, *PKDHELP64; + typedef struct _STACKFRAME { ADDRESS AddrPC; @@ -788,34 +1212,61 @@ typedef struct _STACKFRAME BOOL Virtual; DWORD Reserved[3]; KDHELP KdHelp; + ADDRESS AddrBStore; } STACKFRAME, *LPSTACKFRAME; +typedef struct _STACKFRAME64 +{ + ADDRESS64 AddrPC; + ADDRESS64 AddrReturn; + ADDRESS64 AddrFrame; + ADDRESS64 AddrStack; + ADDRESS64 AddrBStore; + PVOID FuncTableEntry; + DWORD64 Params[4]; + BOOL Far; + BOOL Virtual; + DWORD64 Reserved[3]; + KDHELP64 KdHelp; +} STACKFRAME64, *LPSTACKFRAME64; + typedef BOOL (CALLBACK *PREAD_PROCESS_MEMORY_ROUTINE) - (HANDLE hProcess, LPCVOID lpBaseAddress, PVOID lpBuffer, - DWORD nSize, PDWORD lpNumberOfBytesRead); + (HANDLE, DWORD, PVOID, DWORD, PDWORD); +typedef PVOID (CALLBACK *PFUNCTION_TABLE_ACCESS_ROUTINE)(HANDLE, DWORD); +typedef DWORD (CALLBACK *PGET_MODULE_BASE_ROUTINE)(HANDLE, DWORD); +typedef DWORD (CALLBACK *PTRANSLATE_ADDRESS_ROUTINE)(HANDLE, HANDLE, LPADDRESS); +BOOL WINAPI StackWalk(DWORD, HANDLE, HANDLE, LPSTACKFRAME, PVOID, + PREAD_PROCESS_MEMORY_ROUTINE, + PFUNCTION_TABLE_ACCESS_ROUTINE, + PGET_MODULE_BASE_ROUTINE, + PTRANSLATE_ADDRESS_ROUTINE); -typedef PVOID (CALLBACK *PFUNCTION_TABLE_ACCESS_ROUTINE) - (HANDLE hProcess, DWORD AddrBase); +typedef BOOL (CALLBACK *PREAD_PROCESS_MEMORY_ROUTINE64) + (HANDLE, DWORD64, PVOID, DWORD, PDWORD); +typedef PVOID (CALLBACK *PFUNCTION_TABLE_ACCESS_ROUTINE64)(HANDLE, DWORD64); +typedef DWORD64 (CALLBACK *PGET_MODULE_BASE_ROUTINE64)(HANDLE, DWORD64); +typedef DWORD64 (CALLBACK *PTRANSLATE_ADDRESS_ROUTINE64)(HANDLE, HANDLE, LPADDRESS64); +BOOL WINAPI StackWalk64(DWORD, HANDLE, HANDLE, LPSTACKFRAME64, PVOID, + PREAD_PROCESS_MEMORY_ROUTINE64, + PFUNCTION_TABLE_ACCESS_ROUTINE64, + PGET_MODULE_BASE_ROUTINE64, + PTRANSLATE_ADDRESS_ROUTINE64); -typedef DWORD (CALLBACK *PGET_MODULE_BASE_ROUTINE) - (HANDLE hProcess, DWORD ReturnAddress); +PVOID WINAPI SymFunctionTableAccess(HANDLE, DWORD); +PVOID WINAPI SymFunctionTableAccess64(HANDLE, DWORD64); -typedef DWORD (CALLBACK *PTRANSLATE_ADDRESS_ROUTINE) - (HANDLE hProcess, HANDLE hThread, LPADDRESS lpaddr); +typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK)(HANDLE, DWORD, PVOID); +typedef PVOID (CALLBACK *PSYMBOL_FUNCENTRY_CALLBACK64)(HANDLE, ULONG64, ULONG64); -BOOL WINAPI StackWalk(DWORD MachineType, HANDLE hProcess, HANDLE hThread, - LPSTACKFRAME StackFrame, PVOID ContextRecord, - PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine, - PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine, - PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine, - PTRANSLATE_ADDRESS_ROUTINE TranslateAddress); - -PVOID WINAPI SymFunctionTableAccess(HANDLE hProcess, DWORD AddrBase); +BOOL WINAPI SymRegisterFunctionEntryCallback(HANDLE, PSYMBOL_FUNCENTRY_CALLBACK, PVOID); +BOOL WINAPI SymRegisterFunctionEntryCallback64(HANDLE, PSYMBOL_FUNCENTRY_CALLBACK64, ULONG64); /************************* * Version, global stuff * *************************/ +#define API_VERSION_NUMBER 9 + typedef struct API_VERSION { USHORT MajorVersion; @@ -825,7 +1276,7 @@ typedef struct API_VERSION } API_VERSION, *LPAPI_VERSION; LPAPI_VERSION WINAPI ImagehlpApiVersion(void); -LPAPI_VERSION WINAPI ImagehlpApiVersionEx(LPAPI_VERSION AppVersion); +LPAPI_VERSION WINAPI ImagehlpApiVersionEx(LPAPI_VERSION); typedef struct _IMAGE_DEBUG_INFORMATION { @@ -863,14 +1314,51 @@ typedef struct _IMAGE_DEBUG_INFORMATION } IMAGE_DEBUG_INFORMATION, *PIMAGE_DEBUG_INFORMATION; -PIMAGE_DEBUG_INFORMATION WINAPI MapDebugInformation(HANDLE FileHandle, PSTR FileName, - PSTR SymbolPath, DWORD ImageBase); +PIMAGE_DEBUG_INFORMATION WINAPI MapDebugInformation(HANDLE, PCSTR, PCSTR, ULONG); -BOOL WINAPI UnmapDebugInformation(PIMAGE_DEBUG_INFORMATION DebugInfo); +BOOL WINAPI UnmapDebugInformation(PIMAGE_DEBUG_INFORMATION); DWORD WINAPI SymGetOptions(void); DWORD WINAPI SymSetOptions(DWORD); +BOOL WINAPI SymSetParentWindow(HWND); + +/************************* + * Version, global stuff * + *************************/ + +typedef BOOL (WINAPI* PSYMBOLSERVERPROC)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR); +typedef BOOL (WINAPI* PSYMBOLSERVERPROCA)(PCSTR, PCSTR, PVOID, DWORD, DWORD, PSTR); +typedef BOOL (WINAPI* PSYMBOLSERVERPROCW)(PCWSTR, PCWSTR, PVOID, DWORD, DWORD, PWSTR); +typedef BOOL (WINAPI* PSYMBOLSERVEROPENPROC)(void); +typedef BOOL (WINAPI* PSYMBOLSERVERCLOSEPROC)(void); +typedef BOOL (WINAPI* PSYMBOLSERVERSETOPTIONSPROC)(UINT_PTR, ULONG64); +typedef BOOL (CALLBACK* PSYMBOLSERVERCALLBACKPROC)(UINT_PTR, ULONG64, ULONG64); +typedef UINT_PTR (WINAPI* PSYMBOLSERVERGETOPTIONSPROC)(void); +typedef BOOL (WINAPI* PSYMBOLSERVERPINGPROC)(PCSTR); +typedef BOOL (WINAPI* PSYMBOLSERVERPINGPROCA)(PCSTR); +typedef BOOL (WINAPI* PSYMBOLSERVERPINGPROCW)(PCWSTR); + +#define SSRVOPT_CALLBACK 0x0001 +#define SSRVOPT_DWORD 0x0002 +#define SSRVOPT_DWORDPTR 0x0004 +#define SSRVOPT_GUIDPTR 0x0008 +#define SSRVOPT_OLDGUIDPTR 0x0010 +#define SSRVOPT_UNATTENDED 0x0020 +#define SSRVOPT_NOCOPY 0x0040 +#define SSRVOPT_PARENTWIN 0x0080 +#define SSRVOPT_PARAMTYPE 0x0100 +#define SSRVOPT_SECURE 0x0200 +#define SSRVOPT_TRACE 0x0400 +#define SSRVOPT_SETCONTEXT 0x0800 +#define SSRVOPT_PROXY 0x1000 +#define SSRVOPT_DOWNSTREAM_STORE 0x2000 +#define SSRVOPT_RESET ((ULONG_PTR)-1) + +#define SSRVACTION_TRACE 1 +#define SSRVACTION_QUERYCANCEL 2 +#define SSRVACTION_EVENT 3 + #ifdef __cplusplus } /* extern "C" */ #endif /* defined(__cplusplus) */ diff --git a/reactos/include/reactos/wine/mscvpdb.h b/reactos/include/reactos/wine/mscvpdb.h new file mode 100644 index 00000000000..1aa70a85f97 --- /dev/null +++ b/reactos/include/reactos/wine/mscvpdb.h @@ -0,0 +1,1714 @@ +/* + * MS debug information definitions. + * + * Copyright (C) 1996 Eric Youngdale + * Copyright (C) 1999-2000 Ulrich Weigand + * Copyright (C) 2004 Eric Pouech + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +/* MS has stored all its debug information in a set of structures + * which has been rather consistent across the years (ie you can grasp + * some continuity, and not so many drastic changes). + * + * A bit of history on the various formats + * MSVC 1.0 PDB v1 (new format for debug info) + * MSVC 2.0 Inclusion in link of debug info (PDB v2) + * MSVC 5.0 Types are 24 bits (instead of 16 for <= 4.x) + * MSVC x.0 PDB (change in internal streams layout) + * + * .DBG Contains COFF, FPO and Codeview info + * .PDB New format for debug info (information is + * derived from Codeview information) + * VCx0.PDB x major MSVC number, stores types, while + * .PDB stores symbols. + * + * Debug information can either be found in the debug section of a PE + * module (in something close to a .DBG file), or the debug section + * can actually refer to an external file, which can be in turn, + * either a .DBG or .PDB file. + * + * Regarding PDB files: + * ------------------- + * They are implemented as a set of internal files (as a small file + * system). The file is split into blocks, an internal file is made + * of a set of blocks. Internal files are accessed through + * numbers. For example, + * 1/ is the ROOT (basic information on the file) + * 2/ is the Symbol information (global symbols, local variables...) + * 3/ is the Type internal file (each the symbols can have type + * information associated with it). + * + * Over the years, three formats existed for the PDB: + * - ?? was rather linked to 16 bit code (our support shall be rather + * bad) + * - JG: it's the signature embedded in the file header. This format + * has been used in MSVC 2.0 => 5.0. + * - DS: it's the signature embedded in the file header. It's the + * current format supported my MS. + * + * Types internal stream + * --------------------- + * Types (from the Type internal file) have existed in three flavors + * (note that those flavors came as historical evolution, but there + * isn't a one to one link between types evolution and PDB formats' + * evolutions: + * - the first flavor (suffixed by V1 in this file), where the types + * and subtypes are 16 bit entities; and where strings are in Pascal + * format (first char is their length and are not 0 terminated) + * - the second flavor (suffixed by V2) differs from first flavor with + * types and subtypes as 32 bit entities. This forced some + * reordering of fields in some types + * - the third flavor (suffixed by V3) differs from second flavor with + * strings stored as C strings (ie are 0 terminated, instead of + * length prefixed) + * The different flavors can coexist in the same file (is this really + * true ??) + * + * For the evolution of types, the need of the second flavor was the + * number of types to be defined (limited to 0xFFFF, including the C + * basic types); the need of the third flavor is the increase of + * symbol size (to be greated than 256), which was likely needed for + * complex C++ types (nested + templates). + * + * It's somehow difficult to represent the layout of those types on + * disk because: + * - some integral values are stored as numeric leaf, which size is + * variable depending on its value + * + * Symbols internal stream + * ----------------------- + * Here also we find three flavors (that we've suffixed with _V1, _V2 + * and _V3) even if their evolution is closer to the evolution of + * types, they are not completely linked together. + */ + +#include "pshpack1.h" + +/* ======================================== * + * Type information + * ======================================== */ + +struct p_string +{ + unsigned char namelen; + char name[1]; +}; + +union codeview_type +{ + struct + { + unsigned short int len; + short int id; + } generic; + + struct + { + unsigned short int len; + short int id; + short int attribute; + short int type; + } modifier_v1; + + struct + { + unsigned short int len; + short int id; + int type; + short int attribute; + } modifier_v2; + + struct + { + unsigned short int len; + short int id; + short int attribute; + short int datatype; + struct p_string p_name; + } pointer_v1; + + struct + { + unsigned short int len; + short int id; + unsigned int datatype; + unsigned int attribute; + struct p_string p_name; + } pointer_v2; + + struct + { + unsigned short int len; + short int id; + short int elemtype; + short int idxtype; + unsigned short int arrlen; /* numeric leaf */ +#if 0 + struct p_string p_name; +#endif + } array_v1; + + struct + { + unsigned short int len; + short int id; + unsigned int elemtype; + unsigned int idxtype; + unsigned short int arrlen; /* numeric leaf */ +#if 0 + struct p_string p_name; +#endif + } array_v2; + + struct + { + unsigned short int len; + short int id; + unsigned int elemtype; + unsigned int idxtype; + unsigned short int arrlen; /* numeric leaf */ +#if 0 + char name[1]; +#endif + } array_v3; + + struct + { + unsigned short int len; + short int id; + short int n_element; + short int fieldlist; + short int property; + short int derived; + short int vshape; + unsigned short int structlen; /* numeric leaf */ +#if 0 + struct p_string p_name; +#endif + } struct_v1; + + struct + { + unsigned short int len; + short int id; + short int n_element; + short int property; + unsigned int fieldlist; + unsigned int derived; + unsigned int vshape; + unsigned short int structlen; /* numeric leaf */ +#if 0 + struct p_string p_name; +#endif + } struct_v2; + + struct + { + unsigned short int len; + short int id; + short int n_element; + short int property; + unsigned int fieldlist; + unsigned int derived; + unsigned int vshape; + unsigned short int structlen; /* numeric leaf */ +#if 0 + char name[1]; +#endif + } struct_v3; + + struct + { + unsigned short int len; + short int id; + short int count; + short int fieldlist; + short int property; + unsigned short int un_len; /* numeric leaf */ +#if 0 + struct p_string p_name; +#endif + } union_v1; + + struct + { + unsigned short int len; + short int id; + short int count; + short int property; + unsigned int fieldlist; + unsigned short int un_len; /* numeric leaf */ +#if 0 + struct p_string p_name; +#endif + } union_v2; + + struct + { + unsigned short int len; + short int id; + short int count; + short int property; + unsigned int fieldlist; + unsigned short int un_len; /* numeric leaf */ +#if 0 + char name[1]; +#endif + } union_v3; + + struct + { + unsigned short int len; + short int id; + short int count; + short int type; + short int fieldlist; + short int property; + struct p_string p_name; + } enumeration_v1; + + struct + { + unsigned short int len; + short int id; + short int count; + short int property; + unsigned int type; + unsigned int fieldlist; + struct p_string p_name; + } enumeration_v2; + + struct + { + unsigned short int len; + short int id; + short int count; + short int property; + unsigned int type; + unsigned int fieldlist; + char name[1]; + } enumeration_v3; + + struct + { + unsigned short int len; + short int id; + unsigned short int rvtype; + unsigned char call; + unsigned char reserved; + unsigned short int params; + unsigned short int arglist; + } procedure_v1; + + struct + { + unsigned short int len; + short int id; + unsigned int rvtype; + unsigned char call; + unsigned char reserved; + unsigned short int params; + unsigned int arglist; + } procedure_v2; + + struct + { + unsigned short int len; + short int id; + unsigned short int rvtype; + unsigned short int class_type; + unsigned short int this_type; + unsigned char call; + unsigned char reserved; + unsigned short int params; + unsigned short int arglist; + unsigned int this_adjust; + } mfunction_v1; + + struct + { + unsigned short int len; + short int id; + unsigned this_type; + unsigned int class_type; + unsigned int rvtype; + unsigned char call; + unsigned char reserved; + unsigned short params; + unsigned int arglist; + unsigned int this_adjust; + } mfunction_v2; +}; + +union codeview_reftype +{ + struct + { + unsigned short int len; + short int id; + } generic; + + struct + { + unsigned short int len; + short int id; + unsigned char list[1]; + } fieldlist; + + struct + { + unsigned short int len; + short int id; + unsigned char nbits; + unsigned char bitoff; + unsigned short type; + } bitfield_v1; + + struct + { + unsigned short int len; + short int id; + unsigned int type; + unsigned char nbits; + unsigned char bitoff; + } bitfield_v2; + + struct + { + unsigned short int len; + short int id; + unsigned short num; + unsigned short args[1]; + } arglist_v1; + + struct + { + unsigned short int len; + short int id; + unsigned num; + unsigned args[1]; + } arglist_v2; + + struct + { + unsigned short int len; + short int id; + unsigned short num; + unsigned short drvdcls[1]; + } derived_v1; + + struct + { + unsigned short int len; + short int id; + unsigned num; + unsigned drvdcls[1]; + } derived_v2; +}; + +union codeview_fieldtype +{ + struct + { + short int id; + } generic; + + struct + { + short int id; + short int type; + short int attribute; + unsigned short int offset; /* numeric leaf */ + } bclass_v1; + + struct + { + short int id; + short int attribute; + unsigned int type; + unsigned short int offset; /* numeric leaf */ + } bclass_v2; + + struct + { + short int id; + short int btype; + short int vbtype; + short int attribute; + unsigned short int vbpoff; /* numeric leaf */ +#if 0 + unsigned short int vboff; /* numeric leaf */ +#endif + } vbclass_v1; + + struct + { + short int id; + short int attribute; + unsigned int btype; + unsigned int vbtype; + unsigned short int vbpoff; /* numeric leaf */ +#if 0 + unsigned short int vboff; /* numeric leaf */ +#endif + } vbclass_v2; + + struct + { + short int id; + short int attribute; + unsigned short int value; /* numeric leaf */ +#if 0 + struct p_string p_name; +#endif + } enumerate_v1; + + struct + { + short int id; + short int attribute; + unsigned short int value; /* numeric leaf */ +#if 0 + char name[1]; +#endif + } enumerate_v3; + + struct + { + short int id; + short int type; + struct p_string p_name; + } friendfcn_v1; + + struct + { + short int id; + short int _pad0; + unsigned int type; + struct p_string p_name; + } friendfcn_v2; + + struct + { + short int id; + short int type; + short int attribute; + unsigned short int offset; /* numeric leaf */ +#if 0 + struct p_string p_name; +#endif + } member_v1; + + struct + { + short int id; + short int attribute; + unsigned int type; + unsigned short int offset; /* numeric leaf */ +#if 0 + struct p_string p_name; +#endif + } member_v2; + + struct + { + short int id; + short int attribute; + unsigned int type; + unsigned short int offset; /* numeric leaf */ +#if 0 + unsigned char name[1]; +#endif + } + member_v3; + + struct + { + short int id; + short int type; + short int attribute; + struct p_string p_name; + } stmember_v1; + + struct + { + short int id; + short int attribute; + unsigned int type; + struct p_string p_name; + } stmember_v2; + + struct + { + short int id; + short int attribute; + unsigned int type; + char name[1]; + } stmember_v3; + + struct + { + short int id; + short int count; + short int mlist; + struct p_string p_name; + } method_v1; + + struct + { + short int id; + short int count; + unsigned int mlist; + struct p_string p_name; + } method_v2; + + struct + { + short int id; + short int count; + unsigned int mlist; + char name[1]; + } method_v3; + + struct + { + short int id; + short int type; + struct p_string p_name; + } nesttype_v1; + + struct + { + short int id; + short int _pad0; + unsigned int type; + struct p_string p_name; + } nesttype_v2; + + struct + { + short int id; + short int _pad0; + unsigned int type; + char name[1]; + } nesttype_v3; + + struct + { + short int id; + short int type; + } vfunctab_v1; + + struct + { + short int id; + short int _pad0; + unsigned int type; + } vfunctab_v2; + + struct + { + short int id; + short int type; + } friendcls_v1; + + struct + { + short int id; + short int _pad0; + unsigned int type; + } friendcls_v2; + + struct + { + short int id; + short int attribute; + short int type; + struct p_string p_name; + } onemethod_v1; + + struct + { + short int id; + short int attribute; + unsigned int type; + struct p_string p_name; + } onemethod_v2; + + struct + { + short int id; + short int attribute; + unsigned int type; + char name[1]; + } onemethod_v3; + + struct + { + short int id; + short int attribute; + short int type; + unsigned int vtab_offset; + struct p_string p_name; + } onemethod_virt_v1; + + struct + { + short int id; + short int attribute; + unsigned int type; + unsigned int vtab_offset; + struct p_string p_name; + } onemethod_virt_v2; + + struct + { + short int id; + short int attribute; + unsigned int type; + unsigned int vtab_offset; + char name[1]; + } onemethod_virt_v3; + + struct + { + short int id; + short int type; + unsigned int offset; + } vfuncoff_v1; + + struct + { + short int id; + short int _pad0; + unsigned int type; + unsigned int offset; + } vfuncoff_v2; + + struct + { + short int id; + short int attribute; + short int type; + struct p_string p_name; + } nesttypeex_v1; + + struct + { + short int id; + short int attribute; + unsigned int type; + struct p_string p_name; + } nesttypeex_v2; + + struct + { + short int id; + short int attribute; + unsigned int type; + struct p_string p_name; + } membermodify_v2; + +}; + + +/* + * This covers the basic datatypes that VC++ seems to be using these days. + * 32 bit mode only. There are additional numbers for the pointers in 16 + * bit mode. There are many other types listed in the documents, but these + * are apparently not used by the compiler, or represent pointer types + * that are not used. + */ +#define T_NOTYPE 0x0000 /* Notype */ +#define T_ABS 0x0001 /* Abs */ +#define T_VOID 0x0003 /* Void */ +#define T_CHAR 0x0010 /* signed char */ +#define T_SHORT 0x0011 /* short */ +#define T_LONG 0x0012 /* long */ +#define T_QUAD 0x0013 /* long long */ +#define T_UCHAR 0x0020 /* unsigned char */ +#define T_USHORT 0x0021 /* unsigned short */ +#define T_ULONG 0x0022 /* unsigned long */ +#define T_UQUAD 0x0023 /* unsigned long long */ +#define T_REAL32 0x0040 /* float */ +#define T_REAL64 0x0041 /* double */ +#define T_RCHAR 0x0070 /* real char */ +#define T_WCHAR 0x0071 /* wide char */ +#define T_INT4 0x0074 /* int */ +#define T_UINT4 0x0075 /* unsigned int */ + +#define T_32PVOID 0x0403 /* 32 bit near pointer to void */ +#define T_32PCHAR 0x0410 /* 16:32 near pointer to signed char */ +#define T_32PSHORT 0x0411 /* 16:32 near pointer to short */ +#define T_32PLONG 0x0412 /* 16:32 near pointer to int */ +#define T_32PQUAD 0x0413 /* 16:32 near pointer to long long */ +#define T_32PUCHAR 0x0420 /* 16:32 near pointer to unsigned char */ +#define T_32PUSHORT 0x0421 /* 16:32 near pointer to unsigned short */ +#define T_32PULONG 0x0422 /* 16:32 near pointer to unsigned int */ +#define T_32PUQUAD 0x0423 /* 16:32 near pointer to long long */ +#define T_32PREAL32 0x0440 /* 16:32 near pointer to float */ +#define T_32PREAL64 0x0441 /* 16:32 near pointer to float */ +#define T_32PRCHAR 0x0470 /* 16:32 near pointer to real char */ +#define T_32PWCHAR 0x0471 /* 16:32 near pointer to real char */ +#define T_32PINT4 0x0474 /* 16:32 near pointer to int */ +#define T_32PUINT4 0x0475 /* 16:32 near pointer to unsigned int */ + + +#define LF_MODIFIER_V1 0x0001 +#define LF_POINTER_V1 0x0002 +#define LF_ARRAY_V1 0x0003 +#define LF_CLASS_V1 0x0004 +#define LF_STRUCTURE_V1 0x0005 +#define LF_UNION_V1 0x0006 +#define LF_ENUM_V1 0x0007 +#define LF_PROCEDURE_V1 0x0008 +#define LF_MFUNCTION_V1 0x0009 +#define LF_VTSHAPE_V1 0x000a +#define LF_COBOL0_V1 0x000b +#define LF_COBOL1_V1 0x000c +#define LF_BARRAY_V1 0x000d +#define LF_LABEL_V1 0x000e +#define LF_NULL_V1 0x000f +#define LF_NOTTRAN_V1 0x0010 +#define LF_DIMARRAY_V1 0x0011 +#define LF_VFTPATH_V1 0x0012 +#define LF_PRECOMP_V1 0x0013 +#define LF_ENDPRECOMP_V1 0x0014 +#define LF_OEM_V1 0x0015 +#define LF_TYPESERVER_V1 0x0016 + +#define LF_MODIFIER_V2 0x1001 /* variants with new 32-bit type indices (V2) */ +#define LF_POINTER_V2 0x1002 +#define LF_ARRAY_V2 0x1003 +#define LF_CLASS_V2 0x1004 +#define LF_STRUCTURE_V2 0x1005 +#define LF_UNION_V2 0x1006 +#define LF_ENUM_V2 0x1007 +#define LF_PROCEDURE_V2 0x1008 +#define LF_MFUNCTION_V2 0x1009 +#define LF_COBOL0_V2 0x100a +#define LF_BARRAY_V2 0x100b +#define LF_DIMARRAY_V2 0x100c +#define LF_VFTPATH_V2 0x100d +#define LF_PRECOMP_V2 0x100e +#define LF_OEM_V2 0x100f + +#define LF_SKIP_V1 0x0200 +#define LF_ARGLIST_V1 0x0201 +#define LF_DEFARG_V1 0x0202 +#define LF_LIST_V1 0x0203 +#define LF_FIELDLIST_V1 0x0204 +#define LF_DERIVED_V1 0x0205 +#define LF_BITFIELD_V1 0x0206 +#define LF_METHODLIST_V1 0x0207 +#define LF_DIMCONU_V1 0x0208 +#define LF_DIMCONLU_V1 0x0209 +#define LF_DIMVARU_V1 0x020a +#define LF_DIMVARLU_V1 0x020b +#define LF_REFSYM_V1 0x020c + +#define LF_SKIP_V2 0x1200 /* variants with new 32-bit type indices (V2) */ +#define LF_ARGLIST_V2 0x1201 +#define LF_DEFARG_V2 0x1202 +#define LF_FIELDLIST_V2 0x1203 +#define LF_DERIVED_V2 0x1204 +#define LF_BITFIELD_V2 0x1205 +#define LF_METHODLIST_V2 0x1206 +#define LF_DIMCONU_V2 0x1207 +#define LF_DIMCONLU_V2 0x1208 +#define LF_DIMVARU_V2 0x1209 +#define LF_DIMVARLU_V2 0x120a + +/* Field lists */ +#define LF_BCLASS_V1 0x0400 +#define LF_VBCLASS_V1 0x0401 +#define LF_IVBCLASS_V1 0x0402 +#define LF_ENUMERATE_V1 0x0403 +#define LF_FRIENDFCN_V1 0x0404 +#define LF_INDEX_V1 0x0405 +#define LF_MEMBER_V1 0x0406 +#define LF_STMEMBER_V1 0x0407 +#define LF_METHOD_V1 0x0408 +#define LF_NESTTYPE_V1 0x0409 +#define LF_VFUNCTAB_V1 0x040a +#define LF_FRIENDCLS_V1 0x040b +#define LF_ONEMETHOD_V1 0x040c +#define LF_VFUNCOFF_V1 0x040d +#define LF_NESTTYPEEX_V1 0x040e +#define LF_MEMBERMODIFY_V1 0x040f + +#define LF_BCLASS_V2 0x1400 /* variants with new 32-bit type indices (V2) */ +#define LF_VBCLASS_V2 0x1401 +#define LF_IVBCLASS_V2 0x1402 +#define LF_FRIENDFCN_V2 0x1403 +#define LF_INDEX_V2 0x1404 +#define LF_MEMBER_V2 0x1405 +#define LF_STMEMBER_V2 0x1406 +#define LF_METHOD_V2 0x1407 +#define LF_NESTTYPE_V2 0x1408 +#define LF_VFUNCTAB_V2 0x1409 +#define LF_FRIENDCLS_V2 0x140a +#define LF_ONEMETHOD_V2 0x140b +#define LF_VFUNCOFF_V2 0x140c +#define LF_NESTTYPEEX_V2 0x140d + +#define LF_ENUMERATE_V3 0x1502 +#define LF_ARRAY_V3 0x1503 +#define LF_CLASS_V3 0x1504 +#define LF_STRUCTURE_V3 0x1505 +#define LF_UNION_V3 0x1506 +#define LF_ENUM_V3 0x1507 +#define LF_MEMBER_V3 0x150d +#define LF_STMEMBER_V3 0x150e +#define LF_METHOD_V3 0x150f +#define LF_NESTTYPE_V3 0x1510 +#define LF_ONEMETHOD_V3 0x1511 + +#define LF_NUMERIC 0x8000 /* numeric leaf types */ +#define LF_CHAR 0x8000 +#define LF_SHORT 0x8001 +#define LF_USHORT 0x8002 +#define LF_LONG 0x8003 +#define LF_ULONG 0x8004 +#define LF_REAL32 0x8005 +#define LF_REAL64 0x8006 +#define LF_REAL80 0x8007 +#define LF_REAL128 0x8008 +#define LF_QUADWORD 0x8009 +#define LF_UQUADWORD 0x800a +#define LF_REAL48 0x800b +#define LF_COMPLEX32 0x800c +#define LF_COMPLEX64 0x800d +#define LF_COMPLEX80 0x800e +#define LF_COMPLEX128 0x800f +#define LF_VARSTRING 0x8010 + +/* ======================================== * + * Symbol information + * ======================================== */ + +union codeview_symbol +{ + struct + { + short int len; + short int id; + } generic; + + struct + { + short int len; + short int id; + unsigned int offset; + unsigned short segment; + unsigned short symtype; + struct p_string p_name; + } data_v1; + + struct + { + short int len; + short int id; + unsigned int symtype; + unsigned int offset; + unsigned short segment; + struct p_string p_name; + } data_v2; + + struct + { + short int len; + short int id; + unsigned int symtype; + unsigned int offset; + unsigned short segment; + char name[1]; + } data_v3; + + struct + { + short int len; + short int id; + unsigned int pparent; + unsigned int pend; + unsigned int next; + unsigned int offset; + unsigned short segment; + unsigned short thunk_len; + unsigned char thtype; + struct p_string p_name; + } thunk_v1; + + struct + { + short int len; + short int id; + unsigned int pparent; + unsigned int pend; + unsigned int next; + unsigned int offset; + unsigned short segment; + unsigned short thunk_len; + unsigned char thtype; + char name[1]; + } thunk_v3; + + struct + { + short int len; + short int id; + unsigned int pparent; + unsigned int pend; + unsigned int next; + unsigned int proc_len; + unsigned int debug_start; + unsigned int debug_end; + unsigned int offset; + unsigned short segment; + unsigned short proctype; + unsigned char flags; + struct p_string p_name; + } proc_v1; + + struct + { + short int len; + short int id; + unsigned int pparent; + unsigned int pend; + unsigned int next; + unsigned int proc_len; + unsigned int debug_start; + unsigned int debug_end; + unsigned int proctype; + unsigned int offset; + unsigned short segment; + unsigned char flags; + struct p_string p_name; + } proc_v2; + + struct + { + short int len; + short int id; + unsigned int pparent; + unsigned int pend; + unsigned int next; + unsigned int proc_len; + unsigned int debug_start; + unsigned int debug_end; + unsigned int proctype; + unsigned int offset; + unsigned short segment; + unsigned char flags; + char name[1]; + } proc_v3; + + struct + { + short int len; + short int id; + unsigned int symtype; + unsigned int offset; + unsigned short segment; + struct p_string p_name; + } public_v2; + + struct + { + short int len; + short int id; + unsigned int symtype; + unsigned int offset; + unsigned short segment; + char name[1]; + } public_v3; + + struct + { + short int len; /* Total length of this entry */ + short int id; /* Always S_BPREL_V1 */ + unsigned int offset; /* Stack offset relative to BP */ + unsigned short symtype; + struct p_string p_name; + } stack_v1; + + struct + { + short int len; /* Total length of this entry */ + short int id; /* Always S_BPREL_V2 */ + unsigned int offset; /* Stack offset relative to EBP */ + unsigned int symtype; + struct p_string p_name; + } stack_v2; + + struct + { + short int len; /* Total length of this entry */ + short int id; /* Always S_BPREL_V3 */ + int offset; /* Stack offset relative to BP */ + unsigned int symtype; + char name[1]; + } stack_v3; + + struct + { + short int len; /* Total length of this entry */ + short int id; /* Always S_REGISTER */ + unsigned short type; + unsigned short reg; + struct p_string p_name; + /* don't handle register tracking */ + } register_v1; + + struct + { + short int len; /* Total length of this entry */ + short int id; /* Always S_REGISTER_V2 */ + unsigned int type; /* check whether type & reg are correct */ + unsigned short reg; + struct p_string p_name; + /* don't handle register tracking */ + } register_v2; + + struct + { + short int len; /* Total length of this entry */ + short int id; /* Always S_REGISTER_V3 */ + unsigned int type; /* check whether type & reg are correct */ + unsigned short reg; + char name[1]; + /* don't handle register tracking */ + } register_v3; + + struct + { + short int len; + short int id; + unsigned int parent; + unsigned int end; + unsigned int length; + unsigned int offset; + unsigned short segment; + struct p_string p_name; + } block_v1; + + struct + { + short int len; + short int id; + unsigned int parent; + unsigned int end; + unsigned int length; + unsigned int offset; + unsigned short segment; + char name[1]; + } block_v3; + + struct + { + short int len; + short int id; + unsigned int offset; + unsigned short segment; + unsigned char flags; + struct p_string p_name; + } label_v1; + + struct + { + short int len; + short int id; + unsigned int offset; + unsigned short segment; + unsigned char flags; + char name[1]; + } label_v3; + + struct + { + short int len; + short int id; + unsigned short type; + unsigned short cvalue; /* numeric leaf */ +#if 0 + struct p_string p_name; +#endif + } constant_v1; + + struct + { + short int len; + short int id; + unsigned type; + unsigned short cvalue; /* numeric leaf */ +#if 0 + struct p_string p_name; +#endif + } constant_v2; + + struct + { + short int len; + short int id; + unsigned type; + unsigned short cvalue; +#if 0 + char name[1]; +#endif + } constant_v3; + + struct + { + short int len; + short int id; + unsigned short type; + struct p_string p_name; + } udt_v1; + + struct + { + short int len; + short int id; + unsigned type; + struct p_string p_name; + } udt_v2; + + struct + { + short int len; + short int id; + unsigned int type; + char name[1]; + } udt_v3; + + struct + { + short int len; + short int id; + char signature[4]; + struct p_string p_name; + } objname_v1; + + struct + { + short int len; + short int id; + unsigned int unknown; + struct p_string p_name; + } compiland_v1; + + struct + { + short int len; + short int id; + unsigned unknown1[4]; + unsigned short unknown2; + struct p_string p_name; + } compiland_v2; + + struct + { + short int len; + short int id; + unsigned int unknown; + char name[1]; + } compiland_v3; + + struct + { + short int len; + short int id; + unsigned int offset; + unsigned short segment; + } ssearch_v1; +}; + +#define S_COMPILAND_V1 0x0001 +#define S_REGISTER_V1 0x0002 +#define S_CONSTANT_V1 0x0003 +#define S_UDT_V1 0x0004 +#define S_SSEARCH_V1 0x0005 +#define S_END_V1 0x0006 +#define S_SKIP_V1 0x0007 +#define S_CVRESERVE_V1 0x0008 +#define S_OBJNAME_V1 0x0009 +#define S_ENDARG_V1 0x000a +#define S_COBOLUDT_V1 0x000b +#define S_MANYREG_V1 0x000c +#define S_RETURN_V1 0x000d +#define S_ENTRYTHIS_V1 0x000e + +#define S_BPREL_V1 0x0200 +#define S_LDATA_V1 0x0201 +#define S_GDATA_V1 0x0202 +#define S_PUB_V1 0x0203 +#define S_LPROC_V1 0x0204 +#define S_GPROC_V1 0x0205 +#define S_THUNK_V1 0x0206 +#define S_BLOCK_V1 0x0207 +#define S_WITH_V1 0x0208 +#define S_LABEL_V1 0x0209 +#define S_CEXMODEL_V1 0x020a +#define S_VFTPATH_V1 0x020b +#define S_REGREL_V1 0x020c +#define S_LTHREAD_V1 0x020d +#define S_GTHREAD_V1 0x020e + +#define S_PROCREF_V1 0x0400 +#define S_DATAREF_V1 0x0401 +#define S_ALIGN_V1 0x0402 +#define S_LPROCREF_V1 0x0403 + +#define S_REGISTER_V2 0x1001 /* Variants with new 32-bit type indices */ +#define S_CONSTANT_V2 0x1002 +#define S_UDT_V2 0x1003 +#define S_COBOLUDT_V2 0x1004 +#define S_MANYREG_V2 0x1005 +#define S_BPREL_V2 0x1006 +#define S_LDATA_V2 0x1007 +#define S_GDATA_V2 0x1008 +#define S_PUB_V2 0x1009 +#define S_LPROC_V2 0x100a +#define S_GPROC_V2 0x100b +#define S_VFTTABLE_V2 0x100c +#define S_REGREL_V2 0x100d +#define S_LTHREAD_V2 0x100e +#define S_GTHREAD_V2 0x100f +#if 0 +#define S_XXXXXXXXX_32 0x1012 /* seems linked to a function, content unknown */ +#endif +#define S_COMPILAND_V2 0x1013 + +#define S_COMPILAND_V3 0x1101 +#define S_THUNK_V3 0x1102 +#define S_BLOCK_V3 0x1103 +#define S_LABEL_V3 0x1105 +#define S_REGISTER_V3 0x1106 +#define S_CONSTANT_V3 0x1107 +#define S_UDT_V3 0x1108 +#define S_BPREL_V3 0x110B +#define S_LDATA_V3 0x110C +#define S_GDATA_V3 0x110D +#define S_PUB_V3 0x110E +#define S_LPROC_V3 0x110F +#define S_GPROC_V3 0x1110 +#define S_MSTOOL_V3 0x1116 /* not really understood */ +#define S_PUB_FUNC1_V3 0x1125 /* didn't get the difference between the two */ +#define S_PUB_FUNC2_V3 0x1127 + +/* ======================================== * + * Line number information + * ======================================== */ + +union any_size +{ + const char* c; + const unsigned char* uc; + const short* s; + const int* i; + const unsigned int* ui; +}; + +struct startend +{ + unsigned int start; + unsigned int end; +}; + +struct codeview_linetab +{ + unsigned int nline; + unsigned int segno; + unsigned int start; + unsigned int end; + unsigned int source; + const unsigned short* linetab; + const unsigned int* offtab; +}; + + +/* ======================================== * + * PDB file information + * ======================================== */ + + +struct PDB_FILE +{ + DWORD size; + DWORD unknown; +}; + +struct PDB_JG_HEADER +{ + CHAR ident[40]; + DWORD signature; + DWORD block_size; + WORD free_list; + WORD total_alloc; + struct PDB_FILE toc; + WORD toc_block[1]; +}; + +struct PDB_DS_HEADER +{ + char signature[32]; + DWORD block_size; + DWORD unknown1; + DWORD num_pages; + DWORD toc_size; + DWORD unknown2; + DWORD toc_page; +}; + +struct PDB_JG_TOC +{ + DWORD num_files; + struct PDB_FILE file[1]; +}; + +struct PDB_DS_TOC +{ + DWORD num_files; + DWORD file_size[1]; +}; + +struct PDB_JG_ROOT +{ + DWORD Version; + DWORD TimeDateStamp; + DWORD Age; + DWORD cbNames; + CHAR names[1]; +}; + +struct PDB_DS_ROOT +{ + DWORD Version; + DWORD TimeDateStamp; + DWORD Age; + GUID guid; + DWORD cbNames; + CHAR names[1]; +}; + +typedef struct _PDB_TYPES_OLD +{ + DWORD version; + WORD first_index; + WORD last_index; + DWORD type_size; + WORD file; + WORD pad; +} PDB_TYPES_OLD, *PPDB_TYPES_OLD; + +typedef struct _PDB_TYPES +{ + DWORD version; + DWORD type_offset; + DWORD first_index; + DWORD last_index; + DWORD type_size; + WORD file; + WORD pad; + DWORD hash_size; + DWORD hash_base; + DWORD hash_offset; + DWORD hash_len; + DWORD search_offset; + DWORD search_len; + DWORD unknown_offset; + DWORD unknown_len; +} PDB_TYPES, *PPDB_TYPES; + +typedef struct _PDB_SYMBOL_RANGE +{ + WORD segment; + WORD pad1; + DWORD offset; + DWORD size; + DWORD characteristics; + WORD index; + WORD pad2; +} PDB_SYMBOL_RANGE, *PPDB_SYMBOL_RANGE; + +typedef struct _PDB_SYMBOL_RANGE_EX +{ + WORD segment; + WORD pad1; + DWORD offset; + DWORD size; + DWORD characteristics; + WORD index; + WORD pad2; + DWORD timestamp; + DWORD unknown; +} PDB_SYMBOL_RANGE_EX, *PPDB_SYMBOL_RANGE_EX; + +typedef struct _PDB_SYMBOL_FILE +{ + DWORD unknown1; + PDB_SYMBOL_RANGE range; + WORD flag; + WORD file; + DWORD symbol_size; + DWORD lineno_size; + DWORD unknown2; + DWORD nSrcFiles; + DWORD attribute; + CHAR filename[1]; +} PDB_SYMBOL_FILE, *PPDB_SYMBOL_FILE; + +typedef struct _PDB_SYMBOL_FILE_EX +{ + DWORD unknown1; + PDB_SYMBOL_RANGE_EX range; + WORD flag; + WORD file; + DWORD symbol_size; + DWORD lineno_size; + DWORD unknown2; + DWORD nSrcFiles; + DWORD attribute; + DWORD reserved[2]; + CHAR filename[1]; +} PDB_SYMBOL_FILE_EX, *PPDB_SYMBOL_FILE_EX; + +typedef struct _PDB_SYMBOL_SOURCE +{ + WORD nModules; + WORD nSrcFiles; + WORD table[1]; +} PDB_SYMBOL_SOURCE, *PPDB_SYMBOL_SOURCE; + +typedef struct _PDB_SYMBOL_IMPORT +{ + DWORD unknown1; + DWORD unknown2; + DWORD TimeDateStamp; + DWORD Age; + CHAR filename[1]; +} PDB_SYMBOL_IMPORT, *PPDB_SYMBOL_IMPORT; + +typedef struct _PDB_SYMBOLS_OLD +{ + WORD hash1_file; + WORD hash2_file; + WORD gsym_file; + WORD pad; + DWORD module_size; + DWORD offset_size; + DWORD hash_size; + DWORD srcmodule_size; +} PDB_SYMBOLS_OLD, *PPDB_SYMBOLS_OLD; + +typedef struct _PDB_SYMBOLS +{ + DWORD signature; + DWORD version; + DWORD unknown; + DWORD hash1_file; + DWORD hash2_file; + DWORD gsym_file; + DWORD module_size; + DWORD offset_size; + DWORD hash_size; + DWORD srcmodule_size; + DWORD pdbimport_size; + DWORD resvd[5]; +} PDB_SYMBOLS, *PPDB_SYMBOLS; + +#include "poppack.h" + +/* ---------------------------------------------- + * Information used for parsing + * ---------------------------------------------- */ + +typedef struct +{ + DWORD from; + DWORD to; +} OMAP_DATA; + +struct msc_debug_info +{ + struct module* module; + int nsect; + const IMAGE_SECTION_HEADER* sectp; + int nomap; + const OMAP_DATA* omapp; + const BYTE* root; +}; + +/* coff.c */ +extern BOOL coff_process_info(const struct msc_debug_info* msc_dbg); + +/* =================================================== + * The old CodeView stuff (for NB09 and NB11) + * =================================================== */ + +#define sstModule 0x120 +#define sstTypes 0x121 +#define sstPublic 0x122 +#define sstPublicSym 0x123 +#define sstSymbols 0x124 +#define sstAlignSym 0x125 +#define sstSrcLnSeg 0x126 +#define sstSrcModule 0x127 +#define sstLibraries 0x128 +#define sstGlobalSym 0x129 +#define sstGlobalPub 0x12a +#define sstGlobalTypes 0x12b +#define sstMPC 0x12c +#define sstSegMap 0x12d +#define sstSegName 0x12e +#define sstPreComp 0x12f +#define sstFileIndex 0x133 +#define sstStaticSym 0x134 + +/* overall structure information */ +typedef struct OMFSignature +{ + char Signature[4]; + long filepos; +} OMFSignature; + +typedef struct OMFSignatureRSDS +{ + char Signature[4]; + GUID guid; + DWORD unknown; + CHAR name[1]; +} OMFSignatureRSDS; + +typedef struct _CODEVIEW_PDB_DATA +{ + char Signature[4]; + long filepos; + DWORD timestamp; + DWORD unknown; + CHAR name[1]; +} CODEVIEW_PDB_DATA, *PCODEVIEW_PDB_DATA; + +typedef struct OMFDirHeader +{ + WORD cbDirHeader; + WORD cbDirEntry; + DWORD cDir; + DWORD lfoNextDir; + DWORD flags; +} OMFDirHeader; + +typedef struct OMFDirEntry +{ + WORD SubSection; + WORD iMod; + DWORD lfo; + DWORD cb; +} OMFDirEntry; + +/* sstModule subsection */ + +typedef struct OMFSegDesc +{ + WORD Seg; + WORD pad; + DWORD Off; + DWORD cbSeg; +} OMFSegDesc; + +typedef struct OMFModule +{ + WORD ovlNumber; + WORD iLib; + WORD cSeg; + char Style[2]; +/* + OMFSegDesc SegInfo[cSeg]; + p_string Name; +*/ +} OMFModule; + +typedef struct OMFGlobalTypes +{ + DWORD flags; + DWORD cTypes; +/* + DWORD offset[cTypes]; + types_record[]; +*/ +} OMFGlobalTypes; + +/* sstGlobalPub section */ + +/* Header for symbol table */ +typedef struct OMFSymHash +{ + unsigned short symhash; + unsigned short addrhash; + unsigned long cbSymbol; + unsigned long cbHSym; + unsigned long cbHAddr; +} OMFSymHash; + +/* sstSegMap section */ + +typedef struct OMFSegMapDesc +{ + unsigned short flags; + unsigned short ovl; + unsigned short group; + unsigned short frame; + unsigned short iSegName; + unsigned short iClassName; + unsigned long offset; + unsigned long cbSeg; +} OMFSegMapDesc; + +typedef struct OMFSegMap +{ + unsigned short cSeg; + unsigned short cSegLog; +/* OMFSegMapDesc rgDesc[0];*/ +} OMFSegMap; + + +/* sstSrcModule section */ + +typedef struct OMFSourceLine +{ + unsigned short Seg; + unsigned short cLnOff; + unsigned long offset[1]; + unsigned short lineNbr[1]; +} OMFSourceLine; + +typedef struct OMFSourceFile +{ + unsigned short cSeg; + unsigned short reserved; + unsigned long baseSrcLn[1]; + unsigned short cFName; + char Name; +} OMFSourceFile; + +typedef struct OMFSourceModule +{ + unsigned short cFile; + unsigned short cSeg; + unsigned long baseSrcFile[1]; +} OMFSourceModule; diff --git a/reactos/include/reactos/wine/regex.h b/reactos/include/reactos/wine/regex.h new file mode 100644 index 00000000000..2bca5378a41 --- /dev/null +++ b/reactos/include/reactos/wine/regex.h @@ -0,0 +1,572 @@ +/* Definitions for data structures and routines for the regular + expression library, version 0.12. + Copyright (C) 1985,89,90,91,92,93,95,96,97,98 Free Software Foundation, Inc. + + This file is part of the GNU C Library. Its master source is NOT part of + the C library, however. The master source lives in /gd/gnu/lib. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with the GNU C Library; see the file COPYING.LIB. If not, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +#ifndef _REGEX_H +#define _REGEX_H 1 + +/* Allow the use in C++ code. */ +#ifdef __cplusplus +extern "C" { +#endif + +/* POSIX says that must be included (by the caller) before + . */ + +#if !defined _POSIX_C_SOURCE && !defined _POSIX_SOURCE && defined VMS +/* VMS doesn't have `size_t' in , even though POSIX says it + should be there. */ +# include +#endif + +/* The following two types have to be signed and unsigned integer type + wide enough to hold a value of a pointer. For most ANSI compilers + ptrdiff_t and size_t should be likely OK. Still size of these two + types is 2 for Microsoft C. Ugh... */ +typedef long int s_reg_t; +typedef unsigned long int active_reg_t; + +/* The following bits are used to determine the regexp syntax we + recognize. The set/not-set meanings are chosen so that Emacs syntax + remains the value 0. The bits are given in alphabetical order, and + the definitions shifted by one from the previous bit; thus, when we + add or remove a bit, only one other definition need change. */ +typedef unsigned long int reg_syntax_t; + +/* If this bit is not set, then \ inside a bracket expression is literal. + If set, then such a \ quotes the following character. */ +#define RE_BACKSLASH_ESCAPE_IN_LISTS ((unsigned long int) 1) + +/* If this bit is not set, then + and ? are operators, and \+ and \? are + literals. + If set, then \+ and \? are operators and + and ? are literals. */ +#define RE_BK_PLUS_QM (RE_BACKSLASH_ESCAPE_IN_LISTS << 1) + +/* If this bit is set, then character classes are supported. They are: + [:alpha:], [:upper:], [:lower:], [:digit:], [:alnum:], [:xdigit:], + [:space:], [:print:], [:punct:], [:graph:], and [:cntrl:]. + If not set, then character classes are not supported. */ +#define RE_CHAR_CLASSES (RE_BK_PLUS_QM << 1) + +/* If this bit is set, then ^ and $ are always anchors (outside bracket + expressions, of course). + If this bit is not set, then it depends: + ^ is an anchor if it is at the beginning of a regular + expression or after an open-group or an alternation operator; + $ is an anchor if it is at the end of a regular expression, or + before a close-group or an alternation operator. + + This bit could be (re)combined with RE_CONTEXT_INDEP_OPS, because + POSIX draft 11.2 says that * etc. in leading positions is undefined. + We already implemented a previous draft which made those constructs + invalid, though, so we haven't changed the code back. */ +#define RE_CONTEXT_INDEP_ANCHORS (RE_CHAR_CLASSES << 1) + +/* If this bit is set, then special characters are always special + regardless of where they are in the pattern. + If this bit is not set, then special characters are special only in + some contexts; otherwise they are ordinary. Specifically, + * + ? and intervals are only special when not after the beginning, + open-group, or alternation operator. */ +#define RE_CONTEXT_INDEP_OPS (RE_CONTEXT_INDEP_ANCHORS << 1) + +/* If this bit is set, then *, +, ?, and { cannot be first in an re or + immediately after an alternation or begin-group operator. */ +#define RE_CONTEXT_INVALID_OPS (RE_CONTEXT_INDEP_OPS << 1) + +/* If this bit is set, then . matches newline. + If not set, then it doesn't. */ +#define RE_DOT_NEWLINE (RE_CONTEXT_INVALID_OPS << 1) + +/* If this bit is set, then . doesn't match NUL. + If not set, then it does. */ +#define RE_DOT_NOT_NULL (RE_DOT_NEWLINE << 1) + +/* If this bit is set, nonmatching lists [^...] do not match newline. + If not set, they do. */ +#define RE_HAT_LISTS_NOT_NEWLINE (RE_DOT_NOT_NULL << 1) + +/* If this bit is set, either \{...\} or {...} defines an + interval, depending on RE_NO_BK_BRACES. + If not set, \{, \}, {, and } are literals. */ +#define RE_INTERVALS (RE_HAT_LISTS_NOT_NEWLINE << 1) + +/* If this bit is set, +, ? and | aren't recognized as operators. + If not set, they are. */ +#define RE_LIMITED_OPS (RE_INTERVALS << 1) + +/* If this bit is set, newline is an alternation operator. + If not set, newline is literal. */ +#define RE_NEWLINE_ALT (RE_LIMITED_OPS << 1) + +/* If this bit is set, then `{...}' defines an interval, and \{ and \} + are literals. + If not set, then `\{...\}' defines an interval. */ +#define RE_NO_BK_BRACES (RE_NEWLINE_ALT << 1) + +/* If this bit is set, (...) defines a group, and \( and \) are literals. + If not set, \(...\) defines a group, and ( and ) are literals. */ +#define RE_NO_BK_PARENS (RE_NO_BK_BRACES << 1) + +/* If this bit is set, then \ matches . + If not set, then \ is a back-reference. */ +#define RE_NO_BK_REFS (RE_NO_BK_PARENS << 1) + +/* If this bit is set, then | is an alternation operator, and \| is literal. + If not set, then \| is an alternation operator, and | is literal. */ +#define RE_NO_BK_VBAR (RE_NO_BK_REFS << 1) + +/* If this bit is set, then an ending range point collating higher + than the starting range point, as in [z-a], is invalid. + If not set, then when ending range point collates higher than the + starting range point, the range is ignored. */ +#define RE_NO_EMPTY_RANGES (RE_NO_BK_VBAR << 1) + +/* If this bit is set, then an unmatched ) is ordinary. + If not set, then an unmatched ) is invalid. */ +#define RE_UNMATCHED_RIGHT_PAREN_ORD (RE_NO_EMPTY_RANGES << 1) + +/* If this bit is set, succeed as soon as we match the whole pattern, + without further backtracking. */ +#define RE_NO_POSIX_BACKTRACKING (RE_UNMATCHED_RIGHT_PAREN_ORD << 1) + +/* If this bit is set, do not process the GNU regex operators. + If not set, then the GNU regex operators are recognized. */ +#define RE_NO_GNU_OPS (RE_NO_POSIX_BACKTRACKING << 1) + +/* If this bit is set, turn on internal regex debugging. + If not set, and debugging was on, turn it off. + This only works if regex.c is compiled -DDEBUG. + We define this bit always, so that all that's needed to turn on + debugging is to recompile regex.c; the calling code can always have + this bit set, and it won't affect anything in the normal case. */ +#define RE_DEBUG (RE_NO_GNU_OPS << 1) + +/* This global variable defines the particular regexp syntax to use (for + some interfaces). When a regexp is compiled, the syntax used is + stored in the pattern buffer, so changing this does not affect + already-compiled regexps. */ +extern reg_syntax_t re_syntax_options; + +/* Define combinations of the above bits for the standard possibilities. + (The [[[ comments delimit what gets put into the Texinfo file, so + don't delete them!) */ +/* [[[begin syntaxes]]] */ +#define RE_SYNTAX_EMACS 0 + +#define RE_SYNTAX_AWK \ + (RE_BACKSLASH_ESCAPE_IN_LISTS | RE_DOT_NOT_NULL \ + | RE_NO_BK_PARENS | RE_NO_BK_REFS \ + | RE_NO_BK_VBAR | RE_NO_EMPTY_RANGES \ + | RE_DOT_NEWLINE | RE_CONTEXT_INDEP_ANCHORS \ + | RE_UNMATCHED_RIGHT_PAREN_ORD | RE_NO_GNU_OPS) + +#define RE_SYNTAX_GNU_AWK \ + ((RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS | RE_DEBUG) \ + & ~(RE_DOT_NOT_NULL | RE_INTERVALS | RE_CONTEXT_INDEP_OPS)) + +#define RE_SYNTAX_POSIX_AWK \ + (RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS \ + | RE_INTERVALS | RE_NO_GNU_OPS) + +#define RE_SYNTAX_GREP \ + (RE_BK_PLUS_QM | RE_CHAR_CLASSES \ + | RE_HAT_LISTS_NOT_NEWLINE | RE_INTERVALS \ + | RE_NEWLINE_ALT) + +#define RE_SYNTAX_EGREP \ + (RE_CHAR_CLASSES | RE_CONTEXT_INDEP_ANCHORS \ + | RE_CONTEXT_INDEP_OPS | RE_HAT_LISTS_NOT_NEWLINE \ + | RE_NEWLINE_ALT | RE_NO_BK_PARENS \ + | RE_NO_BK_VBAR) + +#define RE_SYNTAX_POSIX_EGREP \ + (RE_SYNTAX_EGREP | RE_INTERVALS | RE_NO_BK_BRACES) + +/* P1003.2/D11.2, section 4.20.7.1, lines 5078ff. */ +#define RE_SYNTAX_ED RE_SYNTAX_POSIX_BASIC + +#define RE_SYNTAX_SED RE_SYNTAX_POSIX_BASIC + +/* Syntax bits common to both basic and extended POSIX regex syntax. */ +#define _RE_SYNTAX_POSIX_COMMON \ + (RE_CHAR_CLASSES | RE_DOT_NEWLINE | RE_DOT_NOT_NULL \ + | RE_INTERVALS | RE_NO_EMPTY_RANGES) + +#define RE_SYNTAX_POSIX_BASIC \ + (_RE_SYNTAX_POSIX_COMMON | RE_BK_PLUS_QM) + +/* Differs from ..._POSIX_BASIC only in that RE_BK_PLUS_QM becomes + RE_LIMITED_OPS, i.e., \? \+ \| are not recognized. Actually, this + isn't minimal, since other operators, such as \`, aren't disabled. */ +#define RE_SYNTAX_POSIX_MINIMAL_BASIC \ + (_RE_SYNTAX_POSIX_COMMON | RE_LIMITED_OPS) + +#define RE_SYNTAX_POSIX_EXTENDED \ + (_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS \ + | RE_CONTEXT_INDEP_OPS | RE_NO_BK_BRACES \ + | RE_NO_BK_PARENS | RE_NO_BK_VBAR \ + | RE_UNMATCHED_RIGHT_PAREN_ORD) + +/* Differs from ..._POSIX_EXTENDED in that RE_CONTEXT_INVALID_OPS + replaces RE_CONTEXT_INDEP_OPS and RE_NO_BK_REFS is added. */ +#define RE_SYNTAX_POSIX_MINIMAL_EXTENDED \ + (_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS \ + | RE_CONTEXT_INVALID_OPS | RE_NO_BK_BRACES \ + | RE_NO_BK_PARENS | RE_NO_BK_REFS \ + | RE_NO_BK_VBAR | RE_UNMATCHED_RIGHT_PAREN_ORD) +/* [[[end syntaxes]]] */ + +/* Maximum number of duplicates an interval can allow. Some systems + (erroneously) define this in other header files, but we want our + value, so remove any previous define. */ +#ifdef RE_DUP_MAX +# undef RE_DUP_MAX +#endif +/* If sizeof(int) == 2, then ((1 << 15) - 1) overflows. */ +#define RE_DUP_MAX (0x7fff) + + +/* POSIX `cflags' bits (i.e., information for `regcomp'). */ + +/* If this bit is set, then use extended regular expression syntax. + If not set, then use basic regular expression syntax. */ +#define REG_EXTENDED 1 + +/* If this bit is set, then ignore case when matching. + If not set, then case is significant. */ +#define REG_ICASE (REG_EXTENDED << 1) + +/* If this bit is set, then anchors do not match at newline + characters in the string. + If not set, then anchors do match at newlines. */ +#define REG_NEWLINE (REG_ICASE << 1) + +/* If this bit is set, then report only success or fail in regexec. + If not set, then returns differ between not matching and errors. */ +#define REG_NOSUB (REG_NEWLINE << 1) + + +/* POSIX `eflags' bits (i.e., information for regexec). */ + +/* If this bit is set, then the beginning-of-line operator doesn't match + the beginning of the string (presumably because it's not the + beginning of a line). + If not set, then the beginning-of-line operator does match the + beginning of the string. */ +#define REG_NOTBOL 1 + +/* Like REG_NOTBOL, except for the end-of-line. */ +#define REG_NOTEOL (1 << 1) + + +/* If any error codes are removed, changed, or added, update the + `re_error_msg' table in regex.c. */ +typedef enum +{ +#ifdef _XOPEN_SOURCE + REG_ENOSYS = -1, /* This will never happen for this implementation. */ +#endif + + REG_NOERROR = 0, /* Success. */ + REG_NOMATCH, /* Didn't find a match (for regexec). */ + + /* POSIX regcomp return error codes. (In the order listed in the + standard.) */ + REG_BADPAT, /* Invalid pattern. */ + REG_ECOLLATE, /* Not implemented. */ + REG_ECTYPE, /* Invalid character class name. */ + REG_EESCAPE, /* Trailing backslash. */ + REG_ESUBREG, /* Invalid back reference. */ + REG_EBRACK, /* Unmatched left bracket. */ + REG_EPAREN, /* Parenthesis imbalance. */ + REG_EBRACE, /* Unmatched \{. */ + REG_BADBR, /* Invalid contents of \{\}. */ + REG_ERANGE, /* Invalid range end. */ + REG_ESPACE, /* Ran out of memory. */ + REG_BADRPT, /* No preceding re for repetition op. */ + + /* Error codes we've added. */ + REG_EEND, /* Premature end. */ + REG_ESIZE, /* Compiled pattern bigger than 2^16 bytes. */ + REG_ERPAREN /* Unmatched ) or \); not returned from regcomp. */ +} reg_errcode_t; + +/* This data structure represents a compiled pattern. Before calling + the pattern compiler, the fields `buffer', `allocated', `fastmap', + `translate', and `no_sub' can be set. After the pattern has been + compiled, the `re_nsub' field is available. All other fields are + private to the regex routines. */ + +#ifndef RE_TRANSLATE_TYPE +# define RE_TRANSLATE_TYPE char * +#endif + +struct re_pattern_buffer +{ +/* [[[begin pattern_buffer]]] */ + /* Space that holds the compiled pattern. It is declared as + `unsigned char *' because its elements are + sometimes used as array indexes. */ + unsigned char *buffer; + + /* Number of bytes to which `buffer' points. */ + unsigned long int allocated; + + /* Number of bytes actually used in `buffer'. */ + unsigned long int used; + + /* Syntax setting with which the pattern was compiled. */ + reg_syntax_t syntax; + + /* Pointer to a fastmap, if any, otherwise zero. re_search uses + the fastmap, if there is one, to skip over impossible + starting points for matches. */ + char *fastmap; + + /* Either a translate table to apply to all characters before + comparing them, or zero for no translation. The translation + is applied to a pattern when it is compiled and to a string + when it is matched. */ + RE_TRANSLATE_TYPE translate; + + /* Number of subexpressions found by the compiler. */ + size_t re_nsub; + + /* Zero if this pattern cannot match the empty string, one else. + Well, in truth it's used only in `re_search_2', to see + whether or not we should use the fastmap, so we don't set + this absolutely perfectly; see `re_compile_fastmap' (the + `duplicate' case). */ + unsigned can_be_null : 1; + + /* If REGS_UNALLOCATED, allocate space in the `regs' structure + for `max (RE_NREGS, re_nsub + 1)' groups. + If REGS_REALLOCATE, reallocate space if necessary. + If REGS_FIXED, use what's there. */ +#define REGS_UNALLOCATED 0 +#define REGS_REALLOCATE 1 +#define REGS_FIXED 2 + unsigned regs_allocated : 2; + + /* Set to zero when `regex_compile' compiles a pattern; set to one + by `re_compile_fastmap' if it updates the fastmap. */ + unsigned fastmap_accurate : 1; + + /* If set, `re_match_2' does not return information about + subexpressions. */ + unsigned no_sub : 1; + + /* If set, a beginning-of-line anchor doesn't match at the + beginning of the string. */ + unsigned not_bol : 1; + + /* Similarly for an end-of-line anchor. */ + unsigned not_eol : 1; + + /* If true, an anchor at a newline matches. */ + unsigned newline_anchor : 1; + +/* [[[end pattern_buffer]]] */ +}; + +typedef struct re_pattern_buffer regex_t; + +/* Type for byte offsets within the string. POSIX mandates this. */ +typedef int regoff_t; + + +/* This is the structure we store register match data in. See + regex.texinfo for a full description of what registers match. */ +struct re_registers +{ + unsigned num_regs; + regoff_t *start; + regoff_t *end; +}; + + +/* If `regs_allocated' is REGS_UNALLOCATED in the pattern buffer, + `re_match_2' returns information about at least this many registers + the first time a `regs' structure is passed. */ +#ifndef RE_NREGS +# define RE_NREGS 30 +#endif + + +/* POSIX specification for registers. Aside from the different names than + `re_registers', POSIX uses an array of structures, instead of a + structure of arrays. */ +typedef struct +{ + regoff_t rm_so; /* Byte offset from string's start to substring's start. */ + regoff_t rm_eo; /* Byte offset from string's start to substring's end. */ +} regmatch_t; + +/* Declarations for routines. */ + +/* To avoid duplicating every routine declaration -- once with a + prototype (if we are ANSI), and once without (if we aren't) -- we + use the following macro to declare argument types. This + unfortunately clutters up the declarations a bit, but I think it's + worth it. */ + +#if __STDC__ + +# define _RE_ARGS(args) args + +#else /* not __STDC__ */ + +# define _RE_ARGS(args) () + +#endif /* not __STDC__ */ + +/* Sets the current default syntax to SYNTAX, and return the old syntax. + You can also simply assign to the `re_syntax_options' variable. */ +extern reg_syntax_t __re_set_syntax _RE_ARGS ((reg_syntax_t syntax)); +extern reg_syntax_t re_set_syntax _RE_ARGS ((reg_syntax_t syntax)); + +/* Compile the regular expression PATTERN, with length LENGTH + and syntax given by the global `re_syntax_options', into the buffer + BUFFER. Return NULL if successful, and an error string if not. */ +extern const char *__re_compile_pattern + _RE_ARGS ((const char *pattern, size_t length, + struct re_pattern_buffer *buffer)); +extern const char *re_compile_pattern + _RE_ARGS ((const char *pattern, size_t length, + struct re_pattern_buffer *buffer)); + + +/* Compile a fastmap for the compiled pattern in BUFFER; used to + accelerate searches. Return 0 if successful and -2 if was an + internal error. */ +extern int __re_compile_fastmap _RE_ARGS ((struct re_pattern_buffer *buffer)); +extern int re_compile_fastmap _RE_ARGS ((struct re_pattern_buffer *buffer)); + + +/* Search in the string STRING (with length LENGTH) for the pattern + compiled into BUFFER. Start searching at position START, for RANGE + characters. Return the starting position of the match, -1 for no + match, or -2 for an internal error. Also return register + information in REGS (if REGS and BUFFER->no_sub are nonzero). */ +extern int __re_search + _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string, + int length, int start, int range, struct re_registers *regs)); +extern int re_search + _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string, + int length, int start, int range, struct re_registers *regs)); + + +/* Like `re_search', but search in the concatenation of STRING1 and + STRING2. Also, stop searching at index START + STOP. */ +extern int __re_search_2 + _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1, + int length1, const char *string2, int length2, + int start, int range, struct re_registers *regs, int stop)); +extern int re_search_2 + _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1, + int length1, const char *string2, int length2, + int start, int range, struct re_registers *regs, int stop)); + + +/* Like `re_search', but return how many characters in STRING the regexp + in BUFFER matched, starting at position START. */ +extern int __re_match + _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string, + int length, int start, struct re_registers *regs)); +extern int re_match + _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string, + int length, int start, struct re_registers *regs)); + + +/* Relates to `re_match' as `re_search_2' relates to `re_search'. */ +extern int __re_match_2 + _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1, + int length1, const char *string2, int length2, + int start, struct re_registers *regs, int stop)); +extern int re_match_2 + _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1, + int length1, const char *string2, int length2, + int start, struct re_registers *regs, int stop)); + + +/* Set REGS to hold NUM_REGS registers, storing them in STARTS and + ENDS. Subsequent matches using BUFFER and REGS will use this memory + for recording register information. STARTS and ENDS must be + allocated with malloc, and must each be at least `NUM_REGS * sizeof + (regoff_t)' bytes long. + + If NUM_REGS == 0, then subsequent matches should allocate their own + register data. + + Unless this function is called, the first search or match using + PATTERN_BUFFER will allocate its own register data, without + freeing the old data. */ +extern void __re_set_registers + _RE_ARGS ((struct re_pattern_buffer *buffer, struct re_registers *regs, + unsigned num_regs, regoff_t *starts, regoff_t *ends)); +extern void re_set_registers + _RE_ARGS ((struct re_pattern_buffer *buffer, struct re_registers *regs, + unsigned num_regs, regoff_t *starts, regoff_t *ends)); + +#ifdef _REGEX_RE_COMP +# ifndef _CRAY +/* 4.2 bsd compatibility. */ +extern char *re_comp _RE_ARGS ((const char *)); +extern int re_exec _RE_ARGS ((const char *)); +# endif +#endif + +/* POSIX compatibility. */ +extern int __regcomp _RE_ARGS ((regex_t *__preg, const char *__pattern, + int __cflags)); +extern int regcomp _RE_ARGS ((regex_t *__preg, const char *__pattern, + int __cflags)); + +extern int __regexec _RE_ARGS ((const regex_t *__preg, + const char *__string, size_t __nmatch, + regmatch_t __pmatch[], int __eflags)); +extern int regexec _RE_ARGS ((const regex_t *__preg, + const char *__string, size_t __nmatch, + regmatch_t __pmatch[], int __eflags)); + +extern size_t __regerror _RE_ARGS ((int __errcode, const regex_t *__preg, + char *__errbuf, size_t __errbuf_size)); +extern size_t regerror _RE_ARGS ((int __errcode, const regex_t *__preg, + char *__errbuf, size_t __errbuf_size)); + +extern void __regfree _RE_ARGS ((regex_t *__preg)); +extern void regfree _RE_ARGS ((regex_t *__preg)); + + +#ifdef __cplusplus +} +#endif /* C++ */ + +#endif /* regex.h */ + +/* +Local variables: +make-backup-files: t +version-control: t +trim-versions-without-asking: nil +End: +*/ diff --git a/reactos/include/reactos/wine/winbase.h b/reactos/include/reactos/wine/winbase.h new file mode 100644 index 00000000000..10280329e7c --- /dev/null +++ b/reactos/include/reactos/wine/winbase.h @@ -0,0 +1,15 @@ +#ifndef __WINE_WINBASE_H +#define __WINE_WINBASE_H + +#include_next + +/* undocumented functions */ + +typedef struct tagSYSLEVEL +{ + CRITICAL_SECTION crst; + INT level; +} SYSLEVEL; + + +#endif /* __WINE_WINBASE_H */ diff --git a/reactos/include/reactos/wine/winbase16.h b/reactos/include/reactos/wine/winbase16.h index 7e83b70bb5e..365799401c7 100644 --- a/reactos/include/reactos/wine/winbase16.h +++ b/reactos/include/reactos/wine/winbase16.h @@ -13,12 +13,516 @@ * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #ifndef __WINE_WINE_WINBASE16_H #define __WINE_WINE_WINBASE16_H +#include +#include +#include +#include #include +#include + +#include + +/* Process database (i.e. a normal DOS PSP) */ +typedef struct +{ + WORD int20; /* 00 int 20h instruction */ + WORD nextParagraph; /* 02 Segment of next paragraph */ + BYTE reserved1; + BYTE dispatcher[5]; /* 05 Long call to DOS */ + FARPROC16 savedint22; /* 0a Saved int 22h handler */ + FARPROC16 savedint23; /* 0e Saved int 23h handler */ + FARPROC16 savedint24; /* 12 Saved int 24h handler */ + WORD parentPSP; /* 16 Selector of parent PSP */ + BYTE fileHandles[20]; /* 18 Open file handles */ + HANDLE16 environment; /* 2c Selector of environment */ + DWORD saveStack; /* 2e SS:SP on last int21 call */ + WORD nbFiles; /* 32 Number of file handles */ + SEGPTR fileHandlesPtr; /* 34 Pointer to file handle table */ + HANDLE16 hFileHandles; /* 38 Handle to fileHandlesPtr */ + WORD reserved3[17]; + BYTE fcb1[16]; /* 5c First FCB */ + BYTE fcb2[20]; /* 6c Second FCB */ + BYTE cmdLine[128]; /* 80 Command-line (first byte is len)*/ + BYTE padding[16]; /* Some apps access beyond the end of the cmd line */ +} PDB16; + +/* Task database. See 'Windows Internals' p. 226. + * Note that 16-bit OLE 2 libs like to read it directly + * so we have to keep entry offsets as they are. + */ +typedef struct _TDB +{ + HTASK16 hNext; /* 00 Selector of next TDB */ + DWORD ss_sp; /* 02 Stack pointer of task */ + WORD nEvents; /* 06 Events for this task */ + INT16 priority; /* 08 Task priority, -32..15 */ + WORD unused1; /* 0a */ + HTASK16 hSelf; /* 0c Selector of this TDB */ + HANDLE16 hPrevInstance; /* 0e Previous instance of module */ + DWORD unused2; /* 10 */ + WORD ctrlword8087; /* 14 80x87 control word */ + WORD flags; /* 16 Task flags */ + UINT16 error_mode; /* 18 Error mode (see SetErrorMode)*/ + WORD version; /* 1a Expected Windows version */ + HANDLE16 hInstance; /* 1c Instance handle for task */ + HMODULE16 hModule; /* 1e Module handle */ + HQUEUE16 hQueue; /* 20 Selector of task queue */ + HTASK16 hParent; /* 22 Selector of TDB of parent */ + WORD signal_flags; /* 24 Flags for signal handler */ + FARPROC16 sighandler; /* 26 Signal handler */ + FARPROC16 userhandler; /* 2a USER signal handler */ + FARPROC16 discardhandler; /* 2e Handler for GlobalNotify() */ + FARPROC16 int0; /* 32 int 0 (divide by 0) handler */ + FARPROC16 int2; /* 36 int 2 (NMI) handler */ + FARPROC16 int4; /* 3a int 4 (INTO) handler */ + FARPROC16 int6; /* 3e int 6 (invalid opc) handler */ + FARPROC16 int7; /* 42 int 7 (coprocessor) handler */ + FARPROC16 int3e; /* 46 int 3e (80x87 emu) handler */ + FARPROC16 int75; /* 4a int 75 (80x87 error) handler */ + DWORD compat_flags; /* 4e Compatibility flags */ + BYTE unused4[2]; /* 52 */ + struct _TEB *teb; /* 54 Pointer to thread database */ + BYTE unused5[8]; /* 58 */ + HANDLE16 hPDB; /* 60 Selector of PDB (i.e. PSP) */ + SEGPTR dta; /* 62 Current DTA */ + BYTE curdrive; /* 66 Current drive */ + CHAR curdir[65]; /* 67 Current directory */ + WORD nCmdShow; /* a8 cmdShow parameter to WinMain */ + HTASK16 hYieldTo; /* aa Next task to schedule */ + DWORD dlls_to_init; /* ac Ptr to DLLs to initialize */ + HANDLE16 hCSAlias; /* b0 Code segment for this TDB */ + WORD thunks[8*4]; /* b2 Make proc instance thunks */ + CHAR module_name[8]; /* f2 Module name for task */ + WORD magic; /* fa TDB signature */ + HANDLE hEvent; /* fc scheduler event handle */ + PDB16 pdb; /* 100 PDB for this task */ +} TDB; + +/* TDB flags */ +#define TDBF_WINOLDAP 0x0001 +#define TDBF_OS2APP 0x0008 +#define TDBF_WIN32 0x0010 + +/* Windows 3.1 USER signals */ +#define USIG16_TERMINATION 0x0020 +#define USIG16_DLL_LOAD 0x0040 +#define USIG16_DLL_UNLOAD 0x0080 +#define USIG16_GPF 0x0666 + +typedef struct _SEGINFO { + UINT16 offSegment; + UINT16 cbSegment; + UINT16 flags; + UINT16 cbAlloc; + HGLOBAL16 h; + UINT16 alignShift; + UINT16 reserved[2]; +} SEGINFO; + +/* GetWinFlags */ + +#define WF_PMODE 0x0001 +#define WF_CPU286 0x0002 +#define WF_CPU386 0x0004 +#define WF_CPU486 0x0008 +#define WF_STANDARD 0x0010 +#define WF_WIN286 0x0010 +#define WF_ENHANCED 0x0020 +#define WF_WIN386 0x0020 +#define WF_CPU086 0x0040 +#define WF_CPU186 0x0080 +#define WF_LARGEFRAME 0x0100 +#define WF_SMALLFRAME 0x0200 +#define WF_80x87 0x0400 +#define WF_PAGING 0x0800 +#define WF_HASCPUID 0x2000 +#define WF_WIN32WOW 0x4000 /* undoc */ +#define WF_WLO 0x8000 + +/* Parameters for LoadModule() */ +typedef struct +{ + HGLOBAL16 hEnvironment; /* Environment segment */ + SEGPTR cmdLine; /* Command-line */ + SEGPTR showCmd; /* Code for ShowWindow() */ + SEGPTR reserved; +} LOADPARAMS16; + +/* Debugging support (DEBUG SYSTEM ONLY) */ +typedef struct +{ + WORD flags; + DWORD dwOptions; + DWORD dwFilter; + CHAR achAllocModule[8]; + DWORD dwAllocBreak; + DWORD dwAllocCount; +} WINDEBUGINFO16, *LPWINDEBUGINFO16; + +/* definitions specific to Wine 16-bit relaying support */ + +/* 32-bit stack layout after __wine_call_to_16() */ +typedef struct _STACK32FRAME +{ + DWORD restore_addr; /* 00 return address for restoring code selector */ + DWORD codeselector; /* 04 code selector to restore */ + EXCEPTION_REGISTRATION_RECORD frame; /* 08 Exception frame */ + SEGPTR frame16; /* 10 16-bit frame from last CallFrom16() */ + DWORD edi; /* 14 saved registers */ + DWORD esi; /* 18 */ + DWORD ebx; /* 1c */ + DWORD ebp; /* 20 saved 32-bit frame pointer */ + DWORD retaddr; /* 24 return address */ + DWORD target; /* 28 target address / CONTEXT86 pointer */ + DWORD nb_args; /* 2c number of 16-bit argument bytes */ +} STACK32FRAME; + +/* 16-bit stack layout after __wine_call_from_16() */ +typedef struct _STACK16FRAME +{ + STACK32FRAME *frame32; /* 00 32-bit frame from last CallTo16() */ + DWORD edx; /* 04 saved registers */ + DWORD ecx; /* 08 */ + DWORD ebp; /* 0c */ + WORD ds; /* 10 */ + WORD es; /* 12 */ + WORD fs; /* 14 */ + WORD gs; /* 16 */ + DWORD callfrom_ip; /* 18 callfrom tail IP */ + DWORD module_cs; /* 1c module code segment */ + DWORD relay; /* 20 relay function address */ + WORD entry_ip; /* 22 entry point IP */ + DWORD entry_point; /* 26 API entry point to call, reused as mutex count */ + WORD bp; /* 2a 16-bit stack frame chain */ + WORD ip; /* 2c return address */ + WORD cs; /* 2e */ +} STACK16FRAME; + +/* argument type flags for relay debugging */ +enum arg_types +{ + ARG_NONE = 0, /* indicates end of arg list */ + ARG_WORD, /* unsigned word */ + ARG_SWORD, /* signed word */ + ARG_LONG, /* long or segmented pointer */ + ARG_PTR, /* linear pointer */ + ARG_STR, /* linear pointer to null-terminated string */ + ARG_SEGSTR, /* segmented pointer to null-terminated string */ + ARG_VARARG /* start of varargs */ +}; + +#include + +#define INVALID_HANDLE_VALUE16 ((HANDLE16) -1) +#define INFINITE16 0xFFFF + +typedef struct { + DWORD dwOSVersionInfoSize; + DWORD dwMajorVersion; + DWORD dwMinorVersion; + DWORD dwBuildNumber; + DWORD dwPlatformId; + CHAR szCSDVersion[128]; +} OSVERSIONINFO16; + + +/* + * NE Header FORMAT FLAGS + */ +#define NE_FFLAGS_SINGLEDATA 0x0001 +#define NE_FFLAGS_MULTIPLEDATA 0x0002 +#define NE_FFLAGS_WIN32 0x0010 +#define NE_FFLAGS_BUILTIN 0x0020 /* Wine built-in module */ +#define NE_FFLAGS_FRAMEBUF 0x0100 /* OS/2 fullscreen app */ +#define NE_FFLAGS_CONSOLE 0x0200 /* OS/2 console app */ +#define NE_FFLAGS_GUI 0x0300 /* right, (NE_FFLAGS_FRAMEBUF | NE_FFLAGS_CONSOLE) */ +#define NE_FFLAGS_SELFLOAD 0x0800 +#define NE_FFLAGS_LINKERROR 0x2000 +#define NE_FFLAGS_CALLWEP 0x4000 +#define NE_FFLAGS_LIBMODULE 0x8000 + +/* + * NE Header OPERATING SYSTEM + */ +#define NE_OSFLAGS_UNKNOWN 0x01 +#define NE_OSFLAGS_WINDOWS 0x04 + +/* + * NE Header ADDITIONAL FLAGS + */ +#define NE_AFLAGS_WIN2_PROTMODE 0x02 +#define NE_AFLAGS_WIN2_PROFONTS 0x04 +#define NE_AFLAGS_FASTLOAD 0x08 + +/* + * Segment Flags + */ +#define NE_SEGFLAGS_DATA 0x0001 +#define NE_SEGFLAGS_ALLOCATED 0x0002 +#define NE_SEGFLAGS_LOADED 0x0004 +#define NE_SEGFLAGS_ITERATED 0x0008 +#define NE_SEGFLAGS_MOVEABLE 0x0010 +#define NE_SEGFLAGS_SHAREABLE 0x0020 +#define NE_SEGFLAGS_PRELOAD 0x0040 +#define NE_SEGFLAGS_EXECUTEONLY 0x0080 +#define NE_SEGFLAGS_READONLY 0x0080 +#define NE_SEGFLAGS_RELOC_DATA 0x0100 +#define NE_SEGFLAGS_SELFLOAD 0x0800 +#define NE_SEGFLAGS_DISCARDABLE 0x1000 +#define NE_SEGFLAGS_32BIT 0x2000 + +/* + * Resource table structures. + */ +typedef struct +{ + WORD offset; + WORD length; + WORD flags; + WORD id; + HANDLE16 handle; + WORD usage; +} NE_NAMEINFO; + +typedef struct +{ + WORD type_id; /* Type identifier */ + WORD count; /* Number of resources of this type */ + FARPROC16 resloader; /* SetResourceHandler() */ + /* + * Name info array. + */ +} NE_TYPEINFO; + +#define NE_RSCTYPE_CURSOR 0x8001 +#define NE_RSCTYPE_BITMAP 0x8002 +#define NE_RSCTYPE_ICON 0x8003 +#define NE_RSCTYPE_MENU 0x8004 +#define NE_RSCTYPE_DIALOG 0x8005 +#define NE_RSCTYPE_STRING 0x8006 +#define NE_RSCTYPE_FONTDIR 0x8007 +#define NE_RSCTYPE_FONT 0x8008 +#define NE_RSCTYPE_ACCELERATOR 0x8009 +#define NE_RSCTYPE_RCDATA 0x800a +#define NE_RSCTYPE_GROUP_CURSOR 0x800c +#define NE_RSCTYPE_GROUP_ICON 0x800e + + +#define __AHSHIFT 3 /* don't change! */ +#define __AHINCR (1 << __AHSHIFT) + +/* undocumented functions */ +WORD WINAPI AllocCStoDSAlias16(WORD); +WORD WINAPI AllocDStoCSAlias16(WORD); +HGLOBAL16 WINAPI AllocResource16(HINSTANCE16,HRSRC16,DWORD); +WORD WINAPI AllocSelector16(WORD); +WORD WINAPI AllocSelectorArray16(WORD); +VOID WINAPI DirectedYield16(HTASK16); +HGLOBAL16 WINAPI DirectResAlloc16(HINSTANCE16,WORD,UINT16); +HANDLE16 WINAPI FarGetOwner16(HGLOBAL16); +VOID WINAPI FarSetOwner16(HGLOBAL16,HANDLE16); +FARPROC16 WINAPI FileCDR16(FARPROC16); +WORD WINAPI FreeSelector16(WORD); +HANDLE16 WINAPI GetAtomHandle16(ATOM); +HANDLE16 WINAPI GetCodeHandle16(FARPROC16); +BOOL16 WINAPI GetCodeInfo16(FARPROC16,SEGINFO*); +DWORD WINAPI GetCurrentPDB16(void); +HTASK16 WINAPI GetCurrentTask(void); +SEGPTR WINAPI GetDOSEnvironment16(void); +HMODULE16 WINAPI GetExePtr(HANDLE16); +WORD WINAPI GetExeVersion16(void); +WORD WINAPI GetExpWinVer16(HMODULE16); +HQUEUE16 WINAPI GetFastQueue16(void); +DWORD WINAPI GetHeapSpaces16(HMODULE16); +INT16 WINAPI GetInstanceData16(HINSTANCE16,WORD,INT16); +BOOL16 WINAPI GetModuleName16(HINSTANCE16,LPSTR,INT16); +INT16 WINAPI GetModuleUsage16(HINSTANCE16); +UINT16 WINAPI GetNumTasks16(void); +SEGPTR WINAPI GetpWin16Lock16(void); +DWORD WINAPI GetSelectorLimit16(WORD); +FARPROC16 WINAPI GetSetKernelDOSProc16(FARPROC16 DosProc); +HINSTANCE16 WINAPI GetTaskDS16(void); +HQUEUE16 WINAPI GetTaskQueue16(HTASK16); +HQUEUE16 WINAPI GetThreadQueue16(DWORD); +DWORD WINAPI GetWinFlags16(void); +DWORD WINAPI GlobalDOSAlloc16(DWORD); +WORD WINAPI GlobalDOSFree16(WORD); +void WINAPI GlobalFreeAll16(HGLOBAL16); +DWORD WINAPI GlobalHandleNoRIP16(WORD); +WORD WINAPI GlobalHandleToSel16(HGLOBAL16); +HGLOBAL16 WINAPI GlobalLRUNewest16(HGLOBAL16); +HGLOBAL16 WINAPI GlobalLRUOldest16(HGLOBAL16); +VOID WINAPI GlobalNotify16(FARPROC16); +WORD WINAPI GlobalPageLock16(HGLOBAL16); +WORD WINAPI GlobalPageUnlock16(HGLOBAL16); +SEGPTR WINAPI HasGPHandler16(SEGPTR); +BOOL16 WINAPI IsSharedSelector16(HANDLE16); +BOOL16 WINAPI IsTask16(HTASK16); +HTASK16 WINAPI IsTaskLocked16(void); +VOID WINAPI LogError16(UINT16, LPVOID); +VOID WINAPI LogParamError16(UINT16,FARPROC16,LPVOID); +WORD WINAPI LocalCountFree16(void); +WORD WINAPI LocalHandleDelta16(WORD); +WORD WINAPI LocalHeapSize16(void); +BOOL16 WINAPI LocalInit16(HANDLE16,WORD,WORD); +FARPROC16 WINAPI LocalNotify16(FARPROC16); +HTASK16 WINAPI LockCurrentTask16(BOOL16); +VOID WINAPI OldYield16(void); +VOID WINAPI WIN32_OldYield16(void); +VOID WINAPI PostEvent16(HTASK16); +WORD WINAPI PrestoChangoSelector16(WORD,WORD); +WORD WINAPI SelectorAccessRights16(WORD,WORD,WORD); +void WINAPI SetFastQueue16(DWORD,HQUEUE16); +VOID WINAPI SetPriority16(HTASK16,INT16); +FARPROC16 WINAPI SetResourceHandler16(HINSTANCE16,LPCSTR,FARPROC16); +WORD WINAPI SetSelectorLimit16(WORD,DWORD); +HQUEUE16 WINAPI SetTaskQueue16(HTASK16,HQUEUE16); +HQUEUE16 WINAPI SetThreadQueue16(DWORD,HQUEUE16); +VOID WINAPI SwitchStackTo16(WORD,WORD,WORD); +BOOL16 WINAPI WaitEvent16(HTASK16); +VOID WINAPI WriteOutProfiles16(void); +VOID WINAPI hmemcpy16(LPVOID,LPCVOID,LONG); +VOID WINAPI _CreateSysLevel(SYSLEVEL*,INT); +VOID WINAPI _EnterWin16Lock(void); +VOID WINAPI _LeaveWin16Lock(void); + + +INT16 WINAPI AccessResource16(HINSTANCE16,HRSRC16); +ATOM WINAPI AddAtom16(LPCSTR); +UINT16 WINAPI CompareString16(DWORD,DWORD,LPCSTR,DWORD,LPCSTR,DWORD); +BOOL16 WINAPI CreateDirectory16(LPCSTR,LPVOID); +BOOL16 WINAPI DefineHandleTable16(WORD); +ATOM WINAPI DeleteAtom16(ATOM); +BOOL16 WINAPI DeleteFile16(LPCSTR); +void WINAPI ExitKernel16(void); +void WINAPI FatalAppExit16(UINT16,LPCSTR); +ATOM WINAPI FindAtom16(LPCSTR); +BOOL16 WINAPI FindClose16(HANDLE16); +VOID WINAPI FreeLibrary16(HINSTANCE16); +HANDLE16 WINAPI FindFirstFile16(LPCSTR,LPWIN32_FIND_DATAA); +BOOL16 WINAPI FindNextFile16(HANDLE16,LPWIN32_FIND_DATAA); +HRSRC16 WINAPI FindResource16(HINSTANCE16,LPCSTR,LPCSTR); +BOOL16 WINAPI FreeModule16(HMODULE16); +void WINAPI FreeProcInstance16(FARPROC16); +BOOL16 WINAPI FreeResource16(HGLOBAL16); +UINT16 WINAPI GetAtomName16(ATOM,LPSTR,INT16); +UINT16 WINAPI GetCurrentDirectory16(UINT16,LPSTR); +BOOL16 WINAPI GetDiskFreeSpace16(LPCSTR,LPDWORD,LPDWORD,LPDWORD,LPDWORD); +UINT16 WINAPI GetDriveType16(UINT16); /* yes, the arguments differ */ +INT16 WINAPI GetLocaleInfo16(LCID,LCTYPE,LPSTR,INT16); +DWORD WINAPI GetFileAttributes16(LPCSTR); +DWORD WINAPI GetFreeSpace16(UINT16); +INT16 WINAPI GetModuleFileName16(HINSTANCE16,LPSTR,INT16); +HMODULE16 WINAPI GetModuleHandle16(LPCSTR); +UINT16 WINAPI GetPrivateProfileInt16(LPCSTR,LPCSTR,INT16,LPCSTR); +INT16 WINAPI GetPrivateProfileSection16(LPCSTR,LPSTR,UINT16,LPCSTR); +WORD WINAPI GetPrivateProfileSectionNames16(LPSTR,UINT16,LPCSTR); +INT16 WINAPI GetPrivateProfileString16(LPCSTR,LPCSTR,LPCSTR,LPSTR,UINT16,LPCSTR); +BOOL16 WINAPI GetPrivateProfileStruct16(LPCSTR,LPCSTR,LPVOID,UINT16,LPCSTR); +FARPROC16 WINAPI GetProcAddress16(HMODULE16,LPCSTR); +UINT16 WINAPI GetProfileInt16(LPCSTR,LPCSTR,INT16); +INT16 WINAPI GetProfileSection16(LPCSTR,LPSTR,UINT16); +WORD WINAPI GetProfileSectionNames16(LPSTR,WORD); +INT16 WINAPI GetProfileString16(LPCSTR,LPCSTR,LPCSTR,LPSTR,UINT16); +DWORD WINAPI GetSelectorBase(WORD); +BOOL16 WINAPI GetStringType16(LCID,DWORD,LPCSTR,INT16,LPWORD); +UINT16 WINAPI GetSystemDirectory16(LPSTR,UINT16); +UINT16 WINAPI GetTempFileName16(BYTE,LPCSTR,UINT16,LPSTR); +DWORD WINAPI GetVersion16(void); +BOOL16 WINAPI GetVersionEx16(OSVERSIONINFO16*); +BOOL16 WINAPI GetWinDebugInfo16(LPWINDEBUGINFO16,UINT16); +UINT16 WINAPI GetWindowsDirectory16(LPSTR,UINT16); +HGLOBAL16 WINAPI GlobalAlloc16(UINT16,DWORD); +DWORD WINAPI GlobalCompact16(DWORD); +LPVOID WINAPI GlobalLock16(HGLOBAL16); +WORD WINAPI GlobalFix16(HGLOBAL16); +UINT16 WINAPI GlobalFlags16(HGLOBAL16); +HGLOBAL16 WINAPI GlobalFree16(HGLOBAL16); +DWORD WINAPI GlobalHandle16(WORD); +HGLOBAL16 WINAPI GlobalReAlloc16(HGLOBAL16,DWORD,UINT16); +DWORD WINAPI GlobalSize16(HGLOBAL16); +VOID WINAPI GlobalUnfix16(HGLOBAL16); +BOOL16 WINAPI GlobalUnlock16(HGLOBAL16); +BOOL16 WINAPI GlobalUnWire16(HGLOBAL16); +SEGPTR WINAPI GlobalWire16(HGLOBAL16); +WORD WINAPI InitAtomTable16(WORD); +BOOL16 WINAPI IsBadCodePtr16(SEGPTR); +BOOL16 WINAPI IsBadHugeReadPtr16(SEGPTR,DWORD); +BOOL16 WINAPI IsBadHugeWritePtr16(SEGPTR,DWORD); +BOOL16 WINAPI IsBadReadPtr16(SEGPTR,UINT16); +BOOL16 WINAPI IsBadStringPtr16(SEGPTR,UINT16); +BOOL16 WINAPI IsBadWritePtr16(SEGPTR,UINT16); +BOOL16 WINAPI IsDBCSLeadByte16(BYTE); +HINSTANCE16 WINAPI LoadLibrary16(LPCSTR); +HINSTANCE16 WINAPI LoadModule16(LPCSTR,LPVOID); +HGLOBAL16 WINAPI LoadResource16(HINSTANCE16,HRSRC16); +HLOCAL16 WINAPI LocalAlloc16(UINT16,WORD); +UINT16 WINAPI LocalCompact16(UINT16); +UINT16 WINAPI LocalFlags16(HLOCAL16); +HLOCAL16 WINAPI LocalFree16(HLOCAL16); +HLOCAL16 WINAPI LocalHandle16(WORD); +SEGPTR WINAPI LocalLock16(HLOCAL16); +HLOCAL16 WINAPI LocalReAlloc16(HLOCAL16,WORD,UINT16); +UINT16 WINAPI LocalShrink16(HGLOBAL16,UINT16); +UINT16 WINAPI LocalSize16(HLOCAL16); +BOOL16 WINAPI LocalUnlock16(HLOCAL16); +LPVOID WINAPI LockResource16(HGLOBAL16); +HGLOBAL16 WINAPI LockSegment16(HGLOBAL16); +FARPROC16 WINAPI MakeProcInstance16(FARPROC16,HANDLE16); +HFILE16 WINAPI OpenFile16(LPCSTR,OFSTRUCT*,UINT16); +DWORD WINAPI RegCloseKey16(HKEY); +DWORD WINAPI RegCreateKey16(HKEY,LPCSTR,PHKEY); +DWORD WINAPI RegDeleteKey16(HKEY,LPCSTR); +DWORD WINAPI RegDeleteValue16(HKEY,LPSTR); +DWORD WINAPI RegEnumKey16(HKEY,DWORD,LPSTR,DWORD); +DWORD WINAPI RegEnumValue16(HKEY,DWORD,LPSTR,LPDWORD,LPDWORD,LPDWORD,LPBYTE,LPDWORD); +DWORD WINAPI RegOpenKey16(HKEY,LPCSTR,PHKEY); +DWORD WINAPI RegQueryValue16(HKEY,LPCSTR,LPSTR,LPDWORD); +DWORD WINAPI RegQueryValueEx16(HKEY,LPCSTR,LPDWORD,LPDWORD,LPBYTE,LPDWORD); +DWORD WINAPI RegSetValue16(HKEY,LPCSTR,DWORD,LPCSTR,DWORD); +DWORD WINAPI RegSetValueEx16(HKEY,LPCSTR,DWORD,DWORD,CONST BYTE*,DWORD); +BOOL16 WINAPI RemoveDirectory16(LPCSTR); +BOOL16 WINAPI SetCurrentDirectory16(LPCSTR); +UINT16 WINAPI SetErrorMode16(UINT16); +BOOL16 WINAPI SetFileAttributes16(LPCSTR,DWORD); +UINT16 WINAPI SetHandleCount16(UINT16); +WORD WINAPI SetSelectorBase(WORD,DWORD); +LONG WINAPI SetSwapAreaSize16(WORD); +BOOL16 WINAPI SetWinDebugInfo16(LPWINDEBUGINFO16); +DWORD WINAPI SizeofResource16(HMODULE16,HRSRC16); +void WINAPI UnlockSegment16(HGLOBAL16); +BOOL16 WINAPI WritePrivateProfileString16(LPCSTR,LPCSTR,LPCSTR,LPCSTR); +BOOL16 WINAPI WriteProfileString16(LPCSTR,LPCSTR,LPCSTR); +/* Yield16 will only be available from kernel module, use WOWYield instead */ +VOID WINAPI Yield16(void); +SEGPTR WINAPI lstrcat16(SEGPTR,LPCSTR); +SEGPTR WINAPI lstrcatn16(SEGPTR,LPCSTR,INT16); +SEGPTR WINAPI lstrcpy16(SEGPTR,LPCSTR); +SEGPTR WINAPI lstrcpyn16(SEGPTR,LPCSTR,INT16); +INT16 WINAPI lstrlen16(LPCSTR); +HINSTANCE16 WINAPI WinExec16(LPCSTR,UINT16); +LONG WINAPI _hread16(HFILE16,LPVOID,LONG); +LONG WINAPI _hwrite16(HFILE16,LPCSTR,LONG); +HFILE16 WINAPI _lcreat16(LPCSTR,INT16); +HFILE16 WINAPI _lclose16(HFILE16); +LONG WINAPI _llseek16(HFILE16,LONG,INT16); +HFILE16 WINAPI _lopen16(LPCSTR,INT16); +UINT16 WINAPI _lread16(HFILE16,LPVOID,UINT16); +UINT16 WINAPI _lwrite16(HFILE16,LPCSTR,UINT16); +BOOL16 WINAPI WritePrivateProfileSection16(LPCSTR,LPCSTR,LPCSTR); +BOOL16 WINAPI WritePrivateProfileStruct16(LPCSTR,LPCSTR,LPVOID,UINT16,LPCSTR); +BOOL16 WINAPI WriteProfileSection16(LPCSTR,LPCSTR); + +/* Some optimizations */ +extern inline LPVOID WINAPI MapSL( SEGPTR segptr ) +{ + return (char *)wine_ldt_copy.base[SELECTOROF(segptr) >> __AHSHIFT] + OFFSETOF(segptr); +} #endif /* __WINE_WINE_WINBASE16_H */ diff --git a/reactos/include/reactos/wine/windef16.h b/reactos/include/reactos/wine/windef16.h index 990121f3802..5db952eeeb5 100644 --- a/reactos/include/reactos/wine/windef16.h +++ b/reactos/include/reactos/wine/windef16.h @@ -17,14 +17,18 @@ * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #ifndef __WINE_WINDEF16_H #define __WINE_WINDEF16_H -/* #include "windef.h" */ - +#ifndef RC_INVOKED +#include +#endif +#include +#include +#include // ROS Hack /* Standard data types */ typedef unsigned short BOOL16; @@ -37,7 +41,20 @@ typedef UINT16 WPARAM16; typedef INT16 *LPINT16; typedef UINT16 *LPUINT16; +typedef WORD CATCHBUF[9]; +typedef WORD *LPCATCHBUF; + #define MAKESEGPTR(seg,off) ((SEGPTR)MAKELONG(off,seg)) +#define SELECTOROF(ptr) (HIWORD(ptr)) +#define OFFSETOF(ptr) (LOWORD(ptr)) + +typedef WORD *VA_LIST16; + +#define __VA_ROUNDED16(type) \ + ((sizeof(type) + sizeof(WORD) - 1) / sizeof(WORD) * sizeof(WORD)) +#define VA_ARG16(list,type) \ + (((list) = (VA_LIST16)((char *)(list) + __VA_ROUNDED16(type))), \ + *((type *)(void *)((char *)(list) - __VA_ROUNDED16(type)))) #define HFILE_ERROR16 ((HFILE16)-1) @@ -99,7 +116,7 @@ typedef HANDLE16 HGDIOBJ16; typedef HANDLE16 HGLOBAL16; typedef HANDLE16 HLOCAL16; -#include "pshpack1.h" +#include /* The SIZE structure */ @@ -127,7 +144,7 @@ typedef struct INT16 bottom; } RECT16, *LPRECT16; -#include "poppack.h" +#include /* Callback function pointers types */