/* * msvcr100 specific functions * * Copyright 2010 Detlef Riekenberg * * 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 #include "stdio.h" #include "stdlib.h" #include "errno.h" #include "malloc.h" #include "limits.h" #include "sys/stat.h" #include "windef.h" #include "winbase.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(msvcrt); #define INVALID_PMT(x,err) (*_errno() = (err), _invalid_parameter(NULL, NULL, NULL, 0, 0)) #define CHECK_PMT_ERR(x,err) ((x) || (INVALID_PMT( 0, (err) ), FALSE)) #define CHECK_PMT(x) CHECK_PMT_ERR((x), EINVAL) #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__ */ struct __type_info_node { void *memPtr; struct __type_info_node* next; }; typedef struct __type_info { const void *vtable; char *name; /* Unmangled name, allocated lazily */ char mangled[32]; /* Variable length, but we declare it large enough for static RTTI */ } type_info; typedef void* (__cdecl *malloc_func_t)(size_t); typedef void (__cdecl *free_func_t)(void*); extern char* __cdecl __unDName(char *,const char*,int,malloc_func_t,free_func_t,unsigned short int); /********************************************************************* * * stat64_to_stat32 [internal] * */ static void stat64_to_stat32(const struct _stat64 *buf64, struct _stat32 *buf) { buf->st_dev = buf64->st_dev; buf->st_ino = buf64->st_ino; buf->st_mode = buf64->st_mode; buf->st_nlink = buf64->st_nlink; buf->st_uid = buf64->st_uid; buf->st_gid = buf64->st_gid; buf->st_rdev = buf64->st_rdev; buf->st_size = buf64->st_size; buf->st_atime = buf64->st_atime; buf->st_mtime = buf64->st_mtime; buf->st_ctime = buf64->st_ctime; } /********************************************************************* * wmemcpy_s (MSVCR100.@) */ int CDECL wmemcpy_s(wchar_t *dest, size_t numberOfElements, const wchar_t *src, size_t count) { TRACE("(%p %lu %p %lu)\n", dest, (unsigned long)numberOfElements, src, (unsigned long)count); if (!count) return 0; if (!CHECK_PMT(dest != NULL)) return EINVAL; if (!CHECK_PMT(src != NULL)) { memset(dest, 0, numberOfElements*sizeof(wchar_t)); return EINVAL; } if (!CHECK_PMT_ERR(count <= numberOfElements, ERANGE)) { memset(dest, 0, numberOfElements*sizeof(wchar_t)); return ERANGE; } memcpy(dest, src, sizeof(wchar_t)*count); return 0; } /********************************************************************* * wmemmove_s (MSVCR100.@) */ int CDECL wmemmove_s(wchar_t *dest, size_t numberOfElements, const wchar_t *src, size_t count) { TRACE("(%p %lu %p %lu)\n", dest, (unsigned long)numberOfElements, src, (unsigned long)count); if (!count) return 0; /* Native does not seem to conform to 6.7.1.2.3 in * http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1225.pdf * in that it does not zero the output buffer on constraint violation. */ if (!CHECK_PMT(dest != NULL)) return EINVAL; if (!CHECK_PMT(src != NULL)) return EINVAL; if (!CHECK_PMT_ERR(count <= numberOfElements, ERANGE)) return ERANGE; memmove(dest, src, sizeof(wchar_t)*count); return 0; } /********************************************************************* * _encoded_null (MSVCR100.@) */ void * CDECL _encoded_null(void) { TRACE("\n"); return EncodePointer(NULL); } /********************************************************************* * _invalid_parameter_noinfo (MSVCR100.@) */ void CDECL _invalid_parameter_noinfo(void) { _invalid_parameter( NULL, NULL, NULL, 0, 0 ); } /********************************************************************* * __sys_nerr (MSVCR100.@) */ int* CDECL __sys_nerr(void) { return (int*)GetProcAddress(GetModuleHandleA("msvcrt.dll"), "_sys_nerr"); } /********************************************************************* * __sys_errlist (MSVCR100.@) */ char** CDECL __sys_errlist(void) { return (char**)GetProcAddress(GetModuleHandleA("msvcrt.dll"), "_sys_errlist"); } /********************************************************************* * __clean_type_info_names_internal (MSVCR100.@) */ void CDECL __clean_type_info_names_internal(void *p) { FIXME("(%p) stub\n", p); } /********************************************************************* * _recalloc (MSVCR100.@) */ void* CDECL _recalloc(void* mem, size_t num, size_t size) { size_t old_size; void *ret; if(!mem) return calloc(num, size); size = num*size; old_size = _msize(mem); ret = realloc(mem, size); if(!ret) { *_errno() = ENOMEM; return NULL; } if(size>old_size) memset((BYTE*)ret+old_size, 0, size-old_size); return ret; } /********************************************************************* * _fstat32 (MSVCR100.@) */ int CDECL _fstat32(int fd, struct _stat32* buf) { int ret; struct _stat64 buf64; ret = _fstat64(fd, &buf64); if (!ret) stat64_to_stat32(&buf64, buf); return ret; } /********************************************************************* * _stat32 (MSVCR100.@) */ int CDECL _stat32(const char *path, struct _stat32* buf) { int ret; struct _stat64 buf64; ret = _stat64(path, &buf64); if (!ret) stat64_to_stat32(&buf64, buf); return ret; } /********************************************************************* * _wstat32 (MSVCR100.@) */ int CDECL _wstat32(const wchar_t *path, struct _stat32* buf) { int ret; struct _stat64 buf64; ret = _wstat64(path, &buf64); if (!ret) stat64_to_stat32(&buf64, buf); return ret; } static void stat64_to_stat64i32(const struct _stat64 *buf64, struct _stat64i32 *buf) { buf->st_dev = buf64->st_dev; buf->st_ino = buf64->st_ino; buf->st_mode = buf64->st_mode; buf->st_nlink = buf64->st_nlink; buf->st_uid = buf64->st_uid; buf->st_gid = buf64->st_gid; buf->st_rdev = buf64->st_rdev; buf->st_size = buf64->st_size; buf->st_atime = buf64->st_atime; buf->st_mtime = buf64->st_mtime; buf->st_ctime = buf64->st_ctime; } /********************************************************************* * _fstat64i32 (MSVCR100.@) */ int CDECL _fstat64i32(int fd, struct _stat64i32* buf) { int ret; struct _stat64 buf64; ret = _fstat64(fd, &buf64); if (!ret) stat64_to_stat64i32(&buf64, buf); return ret; } /********************************************************************* * _stat64i32 (MSVCR100.@) */ int CDECL _stat64i32(const char* path, struct _stat64i32 * buf) { int ret; struct _stat64 buf64; ret = _stat64(path, &buf64); if (!ret) stat64_to_stat64i32(&buf64, buf); return ret; } /********************************************************************* * _wstat64i32 (MSVCR100.@) */ int CDECL _wstat64i32(const wchar_t *path, struct _stat64i32 *buf) { int ret; struct _stat64 buf64; ret = _wstat64(path, &buf64); if (!ret) stat64_to_stat64i32(&buf64, buf); return ret; } /********************************************************************* * _atoflt (MSVCR100.@) */ int CDECL _atoflt( _CRT_FLOAT *value, char *str ) { return _atoflt_l( value, str, NULL ); } /********************************************************************* * ?_name_internal_method@type_info@@QBEPBDPAU__type_info_node@@@Z (MSVCR100.@) */ DEFINE_THISCALL_WRAPPER(type_info_name_internal_method,8) const char * __thiscall type_info_name_internal_method(type_info * _this, struct __type_info_node *node) { static int once; if (node && !once++) FIXME("type_info_node parameter ignored\n"); if (!_this->name) { /* Create and set the demangled name */ /* Note: mangled name in type_info struct always starts with a '.', while * it isn't valid for mangled name. * Is this '.' really part of the mangled name, or has it some other meaning ? */ char* name = __unDName(0, _this->mangled + 1, 0, malloc, free, 0x2800); if (name) { unsigned int len = strlen(name); /* It seems _unDName may leave blanks at the end of the demangled name */ while (len && name[--len] == ' ') name[len] = '\0'; if (InterlockedCompareExchangePointer((void**)&_this->name, name, NULL)) { /* Another thread set this member since we checked above - use it */ free(name); } } } TRACE("(%p) returning %s\n", _this, _this->name); return _this->name; } /********************************************************************* * _CRT_RTC_INIT (MSVCR100.@) */ void* CDECL _CRT_RTC_INIT(void *unk1, void *unk2, int unk3, int unk4, int unk5) { TRACE("%p %p %x %x %x\n", unk1, unk2, unk3, unk4, unk5); return NULL; } /********************************************************************* * _CRT_RTC_INITW (MSVCR100.@) */ void* CDECL _CRT_RTC_INITW(void *unk1, void *unk2, int unk3, int unk4, int unk5) { TRACE("%p %p %x %x %x\n", unk1, unk2, unk3, unk4, unk5); return NULL; } /********************************************************************* * _vswprintf_p (MSVCR100.@) */ int CDECL _vswprintf_p(wchar_t *buffer, size_t length, const wchar_t *format, __ms_va_list args) { return _vswprintf_p_l(buffer, length, format, NULL, args); } /********************************************************************* * _byteswap_ushort (MSVCR100.@) */ unsigned short CDECL _byteswap_ushort(unsigned short s) { return (s<<8) + (s>>8); } /********************************************************************* * _byteswap_ulong (MSVCR100.@) */ ULONG CDECL _byteswap_ulong(ULONG l) { return (l<<24) + ((l<<8)&0xFF0000) + ((l>>8)&0xFF00) + (l>>24); } /********************************************************************* * _byteswap_uint64 (MSVCR100.@) */ unsigned __int64 CDECL _byteswap_uint64(unsigned __int64 i) { return (i<<56) + ((i&0xFF00)<<40) + ((i&0xFF0000)<<24) + ((i&0xFF000000)<<8) + ((i>>8)&0xFF000000) + ((i>>24)&0xFF0000) + ((i>>40)&0xFF00) + (i>>56); } /********************************************************************* * fread_s (MSVCR100.@) */ size_t CDECL fread_s(void *buf, size_t buf_size, size_t elem_size, size_t count, FILE *stream) { size_t bytes_left, buf_pos; TRACE("(%p %lu %lu %lu %p\n", buf, (unsigned long)buf_size, (unsigned long)elem_size, (unsigned long)count, stream); if(!CHECK_PMT(stream != NULL)) { if(buf && buf_size) memset(buf, 0, buf_size); return 0; } if(!elem_size || !count) return 0; if(!CHECK_PMT(buf != NULL)) return 0; if(!CHECK_PMT(SIZE_MAX/count >= elem_size)) return 0; bytes_left = elem_size*count; buf_pos = 0; while(bytes_left) { if(stream->_cnt > 0) { size_t size = bytes_left_cnt ? bytes_left : stream->_cnt; if(!CHECK_PMT_ERR(size <= buf_size-buf_pos, ERANGE)) { memset(buf, 0, buf_size); return 0; } fread((char*)buf+buf_pos, 1, size, stream); buf_pos += size; bytes_left -= size; }else { int c = _filbuf(stream); if(c == EOF) break; if(!CHECK_PMT_ERR(buf_size-buf_pos > 0, ERANGE)) { memset(buf, 0, buf_size); return 0; } ((char*)buf)[buf_pos++] = c; bytes_left--; } } return buf_pos/elem_size; } /********************************************************************* * _sprintf_p (MSVCR100.@) */ int CDECL _sprintf_p(char *buffer, size_t length, const char *format, ...) { __ms_va_list valist; int r; __ms_va_start(valist, format); r = _vsprintf_p_l(buffer, length, format, NULL, valist); __ms_va_end(valist); return r; } /********************************************************************* * _get_timezone (MSVCR100.@) */ int CDECL _get_timezone(LONG *timezone) { if(!CHECK_PMT(timezone != NULL)) return EINVAL; *timezone = *(LONG*)GetProcAddress(GetModuleHandleA("msvcrt.dll"), "_timezone"); return 0; } /* copied from dlls/msvcrt/heap.c */ #define SAVED_PTR(x) ((void *)((DWORD_PTR)((char *)x - sizeof(void *)) & \ ~(sizeof(void *) - 1))) /********************************************************************* * _aligned_msize (MSVCR100.@) */ size_t CDECL _aligned_msize(void *p, size_t alignment, size_t offset) { void **alloc_ptr; if(!CHECK_PMT(p)) return -1; if(alignment < sizeof(void*)) alignment = sizeof(void*); alloc_ptr = SAVED_PTR(p); return _msize(*alloc_ptr)-alignment-sizeof(void*); } /********************************************************************* * DllMain (MSVCR100.@) */ 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); _set_printf_count_output(0); } return TRUE; }