ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Make LOCAL_*() just wrappers around Local*16() functions.

This commit is contained in:
Dimi Paun 2005-05-14 12:18:15 +00:00 committed by Alexandre Julliard
parent d876893fc1
commit e510a29159
5 changed files with 173 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
dlls/gdi/gdiobj.c
View File

@ -1459,7 +1459,7 @@ DWORD WINAPI GdiSeeGdiDo16( WORD wReqType, WORD wParam1, WORD wParam2,
case 0x0002: /* LocalFree */
return LOCAL_Free( GDI_HeapSel, wParam1 );
case 0x0003: /* LocalCompact */
return LOCAL_Compact( GDI_HeapSel, wParam3, 0 );
return LOCAL_Compact( GDI_HeapSel, wParam3 );
case 0x0103: /* LocalHeap */
return GDI_HeapSel;
default:

17
dlls/kernel/kernel32.spec
View File

@ -1138,6 +1138,14 @@
@ stdcall LocalInit16(long long long)
@ stdcall LocalLock16(long)
@ stdcall LocalUnlock16(long)
@ stdcall LocalReAlloc16(long long long)
@ stdcall LocalFree16(long)
@ stdcall LocalSize16(long)
@ stdcall LocalHandle16(long)
@ stdcall LocalFlags16(long)
@ stdcall LocalCompact16(long)
@ stdcall LocalCountFree16()
@ stdcall LocalHeapSize16()
@ stdcall LockResource16(long)
@ stdcall SelectorAccessRights16(long long long)
@ stdcall SetSelectorBase(long long)
@ -1169,13 +1177,4 @@
# Wine dll separation hacks, these will go away, don't use them
#
@ cdecl DOSMEM_AllocSelector(long)
@ cdecl LOCAL_Alloc(long long long)
@ cdecl LOCAL_Compact(long long long)
@ cdecl LOCAL_CountFree(long)
@ cdecl LOCAL_Free(long long)
@ cdecl LOCAL_HeapSize(long)
@ cdecl LOCAL_Lock(long long)
@ cdecl LOCAL_ReAlloc(long long long long)
@ cdecl LOCAL_Size(long long)
@ cdecl LOCAL_Unlock(long long)
@ stdcall NE_DefResourceHandler(long long long)

180
dlls/kernel/local16.c
View File

@ -726,9 +726,9 @@ static WORD LOCAL_GetFreeSpace(WORD ds, WORD countdiscard)
/***********************************************************************
* LOCAL_Compact
* local_compact
*/
WORD LOCAL_Compact( HANDLE16 ds, UINT16 minfree, UINT16 flags )
static UINT16 local_compact( HANDLE16 ds, UINT16 minfree, UINT16 flags )
{
char *ptr = MapSL( MAKESEGPTR( ds, 0 ) );
LOCALHEAPINFO *pInfo;
@ -845,7 +845,7 @@ WORD LOCAL_Compact( HANDLE16 ds, UINT16 minfree, UINT16 flags )
}
table = *(WORD *)pEntry;
}
return LOCAL_Compact(ds, 0xffff, LMEM_NODISCARD);
return local_compact(ds, 0xffff, LMEM_NODISCARD);
}
@ -931,7 +931,7 @@ notify_done:
arena = LOCAL_FindFreeBlock( ds, size );
if (arena == 0) {
/* no space: try to make some */
LOCAL_Compact( ds, size, flags );
local_compact( ds, size, flags );
arena = LOCAL_FindFreeBlock( ds, size );
}
if (arena == 0) {
@ -1117,12 +1117,11 @@ static void LOCAL_FreeHandleEntry( HANDLE16 ds, HLOCAL16 handle )
/***********************************************************************
* LOCAL_Free
*
* Implementation of LocalFree().
* LocalFree (KERNEL.7)
*/
HLOCAL16 LOCAL_Free( HANDLE16 ds, HLOCAL16 handle )
HLOCAL16 WINAPI LocalFree16( HLOCAL16 handle )
{
HANDLE16 ds = CURRENT_DS;
char *ptr = MapSL( MAKESEGPTR( ds, 0 ) );
TRACE("%04x ds=%04x\n", handle, ds );
@ -1150,15 +1149,13 @@ HLOCAL16 LOCAL_Free( HANDLE16 ds, HLOCAL16 handle )
/***********************************************************************
* LOCAL_Alloc
*
* Implementation of LocalAlloc().
*
* LocalAlloc (KERNEL.5)
*/
HLOCAL16 LOCAL_Alloc( HANDLE16 ds, WORD flags, WORD size )
HLOCAL16 WINAPI LocalAlloc16( UINT16 flags, WORD size )
{
HANDLE16 ds = CURRENT_DS;
HLOCAL16 handle = 0;
char *ptr;
HLOCAL16 handle;
TRACE("%04x %d ds=%04x\n", flags, size, ds );
@ -1171,7 +1168,7 @@ HLOCAL16 LOCAL_Alloc( HANDLE16 ds, WORD flags, WORD size )
if(size)
{
if (!(hmem = LOCAL_GetBlock( ds, size + MOVEABLE_PREFIX, flags )))
return 0;
goto exit;
}
else /* We just need to allocate a discarded handle */
hmem = 0;
@ -1180,7 +1177,7 @@ HLOCAL16 LOCAL_Alloc( HANDLE16 ds, WORD flags, WORD size )
WARN("Couldn't get handle.\n");
if(hmem)
LOCAL_FreeArena( ds, ARENA_HEADER(hmem) );
return 0;
goto exit;
}
ptr = MapSL( MAKESEGPTR( ds, 0 ) );
plhe = (LOCALHANDLEENTRY *)(ptr + handle);
@ -1199,21 +1196,21 @@ HLOCAL16 LOCAL_Alloc( HANDLE16 ds, WORD flags, WORD size )
}
else /* FIXED */
{
if(!size)
return 0;
handle = LOCAL_GetBlock( ds, size, flags );
if(size) handle = LOCAL_GetBlock( ds, size, flags );
}
exit:
CURRENT_STACK16->ecx = handle; /* must be returned in cx too */
return handle;
}
/***********************************************************************
* LOCAL_ReAlloc
*
* Implementation of LocalReAlloc().
* LocalReAlloc (KERNEL.6)
*/
HLOCAL16 LOCAL_ReAlloc( HANDLE16 ds, HLOCAL16 handle, WORD size, WORD flags )
HLOCAL16 WINAPI LocalReAlloc16( HLOCAL16 handle, WORD size, UINT16 flags )
{
HANDLE16 ds = CURRENT_DS;
char *ptr = MapSL( MAKESEGPTR( ds, 0 ) );
LOCALHEAPINFO *pInfo;
LOCALARENA *pArena, *pNext;
@ -1433,20 +1430,11 @@ static HLOCAL16 LOCAL_InternalLock( LPSTR heap, HLOCAL16 handle )
/***********************************************************************
* LOCAL_Lock
* LocalUnlock (KERNEL.9)
*/
void *LOCAL_Lock( HANDLE16 ds, HLOCAL16 handle )
{
char *ptr = MapSL( MAKESEGPTR( ds, 0 ) );
return handle ? ptr + LOCAL_InternalLock( ptr, handle ) : NULL;
}
/***********************************************************************
* LOCAL_Unlock
*/
BOOL16 LOCAL_Unlock( HANDLE16 ds, HLOCAL16 handle )
BOOL16 WINAPI LocalUnlock16( HLOCAL16 handle )
{
HANDLE16 ds = CURRENT_DS;
char *ptr = MapSL( MAKESEGPTR( ds, 0 ) );
TRACE("%04x\n", handle );
@ -1463,12 +1451,11 @@ BOOL16 LOCAL_Unlock( HANDLE16 ds, HLOCAL16 handle )
/***********************************************************************
* LOCAL_Size
*
* Implementation of LocalSize().
* LocalSize (KERNEL.10)
*/
WORD LOCAL_Size( HANDLE16 ds, HLOCAL16 handle )
UINT16 WINAPI LocalSize16( HLOCAL16 handle )
{
HANDLE16 ds = CURRENT_DS;
char *ptr = MapSL( MAKESEGPTR( ds, 0 ) );
LOCALARENA *pArena;
@ -1489,12 +1476,11 @@ WORD LOCAL_Size( HANDLE16 ds, HLOCAL16 handle )
/***********************************************************************
* LOCAL_Flags
*
* Implementation of LocalFlags().
* LocalFlags (KERNEL.12)
*/
WORD LOCAL_Flags( HANDLE16 ds, HLOCAL16 handle )
UINT16 WINAPI LocalFlags16( HLOCAL16 handle )
{
HANDLE16 ds = CURRENT_DS;
char *ptr = MapSL( MAKESEGPTR( ds, 0 ) );
if (HANDLE_MOVEABLE(handle))
@ -1514,25 +1500,22 @@ WORD LOCAL_Flags( HANDLE16 ds, HLOCAL16 handle )
/***********************************************************************
* LOCAL_HeapSize
*
* Implementation of LocalHeapSize().
* LocalHeapSize (KERNEL.162)
*/
WORD LOCAL_HeapSize( HANDLE16 ds )
WORD WINAPI LocalHeapSize16(void)
{
HANDLE16 ds = CURRENT_DS;
LOCALHEAPINFO *pInfo = LOCAL_GetHeap( ds );
if (!pInfo) return 0;
return pInfo->last - pInfo->first;
return pInfo ? pInfo->last - pInfo->first : 0;
}
/***********************************************************************
* LOCAL_CountFree
*
* Implementation of LocalCountFree().
* LocalCountFree (KERNEL.161)
*/
WORD LOCAL_CountFree( HANDLE16 ds )
WORD WINAPI LocalCountFree16(void)
{
HANDLE16 ds = CURRENT_DS;
WORD arena, total;
LOCALARENA *pArena;
LOCALHEAPINFO *pInfo;
@ -1561,12 +1544,11 @@ WORD LOCAL_CountFree( HANDLE16 ds )
/***********************************************************************
* LOCAL_Handle
*
* Implementation of LocalHandle().
* LocalHandle (KERNEL.11)
*/
HLOCAL16 LOCAL_Handle( HANDLE16 ds, WORD addr )
HLOCAL16 WINAPI LocalHandle16( WORD addr )
{
HANDLE16 ds = CURRENT_DS;
char *ptr = MapSL( MAKESEGPTR( ds, 0 ) );
LOCALHEAPINFO *pInfo;
WORD table;
@ -1594,33 +1576,6 @@ HLOCAL16 LOCAL_Handle( HANDLE16 ds, WORD addr )
}
/***********************************************************************
* LocalAlloc (KERNEL.5)
*/
HLOCAL16 WINAPI LocalAlloc16( UINT16 flags, WORD size )
{
HLOCAL16 ret = LOCAL_Alloc( CURRENT_DS, flags, size );
CURRENT_STACK16->ecx = ret; /* must be returned in cx too */
return ret;
}
/***********************************************************************
* LocalReAlloc (KERNEL.6)
*/
HLOCAL16 WINAPI LocalReAlloc16( HLOCAL16 handle, WORD size, UINT16 flags )
{
return LOCAL_ReAlloc( CURRENT_DS, handle, size, flags );
}
/***********************************************************************
* LocalFree (KERNEL.7)
*/
HLOCAL16 WINAPI LocalFree16( HLOCAL16 handle )
{
return LOCAL_Free( CURRENT_DS, handle );
}
/***********************************************************************
@ -1636,49 +1591,13 @@ SEGPTR WINAPI LocalLock16( HLOCAL16 handle )
}
/***********************************************************************
* LocalUnlock (KERNEL.9)
*/
BOOL16 WINAPI LocalUnlock16( HLOCAL16 handle )
{
return LOCAL_Unlock( CURRENT_DS, handle );
}
/***********************************************************************
* LocalSize (KERNEL.10)
*/
UINT16 WINAPI LocalSize16( HLOCAL16 handle )
{
return LOCAL_Size( CURRENT_DS, handle );
}
/***********************************************************************
* LocalHandle (KERNEL.11)
*/
HLOCAL16 WINAPI LocalHandle16( WORD addr )
{
return LOCAL_Handle( CURRENT_DS, addr );
}
/***********************************************************************
* LocalFlags (KERNEL.12)
*/
UINT16 WINAPI LocalFlags16( HLOCAL16 handle )
{
return LOCAL_Flags( CURRENT_DS, handle );
}
/***********************************************************************
* LocalCompact (KERNEL.13)
*/
UINT16 WINAPI LocalCompact16( UINT16 minfree )
{
TRACE("%04x\n", minfree );
return LOCAL_Compact( CURRENT_DS, minfree, 0 );
return local_compact( CURRENT_DS, minfree, 0 );
}
@ -1745,25 +1664,6 @@ DWORD WINAPI GetHeapSpaces16( HMODULE16 module )
}
/***********************************************************************
* LocalCountFree (KERNEL.161)
*/
WORD WINAPI LocalCountFree16(void)
{
return LOCAL_CountFree( CURRENT_DS );
}
/***********************************************************************
* LocalHeapSize (KERNEL.162)
*/
WORD WINAPI LocalHeapSize16(void)
{
TRACE("(void)\n" );
return LOCAL_HeapSize( CURRENT_DS );
}
/***********************************************************************
* LocalHandleDelta (KERNEL.310)
*/

135
include/local.h
View File

@ -23,22 +23,133 @@
#include <windef.h>
#include <wine/windef16.h>
#include <wine/winbase16.h>
#include <stackframe.h>
/* These function are equivalent to the Local* API functions, */
/* excepted that they need DS as the first parameter. This */
/* allows managing several heaps from the emulation library. */
static inline HLOCAL16 LOCAL_Alloc( HANDLE16 ds, UINT16 flags, WORD size )
{
HANDLE16 oldDS = CURRENT_DS;
HLOCAL16 ret;
CURRENT_DS = ds;
ret = LocalAlloc16 (flags, size);
CURRENT_DS = oldDS;
return ret;
}
static inline HLOCAL16 LOCAL_ReAlloc( HANDLE16 ds, HLOCAL16 handle, WORD size, UINT16 flags )
{
HANDLE16 oldDS = CURRENT_DS;
HLOCAL16 ret;
CURRENT_DS = ds;
ret = LocalReAlloc16 (handle, size, flags);
CURRENT_DS = oldDS;
return ret;
}
static inline HLOCAL16 LOCAL_Free( HANDLE16 ds, HLOCAL16 handle )
{
HANDLE16 oldDS = CURRENT_DS;
HLOCAL16 ret;
CURRENT_DS = ds;
ret = LocalFree16 (handle);
CURRENT_DS = oldDS;
return ret;
}
static inline HLOCAL16 LOCAL_Handle( HANDLE16 ds, WORD addr )
{
HANDLE16 oldDS = CURRENT_DS;
HLOCAL16 ret;
CURRENT_DS = ds;
ret = LocalHandle16 (addr);
CURRENT_DS = oldDS;
return ret;
}
static inline UINT16 LOCAL_Size( HANDLE16 ds, HLOCAL16 handle )
{
HANDLE16 oldDS = CURRENT_DS;
UINT16 ret;
CURRENT_DS = ds;
ret = LocalSize16 (handle);
CURRENT_DS = oldDS;
return ret;
}
static inline UINT16 LOCAL_Flags( HANDLE16 ds, HLOCAL16 handle )
{
HANDLE16 oldDS = CURRENT_DS;
UINT16 ret;
CURRENT_DS = ds;
ret = LocalFlags16 (handle);
CURRENT_DS = oldDS;
return ret;
}
static inline UINT16 LOCAL_HeapSize( HANDLE16 ds )
{
HANDLE16 oldDS = CURRENT_DS;
UINT16 ret;
CURRENT_DS = ds;
ret = LocalHeapSize16 ();
CURRENT_DS = oldDS;
return ret;
}
static inline UINT16 LOCAL_CountFree( HANDLE16 ds )
{
HANDLE16 oldDS = CURRENT_DS;
UINT16 ret;
CURRENT_DS = ds;
ret = LocalCountFree16 ();
CURRENT_DS = oldDS;
return ret;
}
static inline void *LOCAL_Lock( HANDLE16 ds, HLOCAL16 handle )
{
HANDLE16 oldDS = CURRENT_DS;
SEGPTR ret;
CURRENT_DS = ds;
ret = LocalLock16 (handle);
CURRENT_DS = oldDS;
return MapSL(ret);
}
static inline BOOL16 LOCAL_Unlock( HANDLE16 ds, HLOCAL16 handle )
{
HANDLE16 oldDS = CURRENT_DS;
BOOL16 ret;
CURRENT_DS = ds;
ret = LocalUnlock16 (handle);
CURRENT_DS = oldDS;
return ret;
}
static inline WORD LOCAL_Compact( HANDLE16 ds, UINT16 minfree )
{
HANDLE16 oldDS = CURRENT_DS;
WORD ret;
CURRENT_DS = ds;
ret = LocalCompact16 (minfree);
CURRENT_DS = oldDS;
return ret;
}
extern HLOCAL16 LOCAL_Alloc( HANDLE16 ds, UINT16 flags, WORD size );
extern HLOCAL16 LOCAL_ReAlloc( HANDLE16 ds, HLOCAL16 handle,
WORD size, UINT16 flags );
extern HLOCAL16 LOCAL_Free( HANDLE16 ds, HLOCAL16 handle );
extern HLOCAL16 LOCAL_Handle( HANDLE16 ds, WORD addr );
extern UINT16 LOCAL_Size( HANDLE16 ds, HLOCAL16 handle );
extern UINT16 LOCAL_Flags( HANDLE16 ds, HLOCAL16 handle );
extern UINT16 LOCAL_HeapSize( HANDLE16 ds );
extern UINT16 LOCAL_CountFree( HANDLE16 ds );
extern void *LOCAL_Lock( HANDLE16 ds, HLOCAL16 handle );
extern BOOL16 LOCAL_Unlock( HANDLE16 ds, HLOCAL16 handle );
extern WORD LOCAL_Compact( HANDLE16 ds, UINT16 minfree, UINT16 flags );
#endif /* __WINE_LOCAL_H */

2
windows/user.c
View File

@ -553,7 +553,7 @@ DWORD WINAPI UserSeeUserDo16(WORD wReqType, WORD wParam1, WORD wParam2, WORD wPa
case USUD_LOCALFREE:
return LOCAL_Free(USER_HeapSel, wParam1);
case USUD_LOCALCOMPACT:
return LOCAL_Compact(USER_HeapSel, wParam3, 0);
return LOCAL_Compact(USER_HeapSel, wParam3);
case USUD_LOCALHEAP:
return USER_HeapSel;
case USUD_FIRSTCLASS: