msvcp60: Added basic_string<char> support.

dlls/msvcp60/Makefile.in

 MODULE = msvcp60.dll
+IMPORTS   = msvcrt
+MODCFLAGS = @BUILTINFLAG@
+EXTRAINCL = -I$(top_srcdir)/include/msvcrt
 
-C_SRCS = msvcp60.c
+C_SRCS = \
+	exception.c \
+	main.c \
+	memory.c \
+	misc.c \
+	string.c
 
 @MAKE_DLL_RULES@

dlls/msvcp60/main.c

+/*
+ * Copyright 2010 Piotr Caban for CodeWeavers
+ *
+ * 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
+ */
+
+#include "config.h"
+
+#include <stdarg.h>
+
+#include "msvcp.h"
+
+#include "windef.h"
+#include "winbase.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(msvcp90);
+
+#ifdef __i386__
+
+#define DEFINE_VTBL_WRAPPER(off)            \
+    __ASM_GLOBAL_FUNC(vtbl_wrapper_ ## off, \
+        "popl %eax\n\t"                     \
+        "popl %ecx\n\t"                     \
+        "pushl %eax\n\t"                    \
+        "movl 0(%ecx), %eax\n\t"            \
+        "jmp *" #off "(%eax)\n\t")
+
+DEFINE_VTBL_WRAPPER(0);
+DEFINE_VTBL_WRAPPER(4);
+DEFINE_VTBL_WRAPPER(8);
+DEFINE_VTBL_WRAPPER(12);
+DEFINE_VTBL_WRAPPER(16);
+DEFINE_VTBL_WRAPPER(20);
+DEFINE_VTBL_WRAPPER(24);
+DEFINE_VTBL_WRAPPER(28);
+DEFINE_VTBL_WRAPPER(32);
+DEFINE_VTBL_WRAPPER(36);
+DEFINE_VTBL_WRAPPER(40);
+DEFINE_VTBL_WRAPPER(44);
+DEFINE_VTBL_WRAPPER(48);
+DEFINE_VTBL_WRAPPER(52);
+DEFINE_VTBL_WRAPPER(56);
+DEFINE_VTBL_WRAPPER(60);
+
+#endif
+
+void* (__cdecl *MSVCRT_operator_new)(MSVCP_size_t);
+void (__cdecl *MSVCRT_operator_delete)(void*);
+void* (__cdecl *MSVCRT_set_new_handler)(void*);
+
+static void init_cxx_funcs(void)
+{
+    HMODULE hmod = GetModuleHandleA("msvcrt.dll");
+
+    if (sizeof(void *) > sizeof(int))  /* 64-bit has different names */
+    {
+        MSVCRT_operator_new = (void*)GetProcAddress(hmod, "??2@YAPEAX_K@Z");
+        MSVCRT_operator_delete = (void*)GetProcAddress(hmod, "??3@YAXPEAX@Z");
+        MSVCRT_set_new_handler = (void*)GetProcAddress(hmod, "?_set_new_handler@@YAP6AH_K@ZP6AH0@Z@Z");
+    }
+    else
+    {
+        MSVCRT_operator_new = (void*)GetProcAddress(hmod, "??2@YAPAXI@Z");
+        MSVCRT_operator_delete = (void*)GetProcAddress(hmod, "??3@YAXPAX@Z");
+        MSVCRT_set_new_handler = (void*)GetProcAddress(hmod, "?_set_new_handler@@YAP6AHI@ZP6AHI@Z@Z");
+    }
+}
+
+BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+{
+    TRACE("(0x%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);
+
+    switch (fdwReason)
+    {
+        case DLL_WINE_PREATTACH:
+            return FALSE;    /* prefer native version */
+        case DLL_PROCESS_ATTACH:
+            init_cxx_funcs();
+            set_exception_vtable();
+            init_lockit();
+            break;
+        case DLL_PROCESS_DETACH:
+            free_lockit();
+            break;
+    }
+
+    return TRUE;
+}
+
+/* ?_BADOFF@std@@3JB -> long const std::_BADOFF */
+/* ?_BADOFF@std@@3_JB -> __int64 const std::_BADOFF */
+const INT_PTR std_BADOFF = -1;
+
+/* ?_BADOFF_func@std@@YAABJXZ -> long const & __cdecl std::_BADOFF_func(void) */
+/* ?_BADOFF_func@std@@YAAEB_JXZ -> __int64 const & __ptr64 __cdecl std::_BADOFF_func(void) */
+const INT_PTR * __cdecl std_BADOFF_func(void)
+{
+    return &std_BADOFF;
+}
+
+/* ?_Fpz@std@@3_JA  __int64 std::_Fpz */
+__int64 std_Fpz = 0;
+
+/* ?_Fpz_func@std@@YAAA_JXZ -> __int64 & __cdecl std::_Fpz_func(void) */
+/* ?_Fpz_func@std@@YAAEA_JXZ -> __int64 & __ptr64 __cdecl std::_Fpz_func(void) */
+__int64 * __cdecl std_Fpz_func(void)
+{
+    return &std_Fpz;
+}

dlls/msvcp60/misc.c

+/*
+ * Copyright 2010 Piotr Caban for CodeWeavers
+ *
+ * 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
+ */
+
+#include "config.h"
+
+#include <stdarg.h>
+#include <limits.h>
+
+#include "msvcp.h"
+
+#include "windef.h"
+#include "winbase.h"
+#include "wine/debug.h"
+WINE_DEFAULT_DEBUG_CHANNEL(msvcp90);
+
+/* ??0_Mutex@std@@QAE@XZ */
+/* ??0_Mutex@std@@QEAA@XZ */
+DEFINE_THISCALL_WRAPPER(mutex_ctor, 4)
+mutex* __thiscall mutex_ctor(mutex *this)
+{
+    this->mutex = CreateMutexW(NULL, FALSE, NULL);
+    return this;
+}
+
+/* ??1_Mutex@std@@QAE@XZ */
+/* ??1_Mutex@std@@QEAA@XZ */
+DEFINE_THISCALL_WRAPPER(mutex_dtor, 4)
+void __thiscall mutex_dtor(mutex *this)
+{
+    CloseHandle(this->mutex);
+}
+
+/* ?_Lock@_Mutex@std@@QAEXXZ */
+/* ?_Lock@_Mutex@std@@QEAAXXZ */
+DEFINE_THISCALL_WRAPPER(mutex_lock, 4)
+void __thiscall mutex_lock(mutex *this)
+{
+    WaitForSingleObject(this->mutex, INFINITE);
+}
+
+/* ?_Unlock@_Mutex@std@@QAEXXZ */
+/* ?_Unlock@_Mutex@std@@QEAAXXZ */
+DEFINE_THISCALL_WRAPPER(mutex_unlock, 4)
+void __thiscall mutex_unlock(mutex *this)
+{
+    ReleaseMutex(this->mutex);
+}
+
+/* ?_Mutex_Lock@_Mutex@std@@CAXPAV12@@Z */
+/* ?_Mutex_Lock@_Mutex@std@@CAXPEAV12@@Z */
+void CDECL mutex_mutex_lock(mutex *m)
+{
+    mutex_lock(m);
+}
+
+/* ?_Mutex_Unlock@_Mutex@std@@CAXPAV12@@Z */
+/* ?_Mutex_Unlock@_Mutex@std@@CAXPEAV12@@Z */
+void CDECL mutex_mutex_unlock(mutex *m)
+{
+    mutex_unlock(m);
+}
+
+/* ?_Mutex_ctor@_Mutex@std@@CAXPAV12@@Z */
+/* ?_Mutex_ctor@_Mutex@std@@CAXPEAV12@@Z */
+void CDECL mutex_mutex_ctor(mutex *m)
+{
+    mutex_ctor(m);
+}
+
+/* ?_Mutex_dtor@_Mutex@std@@CAXPAV12@@Z */
+/* ?_Mutex_dtor@_Mutex@std@@CAXPEAV12@@Z */
+void CDECL mutex_mutex_dtor(mutex *m)
+{
+    mutex_dtor(m);
+}
+
+static CRITICAL_SECTION lockit_cs[_MAX_LOCK];
+
+/* ?_Lockit_ctor@_Lockit@std@@SAXH@Z */
+void __cdecl _Lockit_init(int locktype) {
+    InitializeCriticalSection(&lockit_cs[locktype]);
+    lockit_cs[locktype].DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": _Lockit critical section");
+}
+
+/* ?_Lockit_dtor@_Lockit@std@@SAXH@Z */
+void __cdecl _Lockit_free(int locktype)
+{
+    lockit_cs[locktype].DebugInfo->Spare[0] = 0;
+    DeleteCriticalSection(&lockit_cs[locktype]);
+}
+
+void init_lockit(void) {
+    int i;
+
+    for(i=0; i<_MAX_LOCK; i++)
+        _Lockit_init(i);
+}
+
+void free_lockit(void) {
+    int i;
+
+    for(i=0; i<_MAX_LOCK; i++)
+        _Lockit_free(i);
+}
+
+/* ?_Lockit_ctor@_Lockit@std@@CAXPAV12@H@Z */
+/* ?_Lockit_ctor@_Lockit@std@@CAXPEAV12@H@Z */
+void __cdecl _Lockit__Lockit_ctor_locktype(_Lockit *lockit, int locktype)
+{
+    lockit->locktype = locktype;
+    EnterCriticalSection(&lockit_cs[locktype]);
+}
+
+/* ?_Lockit_ctor@_Lockit@std@@CAXPAV12@@Z */
+/* ?_Lockit_ctor@_Lockit@std@@CAXPEAV12@@Z */
+void __cdecl _Lockit__Lockit_ctor(_Lockit *lockit)
+{
+    _Lockit__Lockit_ctor_locktype(lockit, 0);
+}
+
+/* ??0_Lockit@std@@QAE@H@Z */
+/* ??0_Lockit@std@@QEAA@H@Z */
+DEFINE_THISCALL_WRAPPER(_Lockit_ctor_locktype, 8)
+_Lockit* __thiscall _Lockit_ctor_locktype(_Lockit *this, int locktype)
+{
+    _Lockit__Lockit_ctor_locktype(this, locktype);
+    return this;
+}
+
+/* ??0_Lockit@std@@QAE@XZ */
+/* ??0_Lockit@std@@QEAA@XZ */
+DEFINE_THISCALL_WRAPPER(_Lockit_ctor, 4)
+_Lockit* __thiscall _Lockit_ctor(_Lockit *this)
+{
+    _Lockit__Lockit_ctor_locktype(this, 0);
+    return this;
+}
+
+/* ?_Lockit_dtor@_Lockit@std@@CAXPAV12@@Z */
+/* ?_Lockit_dtor@_Lockit@std@@CAXPEAV12@@Z */
+void __cdecl _Lockit__Lockit_dtor(_Lockit *lockit)
+{
+    LeaveCriticalSection(&lockit_cs[lockit->locktype]);
+}
+
+/* ??1_Lockit@std@@QAE@XZ */
+/* ??1_Lockit@std@@QEAA@XZ */
+DEFINE_THISCALL_WRAPPER(_Lockit_dtor, 4)
+void __thiscall _Lockit_dtor(_Lockit *this)
+{
+    _Lockit__Lockit_dtor(this);
+}
+
+/* wctype */
+unsigned short __cdecl wctype(const char *property)
+{
+    static const struct {
+        const char *name;
+        unsigned short mask;
+    } properties[] = {
+        { "alnum", _DIGIT|_ALPHA },
+        { "alpha", _ALPHA },
+        { "cntrl", _CONTROL },
+        { "digit", _DIGIT },
+        { "graph", _DIGIT|_PUNCT|_ALPHA },
+        { "lower", _LOWER },
+        { "print", _DIGIT|_PUNCT|_BLANK|_ALPHA },
+        { "punct", _PUNCT },
+        { "space", _SPACE },
+        { "upper", _UPPER },
+        { "xdigit", _HEX }
+    };
+    int i;
+
+    for(i=0; i<sizeof(properties)/sizeof(properties[0]); i++)
+        if(!strcmp(property, properties[i].name))
+            return properties[i].mask;
+
+    return 0;
+}
+
+typedef void (__cdecl *MSVCP_new_handler_func)(void);
+static MSVCP_new_handler_func MSVCP_new_handler;
+static int __cdecl new_handler_wrapper(MSVCP_size_t unused)
+{
+    MSVCP_new_handler();
+    return 1;
+}
+
+/* ?set_new_handler@std@@YAP6AXXZP6AXXZ@Z */
+MSVCP_new_handler_func __cdecl set_new_handler(MSVCP_new_handler_func new_handler)
+{
+    MSVCP_new_handler_func old_handler = MSVCP_new_handler;
+
+    TRACE("%p\n", new_handler);
+
+    MSVCP_new_handler = new_handler;
+    MSVCRT_set_new_handler(new_handler ? new_handler_wrapper : NULL);
+    return old_handler;
+}
+
+/* ?set_new_handler@std@@YAP6AXXZH@Z */
+MSVCP_new_handler_func __cdecl set_new_handler_reset(int unused)
+{
+    return set_new_handler(NULL);
+}

dlls/msvcp60/msvcp.h

+/*
+ * Copyright 2010 Piotr Caban for CodeWeavers
+ *
+ * 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
+ */
+
+#include "stdlib.h"
+#include "windef.h"
+
+typedef unsigned char MSVCP_bool;
+typedef SIZE_T MSVCP_size_t;
+typedef SIZE_T streamoff;
+typedef SIZE_T streamsize;
+
+void __cdecl _invalid_parameter(const wchar_t*, const wchar_t*,
+        const wchar_t*, unsigned int, uintptr_t);
+
+extern void* (__cdecl *MSVCRT_operator_new)(MSVCP_size_t);
+extern void (__cdecl *MSVCRT_operator_delete)(void*);
+extern void* (__cdecl *MSVCRT_set_new_handler)(void*);
+
+/* Copied from dlls/msvcrt/cpp.c */
+#ifdef __i386__  /* thiscall functions are i386-specific */
+
+#define THISCALL(func) __thiscall_ ## func
+#define THISCALL_NAME(func) __ASM_NAME("__thiscall_" #func)
+#define __thiscall __stdcall
+#define DEFINE_THISCALL_WRAPPER(func,args) \
+    extern void THISCALL(func)(void); \
+    __ASM_GLOBAL_FUNC(__thiscall_ ## func, \
+                      "popl %eax\n\t" \
+                      "pushl %ecx\n\t" \
+                      "pushl %eax\n\t" \
+                      "jmp " __ASM_NAME(#func) __ASM_STDCALL(args) )
+#else /* __i386__ */
+
+#define THISCALL(func) func
+#define THISCALL_NAME(func) __ASM_NAME(#func)
+#define __thiscall __cdecl
+#define DEFINE_THISCALL_WRAPPER(func,args) /* nothing */
+
+#endif /* __i386__ */
+
+#ifdef _WIN64
+
+#define VTABLE_ADD_FUNC(name) "\t.quad " THISCALL_NAME(name) "\n"
+
+#define __ASM_VTABLE(name,funcs) \
+    __asm__(".data\n" \
+            "\t.align 8\n" \
+            "\t.quad " __ASM_NAME(#name "_rtti") "\n" \
+            "\t.globl " __ASM_NAME("MSVCP_" #name "_vtable") "\n" \
+            __ASM_NAME("MSVCP_" #name "_vtable") ":\n" \
+            "\t.quad " THISCALL_NAME(MSVCP_ ## name ## _vector_dtor) "\n" \
+            funcs "\n\t.text")
+
+#else
+
+#define VTABLE_ADD_FUNC(name) "\t.long " THISCALL_NAME(name) "\n"
+
+#define __ASM_VTABLE(name,funcs) \
+    __asm__(".data\n" \
+            "\t.align 4\n" \
+            "\t.long " __ASM_NAME(#name "_rtti") "\n" \
+            "\t.globl " __ASM_NAME("MSVCP_" #name "_vtable") "\n" \
+            __ASM_NAME("MSVCP_" #name "_vtable") ":\n" \
+            "\t.long " THISCALL_NAME(MSVCP_ ## name ## _vector_dtor) "\n" \
+            funcs "\n\t.text")
+
+#endif /* _WIN64 */
+
+#define DEFINE_RTTI_DATA(name, off, base_classes, cl1, cl2, cl3, mangled_name) \
+static const type_info name ## _type_info = { \
+    &MSVCP_ ## name ## _vtable, \
+    NULL, \
+    mangled_name \
+}; \
+\
+static const rtti_base_descriptor name ## _rtti_base_descriptor = { \
+    &name ##_type_info, \
+    base_classes, \
+    { 0, -1, 0}, \
+    64 \
+}; \
+\
+static const rtti_base_array name ## _rtti_base_array = { \
+    { \
+        &name ## _rtti_base_descriptor, \
+        cl1, \
+        cl2, \
+        cl3 \
+    } \
+}; \
+\
+static const rtti_object_hierarchy name ## _hierarchy = { \
+    0, \
+    0, \
+    base_classes+1, \
+    &name ## _rtti_base_array \
+}; \
+\
+const rtti_object_locator name ## _rtti = { \
+    0, \
+    off, \
+    0, \
+    &name ## _type_info, \
+    &name ## _hierarchy \
+}
+
+#ifdef __i386__
+
+#define CALL_VTBL_FUNC(this, off, ret, type, args) ((ret (WINAPI*)type)&vtbl_wrapper_##off)args
+
+extern void *vtbl_wrapper_0;
+extern void *vtbl_wrapper_4;
+extern void *vtbl_wrapper_8;
+extern void *vtbl_wrapper_12;
+extern void *vtbl_wrapper_16;
+extern void *vtbl_wrapper_20;
+extern void *vtbl_wrapper_24;
+extern void *vtbl_wrapper_28;
+extern void *vtbl_wrapper_32;
+extern void *vtbl_wrapper_36;
+extern void *vtbl_wrapper_40;
+extern void *vtbl_wrapper_44;
+extern void *vtbl_wrapper_48;
+extern void *vtbl_wrapper_52;
+extern void *vtbl_wrapper_56;
+extern void *vtbl_wrapper_60;
+
+#else
+
+#define CALL_VTBL_FUNC(this, off, ret, type, args) ((ret (__cdecl***)type)this)[0][off/4]args
+
+#endif
+
+/* exception object */
+typedef void (*vtable_ptr)(void);
+typedef struct __exception
+{
+    const vtable_ptr *vtable;
+    char             *name;    /* Name of this exception, always a new copy for each object */
+    int               do_free; /* Whether to free 'name' in our dtor */
+} exception;
+
+/* Internal: throws selected exception */
+typedef enum __exception_type {
+    EXCEPTION,
+    EXCEPTION_BAD_ALLOC,
+    EXCEPTION_LOGIC_ERROR,
+    EXCEPTION_LENGTH_ERROR,
+    EXCEPTION_OUT_OF_RANGE,
+    EXCEPTION_INVALID_ARGUMENT,
+    EXCEPTION_RUNTIME_ERROR
+} exception_type;
+void throw_exception(exception_type, const char *);
+void set_exception_vtable(void);
+
+/* rtti */
+typedef struct __type_info
+{
+    const vtable_ptr *vtable;
+    char              *name;        /* Unmangled name, allocated lazily */
+    char               mangled[64]; /* Variable length, but we declare it large enough for static RTTI */
+} type_info;
+
+/* offsets for computing the this pointer */
+typedef struct
+{
+    int         this_offset;   /* offset of base class this pointer from start of object */
+    int         vbase_descr;   /* offset of virtual base class descriptor */
+    int         vbase_offset;  /* offset of this pointer offset in virtual base class descriptor */
+} this_ptr_offsets;
+
+typedef struct _rtti_base_descriptor
+{
+    const type_info *type_descriptor;
+    int num_base_classes;
+    this_ptr_offsets offsets;    /* offsets for computing the this pointer */
+    unsigned int attributes;
+} rtti_base_descriptor;
+
+typedef struct _rtti_base_array
+{
+    const rtti_base_descriptor *bases[4]; /* First element is the class itself */
+} rtti_base_array;
+
+typedef struct _rtti_object_hierarchy
+{
+    unsigned int signature;
+    unsigned int attributes;
+    int array_len; /* Size of the array pointed to by 'base_classes' */
+    const rtti_base_array *base_classes;
+} rtti_object_hierarchy;
+
+typedef struct _rtti_object_locator
+{
+    unsigned int signature;
+    int base_class_offset;
+    unsigned int flags;
+    const type_info *type_descriptor;
+    const rtti_object_hierarchy *type_hierarchy;
+} rtti_object_locator;
+
+/* basic_string<char, char_traits<char>, allocator<char>> */
+#define BUF_SIZE_CHAR 16
+typedef struct _basic_string_char
+{
+    void *allocator;
+    char *ptr;
+    MSVCP_size_t size;
+    MSVCP_size_t res;
+} basic_string_char;
+
+basic_string_char* __stdcall MSVCP_basic_string_char_ctor_cstr(basic_string_char*, const char*);
+basic_string_char* __stdcall MSVCP_basic_string_char_copy_ctor(basic_string_char*, const basic_string_char*);
+void __stdcall MSVCP_basic_string_char_dtor(basic_string_char*);
+const char* __stdcall MSVCP_basic_string_char_c_str(const basic_string_char*);
+
+#define BUF_SIZE_WCHAR 8
+typedef struct _basic_string_wchar
+{
+    void *allocator;
+    wchar_t *ptr;
+    MSVCP_size_t size;
+    MSVCP_size_t res;
+} basic_string_wchar;
+
+char* __stdcall MSVCP_allocator_char_allocate(void*, MSVCP_size_t);
+void __stdcall MSVCP_allocator_char_deallocate(void*, char*, MSVCP_size_t);
+MSVCP_size_t __stdcall MSVCP_allocator_char_max_size(void*);
+wchar_t* __stdcall MSVCP_allocator_wchar_allocate(void*, MSVCP_size_t);
+void __stdcall MSVCP_allocator_wchar_deallocate(void*, wchar_t*, MSVCP_size_t);
+MSVCP_size_t __stdcall MSVCP_allocator_wchar_max_size(void*);
+
+/* class locale */
+typedef struct
+{
+    struct _locale__Locimp *ptr;
+} locale;
+
+locale* __thiscall locale_ctor(locale*);
+void __thiscall locale_dtor(locale*);
+
+/* class _Lockit */
+typedef struct {
+    int locktype;
+} _Lockit;
+
+#define _LOCK_LOCALE 0
+#define _LOCK_MALLOC 1
+#define _LOCK_STREAM 2
+#define _LOCK_DEBUG 3
+#define _MAX_LOCK 4
+
+void init_lockit(void);
+void free_lockit(void);
+_Lockit* __thiscall _Lockit_ctor_locktype(_Lockit*, int);
+void __thiscall _Lockit_dtor(_Lockit*);
+
+/* class mutex */
+typedef struct {
+        void *mutex;
+} mutex;
+
+mutex* __thiscall mutex_ctor(mutex*);
+void __thiscall mutex_dtor(mutex*);
+void __thiscall mutex_lock(mutex*);
+void __thiscall mutex_unlock(mutex*);

dlls/msvcp60/msvcp60.c

-/*
- * msvcp60 specific functions
- *
- * Copyright 2010 Piotr Caban for CodeWeavers
- *
- * 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
- */
-
-#include <stdarg.h>
-
-#include "windef.h"
-#include "winbase.h"
-
-BOOL WINAPI DllMain(HINSTANCE hdll, DWORD reason, LPVOID reserved)
-{
-    switch (reason)
-    {
-        case DLL_WINE_PREATTACH:
-            return FALSE;  /* prefer native version */
-
-        case DLL_PROCESS_ATTACH:
-            DisableThreadLibraryCalls(hdll);
-    }
-    return TRUE;
-}