compat.c File Reference

#include "dbghelp_private.h"

Include dependency graph for compat.c:

Go to the source code of this file.

Functions
void *	__HeapAlloc (int heap, int flags, size_t size)
void *	__HeapReAlloc (int heap, DWORD d2, void *slab, SIZE_T newsize)
WCHAR *	lstrcpynW (WCHAR *lpString1, const WCHAR *lpString2, int iMaxLength)
PIMAGE_NT_HEADERS	__RtlImageNtHeader (void *data)
PIMAGE_SECTION_HEADER	__RtlImageRvaToSection (const IMAGE_NT_HEADERS *NtHeader, PVOID BaseAddress, ULONG Rva)
PVOID	__RtlImageRvaToVa (const IMAGE_NT_HEADERS *NtHeader, PVOID BaseAddress, ULONG Rva, PIMAGE_SECTION_HEADER *SectionHeader)
PVOID	__RtlImageDirectoryEntryToData (PVOID BaseAddress, BOOLEAN MappedAsImage, USHORT Directory, PULONG Size)
BOOL	__GetFileSizeEx (HANDLE file, PLARGE_INTEGER fsize)
BOOL	__CloseHandle (HANDLE handle)
HANDLE	__CreateFileW (LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
BOOL	__ReadFile (HANDLE file, PVOID buffer, DWORD len, PDWORD outlen, PVOID overlap)
DWORD	__SetFilePointer (HANDLE file, LONG low, PLONG high, DWORD move)
void *	__MapViewOfFile (HANDLE file, DWORD d1, DWORD d2, DWORD d3, SIZE_T s)
BOOL	__UnmapViewOfFile (const void *data)
LPSTR	__lstrcpynA (LPSTR d, LPCSTR s, int c)
INT	__WideCharToMultiByte (UINT page, DWORD flags, LPCWSTR src, INT srclen, LPSTR dst, INT dstlen, LPCSTR defchar, BOOL *used)
INT	__MultiByteToWideChar (UINT page, DWORD flags, LPCSTR src, INT srclen, LPWSTR dst, INT dstlen)
HANDLE	__FindExecutableImageExW (PCWSTR file, PCWSTR path, PWSTR out_buffer, PFIND_EXE_FILE_CALLBACKW x, PVOID y)
const char *	wine_dbg_sprintf (const char *format,...)
const char *	wine_dbgstr_an (const char *str, int n)
const char *	wine_dbgstr_wn (const WCHAR *str, int n)
BOOL	__IsWow64Process (HANDLE Process, BOOL *is_wow64)
ULONG	__RtlComputeCrc32 (ULONG Initial, const UCHAR *Data, ULONG Length)

Variables
static const ULONG	CrcTable [256]

Function Documentation

__CloseHandle()

BOOL __CloseHandle

(

HANDLE

handle

)

Definition at line 146 of file compat.c.

{
    fclose(handle);
    return TRUE;
}

__CreateFileW()

HANDLE __CreateFileW	(	LPCWSTR	lpFileName,
		DWORD	dwDesiredAccess,
		DWORD	dwShareMode,
		LPSECURITY_ATTRIBUTES	lpSecurityAttributes,
		DWORD	dwCreationDisposition,
		DWORD	dwFlagsAndAttributes,
		HANDLE	hTemplateFile
	)

Definition at line 152 of file compat.c.

{
    char buf[MAX_PATH];
    HANDLE res;
 
    WideCharToMultiByte(CP_ACP, 0, lpFileName, -1, buf, MAX_PATH, NULL, NULL);
    res = CreateFileA(buf, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
    return res;
}

__FindExecutableImageExW()

HANDLE __FindExecutableImageExW	(	PCWSTR	file,
		PCWSTR	path,
		PWSTR	out_buffer,
		PFIND_EXE_FILE_CALLBACKW	x,
		PVOID	y
	)

Definition at line 286 of file compat.c.

{
    HANDLE ret = CreateFileW(file, 0, 0, NULL, 0, 0, NULL);
    if(ret)
        memcpy(out_buffer, file, (strlenW(file) + 1)*sizeof(WCHAR));
 
    return ret;
}

__GetFileSizeEx()

BOOL __GetFileSizeEx	(	HANDLE	file,
		PLARGE_INTEGER	fsize
	)

Definition at line 138 of file compat.c.

{
    if (fseek((FILE*)file, 0, 2) == -1)
        return FALSE;
    fsize->QuadPart = ftell((FILE*)file);
    return TRUE;
}

__HeapAlloc()

void * __HeapAlloc	(	int	heap,
		int	flags,
		size_t	size
	)

Definition at line 3 of file compat.c.

{
    void * ret = malloc(size);
    if(flags & HEAP_ZERO_MEMORY)
        memset(ret, 0, size);
    return ret;
}

__HeapReAlloc()

void * __HeapReAlloc	(	int	heap,
		DWORD	d2,
		void *	slab,
		SIZE_T	newsize
	)

Definition at line 11 of file compat.c.

{
    return realloc(slab, newsize);
}

__IsWow64Process()

BOOL __IsWow64Process	(	HANDLE	Process,
		BOOL *	is_wow64
	)

Definition at line 423 of file compat.c.

{
    *is_wow64 = FALSE;
    return TRUE;
}

__lstrcpynA()

LPSTR __lstrcpynA	(	LPSTR	d,
		LPCSTR	s,
		int	c
	)

Definition at line 225 of file compat.c.

{
    LPSTR r = d;
    while(*s && c)
    {
        *d++ = *s++;
        c--;
    }
    return r;
}

__MapViewOfFile()

void * __MapViewOfFile	(	HANDLE	file,
		DWORD	d1,
		DWORD	d2,
		DWORD	d3,
		SIZE_T	s
	)

Definition at line 194 of file compat.c.

{
    FILE *f = (FILE*)file;
    LARGE_INTEGER size;
    char *result;
 
    if (file == INVALID_HANDLE_VALUE)
        return NULL;
 
    if (!GetFileSizeEx(file, &size))
        return NULL;
 
    if (fseek(f, 0, 0) == -1)
        return NULL;
 
    result = malloc(size.LowPart);
    if (fread(result, 1, size.LowPart, f) != size.LowPart)
    {
        free(result);
        return NULL;
    }
 
    return result;
}

__MultiByteToWideChar()

INT __MultiByteToWideChar	(	UINT	page,
		DWORD	flags,
		LPCSTR	src,
		INT	srclen,
		LPWSTR	dst,
		INT	dstlen
	)

Definition at line 263 of file compat.c.

{
    int i;
 
    if (!src || !srclen || (!dst && dstlen))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
 
    if (srclen < 0) srclen = strlen(src) + 1;
 
    if(!dstlen)
        return srclen;
 
    for(i=0; i<srclen && i<dstlen; i++)
        dst[i] = src[i];
 
    return i;
}

__ReadFile()

BOOL __ReadFile	(	HANDLE	file,
		PVOID	buffer,
		DWORD	len,
		PDWORD	outlen,
		PVOID	overlap
	)

Definition at line 169 of file compat.c.

{
    size_t read;
 
    assert(overlap == NULL);
 
    read = fread(buffer, 1, len, file);
 
    if (ferror(file) != 0)
        return FALSE;
 
    *outlen = (DWORD)read;
    return TRUE;
}

__RtlComputeCrc32()

ULONG __RtlComputeCrc32	(	ULONG	Initial,
		const UCHAR *	Data,
		ULONG	Length
	)

Definition at line 501 of file compat.c.

{
  ULONG CrcValue = ~Initial;
 
  while (Length > 0)
  {
    CrcValue = CrcTable[(CrcValue ^ *Data) & 0xff] ^ (CrcValue >> 8);
    Data++;
    Length--;
  }
  return ~CrcValue;
}

__RtlImageDirectoryEntryToData()

PVOID __RtlImageDirectoryEntryToData	(	PVOID	BaseAddress,
		BOOLEAN	MappedAsImage,
		USHORT	Directory,
		PULONG	Size
	)

Definition at line 102 of file compat.c.

{
    PIMAGE_NT_HEADERS NtHeader;
    ULONG Va;
 
    /* Magic flag for non-mapped images. */
    if ((ULONG_PTR)BaseAddress & 1)
    {
        BaseAddress = (PVOID)((ULONG_PTR)BaseAddress & ~1);
        MappedAsImage = FALSE;
    }
 
    NtHeader = RtlImageNtHeader(BaseAddress);
    if (NtHeader == NULL)
        return NULL;
 
    if (Directory >= SWAPD(NtHeader->OptionalHeader.NumberOfRvaAndSizes))
        return NULL;
 
    Va = SWAPD(NtHeader->OptionalHeader.DataDirectory[Directory].VirtualAddress);
    if (Va == 0)
        return NULL;
 
    *Size = SWAPD(NtHeader->OptionalHeader.DataDirectory[Directory].Size);
 
    if (MappedAsImage || Va < SWAPD(NtHeader->OptionalHeader.SizeOfHeaders))
        return (PVOID)((ULONG_PTR)BaseAddress + Va);
 
    /* Image mapped as ordinary file, we must find raw pointer */
    return RtlImageRvaToVa(NtHeader, BaseAddress, Va, NULL);
}

__RtlImageNtHeader()

PIMAGE_NT_HEADERS __RtlImageNtHeader

(

void *

data

)

Definition at line 34 of file compat.c.

{
    PIMAGE_DOS_HEADER DosHeader = (PIMAGE_DOS_HEADER)data;
    PIMAGE_NT_HEADERS NtHeaders;
    PCHAR NtHeaderPtr;
    if (DosHeader->e_magic != IMAGE_DOS_SIGNATURE)
        return NULL;
    NtHeaderPtr = ((PCHAR)data) + DosHeader->e_lfanew;
    NtHeaders = (PIMAGE_NT_HEADERS)NtHeaderPtr;
    if (NtHeaders->Signature != IMAGE_NT_SIGNATURE)
        return NULL;
    return NtHeaders;
}

__RtlImageRvaToSection()

PIMAGE_SECTION_HEADER __RtlImageRvaToSection	(	const IMAGE_NT_HEADERS *	NtHeader,
		PVOID	BaseAddress,
		ULONG	Rva
	)

Definition at line 49 of file compat.c.

{
    PIMAGE_SECTION_HEADER Section;
    ULONG Va;
    ULONG Count;
 
    Count = SWAPW(NtHeader->FileHeader.NumberOfSections);
    Section = IMAGE_FIRST_SECTION(NtHeader);
 
    while (Count--)
    {
        Va = SWAPD(Section->VirtualAddress);
        if ((Va <= Rva) && (Rva < Va + SWAPD(Section->SizeOfRawData)))
            return Section;
        Section++;
    }
 
    return NULL;
}

__RtlImageRvaToVa()

PVOID __RtlImageRvaToVa	(	const IMAGE_NT_HEADERS *	NtHeader,
		PVOID	BaseAddress,
		ULONG	Rva,
		PIMAGE_SECTION_HEADER *	SectionHeader
	)

Definition at line 73 of file compat.c.

{
    PIMAGE_SECTION_HEADER Section = NULL;
 
    if (SectionHeader)
        Section = *SectionHeader;
 
    if ((Section == NULL) ||
        (Rva < SWAPD(Section->VirtualAddress)) ||
        (Rva >= SWAPD(Section->VirtualAddress) + SWAPD(Section->SizeOfRawData)))
    {
        Section = RtlImageRvaToSection(NtHeader, BaseAddress, Rva);
        if (Section == NULL)
            return NULL;
 
        if (SectionHeader)
            *SectionHeader = Section;
    }
 
    return (PVOID)((ULONG_PTR)BaseAddress + Rva +
                   (ULONG_PTR)SWAPD(Section->PointerToRawData) -
                   (ULONG_PTR)SWAPD(Section->VirtualAddress));
}

__SetFilePointer()

DWORD __SetFilePointer	(	HANDLE	file,
		LONG	low,
		PLONG	high,
		DWORD	move
	)

Definition at line 184 of file compat.c.

{
    assert(move == FILE_BEGIN);
    assert(high == NULL);
 
    if (fseek(file, low, SEEK_SET))
        return INVALID_SET_FILE_POINTER;
    return low;
}

__UnmapViewOfFile()

BOOL __UnmapViewOfFile

(

const void *

data

)

Definition at line 219 of file compat.c.

{
    free((void *)data);
    return TRUE;
}

__WideCharToMultiByte()

INT __WideCharToMultiByte	(	UINT	page,
		DWORD	flags,
		LPCWSTR	src,
		INT	srclen,
		LPSTR	dst,
		INT	dstlen,
		LPCSTR	defchar,
		BOOL *	used
	)

Definition at line 238 of file compat.c.

{
    int i;
 
    if (!src || !srclen || (!dst && dstlen))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
 
    if (srclen < 0) srclen = strlenW(src) + 1;
 
    if(!dstlen)
        return srclen;
 
    for(i=0; i<srclen && i<dstlen; i++)
        dst[i] = src[i] & 0xFF;
 
    if (used) *used = FALSE;
 
    return i;
}

lstrcpynW()

WCHAR * lstrcpynW	(	WCHAR *	lpString1,
		const WCHAR *	lpString2,
		int	iMaxLength
	)

Definition at line 16 of file compat.c.

{
    LPWSTR d = lpString1;
    const WCHAR* s = lpString2;
    UINT count = iMaxLength;
 
    while ((count > 1) && *s)
    {
        count--;
        *d++ = *s++;
    }
 
    if (count)
        *d = 0;
 
    return lpString1;
}

wine_dbg_sprintf()

const char * wine_dbg_sprintf	(	const char *	format,
			...
	)

Definition at line 296 of file compat.c.

{
    static const int max_size = 200;
    static char buffer[256];
    char *ret;
    int len;
    va_list valist;
 
    va_start(valist, format);
    ret = buffer;
    len = vsnprintf( ret, max_size, format, valist );
    if (len == -1 || len >= max_size) ret[max_size-1] = 0;
    va_end(valist);
    return ret;
}

Referenced by context_dump_fbo_attachment(), dbgstr_SYSTEMTIME(), dbgstr_tag(), dbgstr_type_info(), debug_box(), debug_color(), debug_const_bo_address(), debug_cs_op(), debug_d2d_color_f(), debug_d2d_ellipse(), debug_d2d_point_2f(), debug_d2d_point_2l(), debug_d2d_rect_f(), debug_d2d_rect_l(), debug_d2d_rounded_rect(), debug_d3d_driver_type(), debug_d3dshaderinstructionhandler(), debug_d3dstate(), debug_d3dusage(), debug_d3dx_pixels(), debug_dxgi_mode(), debug_dxgi_mode1(), debug_fboattachment(), debug_float4(), debug_gl_shader_type(), debug_ivec4(), debug_print_dstreg(), debug_print_relarg(), debug_print_srcreg(), debug_print_swizzle(), debug_print_writemask(), debug_uvec4(), debug_vec4(), debug_vk_version(), debug_volume(), debug_wic_rect(), debuglvhittestinfo(), debugnmlistview(), debugrange(), debugstr_bindstatus(), debugstr_chunk(), debugstr_DMUS_IO_CONTAINED_OBJECT_HEADER(), debugstr_DMUS_IO_CONTAINER_HEADER(), debugstr_filetime(), debugstr_flags(), debugstr_formatetc(), debugstr_INTERPRETER_OPT_FLAGS(), debugstr_jsstr(), debugstr_jsval(), debugstr_matrix(), debugstr_nodetype(), debugstr_normalized_rect(), debugstr_ok(), debugstr_pointf(), debugstr_PROC_PF(), debugstr_protocol_flags(), debugstr_range(), debugstr_reader_prop(), debugstr_rectf(), debugstr_rundescr(), debugstr_sf_gen(), debugstr_sf_generator(), debugstr_sf_mod(), debugstr_sid(), debugstr_sqllen(), debugstr_sqlulen(), debugstr_status_info(), debugstr_time(), debugstr_user_flags(), debugstr_version(), debugstr_vk(), debugstr_wm(), debugstr_writer_prop(), debugstr_xml_attr(), debugstr_xml_elem(), device_io(), dump_fmtetc(), dumpCooperativeLevel(), DumpEvent(), dwarf2_debug_ctx(), dwarf2_debug_di(), dwarf2_debug_traverse_ctx(), filetime_to_str(), get_regname(), hex_str(), MCI_MessageToString(), resolve_STREAM_SEEK(), shdebugstr_guid(), SPY_GetMsgName(), strmbase_debugstr_guid(), wine_dbgstr_addr(), wine_dbgstr_icerr(), wined3d_debug_bind_flags(), wined3d_debug_feature_level(), wined3d_debug_location(), wined3d_debug_resource_access(), wined3d_debug_view_desc(), and wined3d_debug_vkresult().

wine_dbgstr_an()

const char * wine_dbgstr_an	(	const char *	str,
		int	n
	)

Definition at line 313 of file compat.c.

{
    static const char hex[16] = "0123456789abcdef";
    char *dst, *res;
    size_t size;
    static char buffer[256];
 
    if (!((ULONG_PTR)str >> 16))
    {
        if (!str) return "(null)";
        res = buffer;
        sprintf( res, "#%04x", LOWORD(str) );
        return res;
    }
    if (n == -1) n = strlen(str);
    if (n < 0) n = 0;
    size = 10 + min( 300, n * 4 );
    dst = res = buffer;
    *dst++ = '"';
    while (n-- > 0 && dst <= res + size - 9)
    {
        unsigned char c = *str++;
        switch (c)
        {
        case '\n': *dst++ = '\\'; *dst++ = 'n'; break;
        case '\r': *dst++ = '\\'; *dst++ = 'r'; break;
        case '\t': *dst++ = '\\'; *dst++ = 't'; break;
        case '"':  *dst++ = '\\'; *dst++ = '"'; break;
        case '\\': *dst++ = '\\'; *dst++ = '\\'; break;
        default:
            if (c >= ' ' && c <= 126)
                *dst++ = c;
            else
            {
                *dst++ = '\\';
                *dst++ = 'x';
                *dst++ = hex[(c >> 4) & 0x0f];
                *dst++ = hex[c & 0x0f];
            }
        }
    }
    *dst++ = '"';
    if (n > 0)
    {
        *dst++ = '.';
        *dst++ = '.';
        *dst++ = '.';
    }
    *dst++ = 0;
    return res;
}

Referenced by _test_file_contents(), test_mui(), test_PBKDF2(), test_strftime(), test_string_data(), test_string_data_process(), and wsprintfATest().

wine_dbgstr_wn()

const char * wine_dbgstr_wn	(	const WCHAR *	str,
		int	n
	)

Definition at line 367 of file compat.c.

{
    char *dst, *res;
    size_t size;
    static char buffer[256];
 
    if (!((ULONG_PTR)str >> 16))
    {
        if (!str) return "(null)";
        res = buffer;
        sprintf( res, "#%04x", LOWORD(str) );
        return res;
    }
    if (n == -1)
    {
        const WCHAR *end = str;
        while (*end) end++;
        n = end - str;
    }
    if (n < 0) n = 0;
    size = 12 + min( 300, n * 5 );
    dst = res = buffer;
    *dst++ = 'L';
    *dst++ = '"';
    while (n-- > 0 && dst <= res + size - 10)
    {
        WCHAR c = *str++;
        switch (c)
        {
        case '\n': *dst++ = '\\'; *dst++ = 'n'; break;
        case '\r': *dst++ = '\\'; *dst++ = 'r'; break;
        case '\t': *dst++ = '\\'; *dst++ = 't'; break;
        case '"':  *dst++ = '\\'; *dst++ = '"'; break;
        case '\\': *dst++ = '\\'; *dst++ = '\\'; break;
        default:
            if (c >= ' ' && c <= 126)
                *dst++ = c;
            else
            {
                *dst++ = '\\';
                sprintf(dst,"%04x",c);
                dst+=4;
            }
        }
    }
    *dst++ = '"';
    if (n > 0)
    {
        *dst++ = '.';
        *dst++ = '.';
        *dst++ = '.';
    }
    *dst++ = 0;
    return res;
}

Variable Documentation

CrcTable

const ULONG CrcTable[256]

static

Definition at line 438 of file compat.c.

Referenced by __RtlComputeCrc32().