mirror of
https://github.com/reactos/wine.git
synced 2024-12-24 12:36:54 +00:00
4f8c37b487
Sun Jan 14 13:45:22 1996 Alexandre Julliard <julliard@sunsite.unc.edu> * [configure.in] Added check for gcc strength-reduce bug. * [controls/listbox.c] Changed ListBoxDirectory() to use the new DOS file functions. * [controls/menu.c] Fixed parameters for DeleteMenu() call in ChangeMenu(). * [debugger/stack.c] Also display current frame in back-trace. * [files/directory.c] [files/dos_fs.c] [files/drive.c] [files/file.c] Complete rewrite of the DOS file handling. Implemented per-task file handles. Removed default Z: drive; needs to be put explicitely in wine.ini if desired. * [loader/module.c] Fixed file descriptor leak in LoadModule(). * [loader/task.c] Initialise PDB file handle table in TASK_CreateTask(). Close file handles on task termination. Implemented SetErrorMode(). * [misc/network.c] Fixed WNetGetConnection() to use GetDriveType(). * [misc/xmalloc.c] Added function xstrdup(). * [miscemu/int21.c] Many changes for new DOS file functions. * [miscemu/interrupts.c] Moved DOS_GetEquipment() function into INT_Int11Handler(). * [windows/win.c] Bug fix: create system menu before sending WM_NCCREATE. * [*/*.c] Replaced strcasecmp and strncasecmp by lstrcmpi and lstrncmpi for better portability. Sat Jan 13 16:13:02 1996 Jim Peterson <jspeter@birch.ee.vt.edu> * [include/wintypes.h] Added 'typedef HGLOBAL GOBALHANDLE;'. This is not precisely in line with the true windows 'typedef HANDLE GLOBALHANDLE;', but I believe it should suffice. * [include/winsock.h] Added '#include <arpa/inet.h>' for various declarations. '#ifdef'-ed out some old style internet address #define's. * [loader/task.c] Made MakeProcInstance() return first parameter #ifdef WINELIB32. Made FreeProcInstance() do nothing #ifdef WINELIB32. '#ifdef'-ed out TASK_AllocThunk(), as it was unused in WINELIB32. * [library/miscstubs.c] Made GetWndProcEntry16() return ACTIVATEAPP_callback() when called with name="ActivateAppProc". This hardly seems correct, but it's my best guess as to how the emulator responds. Sat Jan 6 17:57:45 1996 Martin von Loewis <loewis@informatik.hu-berlin.de> * [if1632/kernel32.spec][win32/process.c] WIN32_GetProcAddress, LoadLibraryA: new functions * [if1632/relay32.c] RELAY32_GetEntryPoint: Removed code to load PE DLLs * [include/pe_image.h][include/pe_exe.h] struct pe_data: new fields base_addr,load_addr,vma_size,pe_reloc struct PE_Reloc_Block: new structure * [loader/module.c] MODULE_RegisterModule: new function * [loader/pe_image.c] PE_FindExportedFunction,PE_GetProcAddress: new functions fixup_imports: expect struct w_files* now, fill dlls_to_init, load PE DLLs do_relocations: new functions calc_vma_size: renamed from dump_table PE_LoadImage: use malloc to allocate memory for image PE_InitDLL: expect HMODULE PE_InitializeDLLs: new function * [loader/task.c] NE_InitializeDLLs: branch to PE_InitializeDLLs for PE modules GetExePtr: Accept PE modules * [misc/commdlg.c] FILEDLG_WMCommand: unpack WIN32 WM_COMMAND appropriately for WineLib Thu Jan 4 11:36:21 1996 Manfred Weichel <Manfred.Weichel@mch.sni.de> * [misc/port.c] New file with usleep() function for SVR4. * [configure.in] Check for usleep() function. Tue Jan 02 14:00:00 1996 Anand Kumria <akumria@ozemail.com.au> * [if1632/toolhelp.spec] [include/toolhelp.h] [misc/user.c] [windows/message.c] Implement TOOLHELP.80 TimerCount. Fix GetTickCount. * [winsocket.c] Fixed ENOENT error. * [miscemu/dpmi.c] Implement DPMI Get Page Size (AX=0604, INT 31) * [memory/global.c] Implement TOOLHELP.72 GetMemManInfo. Mon Jan 2 10:33:00 1996 Thomas Sandford <t.d.g.sandford@prds-grn.demon.co.uk> * [if1632/callback.c] CallWindowProc() - When calling RELAY32_CallWindowProc, check whether lParam should be a SEGPTR, and if so convert it to one. * [if1632/gdi.spec] [if1632/kernel32.spec] [if1632/user32.spec] Numerous functions added, mostly calls to original (win16) functions. Note that some (many) of these are probably not strictly correct, but with these additions freecell will at least display its main window though it is garbled. * [if1632/winprocs.spec] Completely rewritten - all WndProcs now have win32 versions to help with the lparam SEGPTR fix in callback.c * [include/kernel32.h] LPTCSTR defined. * [include/peexe.h] Definition of PE_Export_Directory amended. * [include/resource32.h] New file. * [include/stackframe.h] Definition of MAKE_SEGPTR macro #ifdef'd out and replaced with prototype for replacement function in memory/selector.c which can operate on any given memory address. This is currently required for win32 support. It is a dreadful cludge, and will certainly slow down other programs. If you are not interested in win32 development you may wish to reverse this patch. * [include/windows.h] Definition of SW_SHOWDEFAULT added. * [loader/pe_image.c] Extensive rewrites of xmmap() fixup_imports(). PE_LoadImage() - initialisation of bss added, extraction of module name fixed, initialisation of DLL added. PE_InitDLL() - now does something. PE_Win32CallToStart() - initialisation of TEB pointed to by fs added. PE_InitTEB() created to perform TEB initialisation. * [memory/selector.c] New function MAKE_SEGPTR() - see include/stackframe.h above. * [misc/user32.c] USER32_RegisterClassA(), CreateWindowExA() memory allocation method changed. This is probably now unnecessary with the new MAKE_SEGPTR handling code. USER32_DefWndProcA() removed to win32/winprocs.c USER32_TranslateMessage added. * [tools/build.c] handling of win32 spec files changed to support gcc2.6.X this requires optimisations to be disabled. * [win32/resource.c] [win32/newfns.c] [win32/heap.c] [win32/winprocs.c] New files. * [win32/Makefile.in] New files heap.c, newfns.c, resource.c and winprocs.c added to build. * [win32/file.c] New function W32_SetHandleCount. * [win32/init.c] WIN32_GetModuleHandle() - now returns handle of running process if called with NULL. GetStartupInfoA() - set cbReserved2 to 0. * [win32/memory.c] VirtualAlloc() - set mmap() file parameter to -1 instead of 0 to make it work with FreeBSD. Also check for return value. Removed extra return. * [windows/winpos.c] ShowWindow() - SW_SHOWDEFAULT handling kludged in.
479 lines
14 KiB
C
479 lines
14 KiB
C
/*
|
|
* Selector manipulation functions
|
|
*
|
|
* Copyright 1995 Alexandre Julliard
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include "windows.h"
|
|
#include "ldt.h"
|
|
#include "selectors.h"
|
|
#include "stackframe.h"
|
|
#include "stddebug.h"
|
|
#include "debug.h"
|
|
|
|
|
|
#define FIRST_LDT_ENTRY_TO_ALLOC 6
|
|
|
|
|
|
/***********************************************************************
|
|
* AllocSelectorArray (KERNEL.206)
|
|
*/
|
|
WORD AllocSelectorArray( WORD count )
|
|
{
|
|
WORD i, size = 0;
|
|
|
|
if (!count) return 0;
|
|
for (i = FIRST_LDT_ENTRY_TO_ALLOC; i < LDT_SIZE; i++)
|
|
{
|
|
if (!IS_LDT_ENTRY_FREE(i)) size = 0;
|
|
else if (++size >= count) break;
|
|
}
|
|
if (i == LDT_SIZE) return 0;
|
|
/* Mark selector as allocated */
|
|
while (size--) ldt_flags_copy[i--] |= LDT_FLAGS_ALLOCATED;
|
|
return ENTRY_TO_SELECTOR( i + 1 );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* AllocSelector (KERNEL.175)
|
|
*/
|
|
WORD AllocSelector( WORD sel )
|
|
{
|
|
WORD newsel, count, i;
|
|
|
|
count = sel ? ((GET_SEL_LIMIT(sel) >> 16) + 1) : 1;
|
|
newsel = AllocSelectorArray( count );
|
|
dprintf_selector( stddeb, "AllocSelector(%04x): returning %04x\n",
|
|
sel, newsel );
|
|
if (!newsel) return 0;
|
|
if (!sel) return newsel; /* nothing to copy */
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
ldt_entry entry;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(sel) + i, &entry );
|
|
LDT_SetEntry( SELECTOR_TO_ENTRY(newsel) + i, &entry );
|
|
}
|
|
return newsel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* FreeSelector (KERNEL.176)
|
|
*/
|
|
WORD FreeSelector( WORD sel )
|
|
{
|
|
WORD i, count;
|
|
ldt_entry entry;
|
|
STACK16FRAME *frame;
|
|
|
|
dprintf_selector( stddeb, "FreeSelector(%04x)\n", sel );
|
|
if (IS_SELECTOR_FREE(sel)) return sel; /* error */
|
|
count = (GET_SEL_LIMIT(sel) >> 16) + 1;
|
|
memset( &entry, 0, sizeof(entry) ); /* clear the LDT entries */
|
|
/* FIXME: is it correct to free the whole array? */
|
|
for (i = SELECTOR_TO_ENTRY(sel); count; i++, count--)
|
|
{
|
|
LDT_SetEntry( i, &entry );
|
|
ldt_flags_copy[i] &= ~LDT_FLAGS_ALLOCATED;
|
|
}
|
|
|
|
/* Clear the saved 16-bit selector */
|
|
#ifndef WINELIB
|
|
frame = CURRENT_STACK16;
|
|
while (frame)
|
|
{
|
|
if (frame->ds == sel) frame->ds = 0;
|
|
if (frame->es == sel) frame->es = 0;
|
|
frame = PTR_SEG_OFF_TO_LIN(frame->saved_ss, frame->saved_sp);
|
|
}
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SELECTOR_SetEntries
|
|
*
|
|
* Set the LDT entries for an array of selectors.
|
|
*/
|
|
static void SELECTOR_SetEntries( WORD sel, const void *base, DWORD size,
|
|
enum seg_type type, BOOL is32bit,
|
|
BOOL readonly )
|
|
{
|
|
ldt_entry entry;
|
|
WORD i, count;
|
|
|
|
/* The limit for the first selector is the whole */
|
|
/* block. The next selectors get a 64k limit. */
|
|
entry.base = (unsigned long)base;
|
|
entry.type = type;
|
|
entry.seg_32bit = is32bit;
|
|
entry.read_only = readonly;
|
|
entry.limit_in_pages = (size > 0x100000);
|
|
if (entry.limit_in_pages) entry.limit = ((size + 0xfff) >> 12) - 1;
|
|
else entry.limit = size - 1;
|
|
count = (size + 0xffff) / 0x10000;
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
LDT_SetEntry( SELECTOR_TO_ENTRY(sel) + i, &entry );
|
|
entry.base += 0x10000;
|
|
size -= 0x10000;
|
|
entry.limit = (size > 0x10000) ? 0xffff : size-1;
|
|
entry.limit_in_pages = 0;
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SELECTOR_AllocBlock
|
|
*
|
|
* Allocate selectors for a block of linear memory.
|
|
*/
|
|
WORD SELECTOR_AllocBlock( const void *base, DWORD size, enum seg_type type,
|
|
BOOL is32bit, BOOL readonly )
|
|
{
|
|
WORD sel, count;
|
|
|
|
if (!size) return 0;
|
|
count = (size + 0xffff) / 0x10000;
|
|
sel = AllocSelectorArray( count );
|
|
if (sel) SELECTOR_SetEntries( sel, base, size, type, is32bit, readonly );
|
|
return sel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SELECTOR_ReallocBlock
|
|
*
|
|
* Change the size of a block of selectors.
|
|
*/
|
|
WORD SELECTOR_ReallocBlock( WORD sel, const void *base, DWORD size,
|
|
enum seg_type type, BOOL is32bit, BOOL readonly )
|
|
{
|
|
WORD i, oldcount, newcount;
|
|
ldt_entry entry;
|
|
|
|
if (!size) size = 1;
|
|
oldcount = (GET_SEL_LIMIT(sel) >> 16) + 1;
|
|
newcount = (size + 0xffff) >> 16;
|
|
|
|
if (oldcount < newcount) /* We need to add selectors */
|
|
{
|
|
/* Check if the next selectors are free */
|
|
if (SELECTOR_TO_ENTRY(sel) + newcount > LDT_SIZE) i = oldcount;
|
|
else
|
|
for (i = oldcount; i < newcount; i++)
|
|
if (!IS_LDT_ENTRY_FREE(SELECTOR_TO_ENTRY(sel)+i)) break;
|
|
|
|
if (i < newcount) /* they are not free */
|
|
{
|
|
FreeSelector( sel );
|
|
sel = AllocSelectorArray( newcount );
|
|
}
|
|
else /* mark the selectors as allocated */
|
|
{
|
|
for (i = oldcount; i < newcount; i++)
|
|
ldt_flags_copy[SELECTOR_TO_ENTRY(sel)+i] |=LDT_FLAGS_ALLOCATED;
|
|
}
|
|
}
|
|
else if (oldcount > newcount) /* We need to remove selectors */
|
|
{
|
|
memset( &entry, 0, sizeof(entry) ); /* clear the LDT entries */
|
|
for (i = oldcount; i < newcount; i++)
|
|
{
|
|
LDT_SetEntry( SELECTOR_TO_ENTRY(sel) + i, &entry );
|
|
ldt_flags_copy[SELECTOR_TO_ENTRY(sel) + i] &= ~LDT_FLAGS_ALLOCATED;
|
|
}
|
|
}
|
|
if (sel) SELECTOR_SetEntries( sel, base, size, type, is32bit, readonly );
|
|
return sel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* PrestoChangoSelector (KERNEL.177)
|
|
*/
|
|
WORD PrestoChangoSelector( WORD selSrc, WORD selDst )
|
|
{
|
|
ldt_entry entry;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY( selSrc ), &entry );
|
|
entry.type ^= SEGMENT_CODE; /* toggle the executable bit */
|
|
LDT_SetEntry( SELECTOR_TO_ENTRY( selDst ), &entry );
|
|
return selDst;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* AllocCStoDSAlias (KERNEL.170)
|
|
*/
|
|
WORD AllocCStoDSAlias( WORD sel )
|
|
{
|
|
WORD newsel;
|
|
ldt_entry entry;
|
|
|
|
newsel = AllocSelectorArray( 1 );
|
|
dprintf_selector( stddeb, "AllocCStoDSAlias(%04x): returning %04x\n",
|
|
sel, newsel );
|
|
if (!newsel) return 0;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
entry.type = SEGMENT_DATA;
|
|
LDT_SetEntry( SELECTOR_TO_ENTRY(newsel), &entry );
|
|
return newsel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* AllocDStoCSAlias (KERNEL.171)
|
|
*/
|
|
WORD AllocDStoCSAlias( WORD sel )
|
|
{
|
|
WORD newsel;
|
|
ldt_entry entry;
|
|
|
|
newsel = AllocSelectorArray( 1 );
|
|
dprintf_selector( stddeb, "AllocDStoCSAlias(%04x): returning %04x\n",
|
|
sel, newsel );
|
|
if (!newsel) return 0;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
entry.type = SEGMENT_CODE;
|
|
LDT_SetEntry( SELECTOR_TO_ENTRY(newsel), &entry );
|
|
return newsel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* LongPtrAdd (KERNEL.180)
|
|
*/
|
|
void LongPtrAdd( DWORD ptr, DWORD add )
|
|
{
|
|
ldt_entry entry;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(SELECTOROF(ptr)), &entry );
|
|
entry.base += add;
|
|
LDT_SetEntry( SELECTOR_TO_ENTRY(SELECTOROF(ptr)), &entry );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* GetSelectorBase (KERNEL.186)
|
|
*/
|
|
DWORD GetSelectorBase( WORD sel )
|
|
{
|
|
return GET_SEL_BASE(sel);
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SetSelectorBase (KERNEL.187)
|
|
*/
|
|
WORD SetSelectorBase( WORD sel, DWORD base )
|
|
{
|
|
ldt_entry entry;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
entry.base = base;
|
|
LDT_SetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
return sel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* GetSelectorLimit (KERNEL.188)
|
|
*/
|
|
DWORD GetSelectorLimit( WORD sel )
|
|
{
|
|
return GET_SEL_LIMIT(sel);
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SetSelectorLimit (KERNEL.189)
|
|
*/
|
|
WORD SetSelectorLimit( WORD sel, DWORD limit )
|
|
{
|
|
ldt_entry entry;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
entry.limit = limit;
|
|
LDT_SetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
return sel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SelectorAccessRights (KERNEL.196)
|
|
*/
|
|
WORD SelectorAccessRights( WORD sel, WORD op, WORD val )
|
|
{
|
|
ldt_entry entry;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
if (op == 0) /* get */
|
|
{
|
|
return 1 /* accessed */ |
|
|
((entry.read_only == 0) << 1) |
|
|
(entry.type << 2) |
|
|
(entry.seg_32bit << 14) |
|
|
(entry.limit_in_pages << 15);
|
|
}
|
|
else /* set */
|
|
{
|
|
entry.read_only = ((val & 2) == 0);
|
|
entry.type = (val >> 2) & 3;
|
|
entry.seg_32bit = val & 0x4000;
|
|
entry.limit_in_pages = val & 0x8000;
|
|
LDT_SetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* IsBadCodePtr (KERNEL.336)
|
|
*/
|
|
BOOL IsBadCodePtr( SEGPTR lpfn )
|
|
{
|
|
WORD sel;
|
|
ldt_entry entry;
|
|
|
|
sel = SELECTOROF(lpfn);
|
|
if (!sel) return TRUE;
|
|
if (IS_SELECTOR_FREE(sel)) return TRUE;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
if (entry.type != SEGMENT_CODE) return TRUE;
|
|
if (OFFSETOF(lpfn) > entry.limit) return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* IsBadStringPtr (KERNEL.337)
|
|
*/
|
|
BOOL IsBadStringPtr( SEGPTR ptr, WORD size )
|
|
{
|
|
WORD sel;
|
|
ldt_entry entry;
|
|
|
|
sel = SELECTOROF(ptr);
|
|
if (!sel) return TRUE;
|
|
if (IS_SELECTOR_FREE(sel)) return TRUE;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
if ((entry.type == SEGMENT_CODE) && entry.read_only) return TRUE;
|
|
if (strlen(PTR_SEG_TO_LIN(ptr)) < size) size = strlen(PTR_SEG_TO_LIN(ptr));
|
|
if (OFFSETOF(ptr) + size - 1 > entry.limit) return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* IsBadHugeReadPtr (KERNEL.346)
|
|
*/
|
|
BOOL IsBadHugeReadPtr( SEGPTR ptr, DWORD size )
|
|
{
|
|
WORD sel;
|
|
ldt_entry entry;
|
|
|
|
sel = SELECTOROF(ptr);
|
|
if (!sel) return TRUE;
|
|
if (IS_SELECTOR_FREE(sel)) return TRUE;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
if ((entry.type == SEGMENT_CODE) && entry.read_only) return TRUE;
|
|
if (OFFSETOF(ptr) + size - 1 > entry.limit) return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* IsBadHugeWritePtr (KERNEL.347)
|
|
*/
|
|
BOOL IsBadHugeWritePtr( SEGPTR ptr, DWORD size )
|
|
{
|
|
WORD sel;
|
|
ldt_entry entry;
|
|
|
|
sel = SELECTOROF(ptr);
|
|
if (!sel) return TRUE;
|
|
if (IS_SELECTOR_FREE(sel)) return TRUE;
|
|
LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
|
|
if ((entry.type == SEGMENT_CODE) || entry.read_only) return TRUE;
|
|
if (OFFSETOF(ptr) + size - 1 > entry.limit) return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* IsBadReadPtr (KERNEL.334)
|
|
*/
|
|
BOOL IsBadReadPtr( SEGPTR ptr, WORD size )
|
|
{
|
|
return IsBadHugeReadPtr( ptr, size );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* IsBadWritePtr (KERNEL.335)
|
|
*/
|
|
BOOL IsBadWritePtr( SEGPTR ptr, WORD size )
|
|
{
|
|
return IsBadHugeWritePtr( ptr, size );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* MemoryRead (TOOLHELP.78)
|
|
*/
|
|
DWORD MemoryRead( WORD sel, DWORD offset, void *buffer, DWORD count )
|
|
{
|
|
if (IS_SELECTOR_FREE(sel)) return 0;
|
|
if (offset > GET_SEL_LIMIT(sel)) return 0;
|
|
if (offset + count > GET_SEL_LIMIT(sel) + 1)
|
|
count = GET_SEL_LIMIT(sel) + 1 - offset;
|
|
memcpy( buffer, ((char *)GET_SEL_BASE(sel)) + offset, count );
|
|
return count;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* MemoryWrite (TOOLHELP.79)
|
|
*/
|
|
DWORD MemoryWrite( WORD sel, DWORD offset, void *buffer, DWORD count )
|
|
{
|
|
if (IS_SELECTOR_FREE(sel)) return 0;
|
|
if (offset > GET_SEL_LIMIT(sel)) return 0;
|
|
if (offset + count > GET_SEL_LIMIT(sel) + 1)
|
|
count = GET_SEL_LIMIT(sel) + 1 - offset;
|
|
memcpy( ((char *)GET_SEL_BASE(sel)) + offset, buffer, count );
|
|
return count;
|
|
}
|
|
|
|
#ifndef WINELIB
|
|
SEGPTR MAKE_SEGPTR(void * ptr)
|
|
|
|
{
|
|
SEGPTR result;
|
|
int entry;
|
|
|
|
if (!ptr)
|
|
return ptr;
|
|
if (!((unsigned)ptr & 0xffff0000)) {
|
|
fprintf(stderr, "Invalid pointer %08x has been passed to MAKE_SEGPTR. This was\n", ptr);
|
|
fprintf(stderr, "probably caused by an unnecessary call to PTR_SEG_TO_LIN.\n");
|
|
fprintf(stderr, "Forcing call to debugger\n");
|
|
ptr = *(void **)0;
|
|
}
|
|
result = (SEGPTR) (IF1632_Stack32_base) +
|
|
((DWORD)(ptr) - (DWORD) PTR_SEG_TO_LIN(IF1632_Stack32_base));
|
|
if (PTR_SEG_TO_LIN(result) == ptr)
|
|
return result;
|
|
|
|
for (entry = 0; entry < LDT_SIZE; entry++) {
|
|
if (ldt_copy[entry].base &&
|
|
(ldt_copy[entry].limit < 0x10000) &&
|
|
((unsigned) ptr >= ldt_copy[entry].base) &&
|
|
((unsigned) ptr < (ldt_copy[entry].base + ldt_copy[entry].limit))) {
|
|
return ((ENTRY_TO_SELECTOR(entry) << 16) |
|
|
((unsigned) ptr - ldt_copy[entry].base));
|
|
}
|
|
}
|
|
entry = SELECTOR_AllocBlock((void *)((unsigned)ptr & 0xffff0000), 0x10000, SEGMENT_DATA, 0, 0);
|
|
return ((entry << 16) | ((unsigned) ptr & 0xffff));
|
|
}
|
|
#endif
|