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 */