include: rename LIST_ENTRY to WINE_LIST_ENTRY to prevent a conflict on *BSD/OS X
Austin English
austinenglish at gmail.com
Fri Jan 15 17:12:22 CST 2010
See bug 21320.
dlls/crypt32/collectionstore.c | 8 ++--
dlls/crypt32/proplist.c | 4 +-
dlls/ddraw/ddraw.c | 4 +-
dlls/ddraw/main.c | 2 +-
dlls/dinput/effect_linuxinput.c | 2 +-
dlls/dmime/graph.c | 4 +-
dlls/dmime/segment.c | 10 +++---
dlls/dmime/tempotrack.c | 2 +-
dlls/dmloader/container.c | 8 ++--
dlls/dmloader/loader.c | 20 +++++-----
dlls/dmstyle/commandtrack.c | 2 +-
dlls/dmusic/collection.c | 6 ++--
dlls/fusion/asmenum.c | 6 ++--
dlls/fusion/tests/asmenum.c | 4 +-
dlls/gdi32/freetype.c | 70 ++++++++++++++++++------------------
dlls/inetcomm/mimeole.c | 12 +++---
dlls/kernel32/resource.c | 4 +-
dlls/mapi32/prop.c | 8 ++--
dlls/msctf/compartmentmgr.c | 12 +++---
dlls/msctf/context.c | 12 +++---
dlls/msctf/inputprocessor.c | 4 +-
dlls/msctf/threadmgr.c | 42 +++++++++++-----------
dlls/mshtml/dispex.c | 2 +-
dlls/mshtml/htmlwindow.c | 2 +-
dlls/mshtml/script.c | 2 +-
dlls/mshtml/task.c | 8 ++--
dlls/msi/action.c | 8 ++--
dlls/msi/custom.c | 2 +-
dlls/msi/database.c | 8 ++--
dlls/msi/dialog.c | 2 +-
dlls/msi/events.c | 4 +-
dlls/msi/format.c | 6 ++--
dlls/msi/helpers.c | 30 ++++++++--------
dlls/msi/join.c | 2 +-
dlls/msi/source.c | 2 +-
dlls/msi/table.c | 4 +-
dlls/msxml3/dispex.c | 2 +-
dlls/ntdll/directory.c | 4 +-
dlls/ntdll/exception.c | 4 +-
dlls/ntdll/heap.c | 20 +++++-----
dlls/ntdll/threadpool.c | 8 ++--
dlls/ntdll/virtual.c | 14 ++++----
dlls/ole32/compobj.c | 12 +++---
dlls/ole32/marshal.c | 14 ++++----
dlls/ole32/moniker.c | 4 +-
dlls/ole32/ole2.c | 2 +-
dlls/ole32/storage32.c | 4 +-
dlls/ole32/stubmanager.c | 10 +++---
dlls/pdh/pdh_main.c | 6 ++--
dlls/quartz/memallocator.c | 6 ++--
dlls/urlmon/urlmon_main.c | 2 +-
dlls/user.exe16/user.c | 2 +-
dlls/user32/class.c | 2 +-
dlls/windowscodecs/info.c | 2 +-
dlls/wined3d/arb_program_shader.c | 24 ++++++------
dlls/wined3d/baseshader.c | 2 +-
dlls/wined3d/context.c | 2 +-
dlls/wined3d/device.c | 16 ++++----
dlls/wined3d/glsl_shader.c | 4 +-
dlls/wined3d/resource.c | 4 +-
dlls/wined3d/stateblock.c | 8 ++--
dlls/wineps.drv/ppd.c | 2 +-
dlls/winex11.drv/dib.c | 2 +-
dlls/winhttp/cookie.c | 10 +++---
dlls/winhttp/session.c | 2 +-
dlls/wininet/cookie.c | 10 +++---
dlls/wininet/http.c | 2 +-
dlls/wininet/urlcache.c | 2 +-
dlls/winmm/time.c | 2 +-
dlls/winspool.drv/info.c | 4 +-
include/wine/list.h | 23 ++++++------
libs/wine/mmap.c | 16 ++++----
programs/winecfg/winecfg.c | 8 ++--
server/async.c | 6 ++--
server/change.c | 4 +-
server/class.c | 4 +-
server/completion.c | 2 +-
server/debugger.c | 4 +-
server/device.c | 4 +-
server/fd.c | 27 +++++++-------
server/hook.c | 2 +-
server/mailslot.c | 2 +-
server/mutex.c | 2 +-
server/object.c | 8 ++--
server/process.c | 16 ++++----
server/process.h | 2 +-
server/queue.c | 38 ++++++++++----------
server/registry.c | 4 +-
server/thread.c | 6 ++--
server/token.c | 4 +-
server/window.c | 14 ++++----
tools/widl/parser.y | 6 ++--
tools/widl/typegen.c | 10 +++---
tools/widl/typetree.c | 2 +-
tools/widl/typetree.h | 4 +-
95 files changed, 379 insertions(+), 381 deletions(-)
--
-Austin
-------------- next part --------------
diff --git a/dlls/crypt32/collectionstore.c b/dlls/crypt32/collectionstore.c
index 35941dd..86bf312 100644
--- a/dlls/crypt32/collectionstore.c
+++ b/dlls/crypt32/collectionstore.c
@@ -167,7 +167,7 @@ static void *CRYPT_CollectionAdvanceEnum(PWINE_COLLECTIONSTORE store,
*/
size_t offset = (LPBYTE)contextFuncs - (LPBYTE)storeEntry->store;
PWINE_STORE_LIST_ENTRY storeNextEntry =
- LIST_ENTRY(storeNext, WINE_STORE_LIST_ENTRY, entry);
+ WINE_LIST_ENTRY(storeNext, WINE_STORE_LIST_ENTRY, entry);
PCONTEXT_FUNCS storeNextContexts =
(PCONTEXT_FUNCS)((LPBYTE)storeNextEntry->store + offset);
@@ -231,7 +231,7 @@ static void *CRYPT_CollectionEnumCert(PWINECRYPT_CERTSTORE store, void *pPrev)
{
if (!list_empty(&cs->stores))
{
- PWINE_STORE_LIST_ENTRY storeEntry = LIST_ENTRY(cs->stores.next,
+ PWINE_STORE_LIST_ENTRY storeEntry = WINE_LIST_ENTRY(cs->stores.next,
WINE_STORE_LIST_ENTRY, entry);
ret = CRYPT_CollectionAdvanceEnum(cs, storeEntry,
@@ -317,7 +317,7 @@ static void *CRYPT_CollectionEnumCRL(PWINECRYPT_CERTSTORE store, void *pPrev)
{
if (!list_empty(&cs->stores))
{
- PWINE_STORE_LIST_ENTRY storeEntry = LIST_ENTRY(cs->stores.next,
+ PWINE_STORE_LIST_ENTRY storeEntry = WINE_LIST_ENTRY(cs->stores.next,
WINE_STORE_LIST_ENTRY, entry);
ret = CRYPT_CollectionAdvanceEnum(cs, storeEntry,
@@ -402,7 +402,7 @@ static void *CRYPT_CollectionEnumCTL(PWINECRYPT_CERTSTORE store, void *pPrev)
{
if (!list_empty(&cs->stores))
{
- PWINE_STORE_LIST_ENTRY storeEntry = LIST_ENTRY(cs->stores.next,
+ PWINE_STORE_LIST_ENTRY storeEntry = WINE_LIST_ENTRY(cs->stores.next,
WINE_STORE_LIST_ENTRY, entry);
ret = CRYPT_CollectionAdvanceEnum(cs, storeEntry,
diff --git a/dlls/crypt32/proplist.c b/dlls/crypt32/proplist.c
index 31cd53b..a6ca1ad 100644
--- a/dlls/crypt32/proplist.c
+++ b/dlls/crypt32/proplist.c
@@ -185,7 +185,7 @@ DWORD ContextPropertyList_EnumPropIDs(PCONTEXT_PROPERTY_LIST list, DWORD id)
if (cursor)
{
if (cursor->entry.next != &list->properties)
- ret = LIST_ENTRY(cursor->entry.next, CONTEXT_PROPERTY,
+ ret = WINE_LIST_ENTRY(cursor->entry.next, CONTEXT_PROPERTY,
entry)->propID;
else
ret = 0;
@@ -194,7 +194,7 @@ DWORD ContextPropertyList_EnumPropIDs(PCONTEXT_PROPERTY_LIST list, DWORD id)
ret = 0;
}
else if (!list_empty(&list->properties))
- ret = LIST_ENTRY(list->properties.next, CONTEXT_PROPERTY,
+ ret = WINE_LIST_ENTRY(list->properties.next, CONTEXT_PROPERTY,
entry)->propID;
else
ret = 0;
diff --git a/dlls/ddraw/ddraw.c b/dlls/ddraw/ddraw.c
index 527f448..5573154 100644
--- a/dlls/ddraw/ddraw.c
+++ b/dlls/ddraw/ddraw.c
@@ -2489,7 +2489,7 @@ IDirectDrawImpl_CreateSurface(IDirectDraw7 *iface,
/* Search for the primary to use as render target */
LIST_FOR_EACH(entry, &This->surface_list)
{
- surface = LIST_ENTRY(entry, IDirectDrawSurfaceImpl, surface_list_entry);
+ surface = WINE_LIST_ENTRY(entry, IDirectDrawSurfaceImpl, surface_list_entry);
if((surface->surface_desc.ddsCaps.dwCaps & (DDSCAPS_PRIMARYSURFACE | DDSCAPS_FRONTBUFFER)) ==
(DDSCAPS_PRIMARYSURFACE | DDSCAPS_FRONTBUFFER))
{
@@ -2751,7 +2751,7 @@ IDirectDrawImpl_EnumSurfaces(IDirectDraw7 *iface,
/* Use the _SAFE enumeration, the app may destroy enumerated surfaces */
LIST_FOR_EACH_SAFE(entry, entry2, &This->surface_list)
{
- surf = LIST_ENTRY(entry, IDirectDrawSurfaceImpl, surface_list_entry);
+ surf = WINE_LIST_ENTRY(entry, IDirectDrawSurfaceImpl, surface_list_entry);
if (all || (nomatch != IDirectDrawImpl_DDSD_Match(DDSD, &surf->surface_desc)))
{
desc = surf->surface_desc;
diff --git a/dlls/ddraw/main.c b/dlls/ddraw/main.c
index ed4e7cd..b539c53 100644
--- a/dlls/ddraw/main.c
+++ b/dlls/ddraw/main.c
@@ -907,7 +907,7 @@ DllMain(HINSTANCE hInstDLL,
HRESULT hr;
DDSURFACEDESC2 desc;
int i;
- IDirectDrawImpl *ddraw = LIST_ENTRY(entry, IDirectDrawImpl, ddraw_list_entry);
+ IDirectDrawImpl *ddraw = WINE_LIST_ENTRY(entry, IDirectDrawImpl, ddraw_list_entry);
WARN("DDraw %p has a refcount of %d\n", ddraw, ddraw->ref7 + ddraw->ref4 + ddraw->ref3 + ddraw->ref2 + ddraw->ref1);
diff --git a/dlls/dinput/effect_linuxinput.c b/dlls/dinput/effect_linuxinput.c
index 3c86a34..a14a0ef 100644
--- a/dlls/dinput/effect_linuxinput.c
+++ b/dlls/dinput/effect_linuxinput.c
@@ -766,7 +766,7 @@ static ULONG WINAPI LinuxInputEffectImpl_Release(LPDIRECTINPUTEFFECT iface)
LinuxInputEffectImpl_Stop(iface);
LinuxInputEffectImpl_Unload(iface);
list_remove(This->entry);
- HeapFree(GetProcessHeap(), 0, LIST_ENTRY(This->entry, effect_list_item, entry));
+ HeapFree(GetProcessHeap(), 0, WINE_LIST_ENTRY(This->entry, effect_list_item, entry));
HeapFree(GetProcessHeap(), 0, This);
}
return ref;
diff --git a/dlls/dmime/graph.c b/dlls/dmime/graph.c
index 6f9f705..a9979d5 100644
--- a/dlls/dmime/graph.c
+++ b/dlls/dmime/graph.c
@@ -126,7 +126,7 @@ static HRESULT WINAPI IDirectMusicGraphImpl_IDirectMusicGraph_InsertTool (LPDIRE
pPrevEntry = &This->Tools;
LIST_FOR_EACH (pEntry, &This->Tools) {
- pIt = LIST_ENTRY(pEntry, DMUS_PRIVATE_GRAPH_TOOL, entry);
+ pIt = WINE_LIST_ENTRY(pEntry, DMUS_PRIVATE_GRAPH_TOOL, entry);
if (pIt->dwIndex == lIndex) {
return DMUS_E_ALREADY_EXISTS;
}
@@ -160,7 +160,7 @@ static HRESULT WINAPI IDirectMusicGraphImpl_IDirectMusicGraph_GetTool (LPDIRECTM
FIXME("(%p, %d, %p): stub\n", This, dwIndex, ppTool);
LIST_FOR_EACH (pEntry, &This->Tools) {
- pIt = LIST_ENTRY(pEntry, DMUS_PRIVATE_GRAPH_TOOL, entry);
+ pIt = WINE_LIST_ENTRY(pEntry, DMUS_PRIVATE_GRAPH_TOOL, entry);
if (pIt->dwIndex == dwIndex) {
*ppTool = pIt->pTool;
if (NULL != *ppTool) {
diff --git a/dlls/dmime/segment.c b/dlls/dmime/segment.c
index ca127d7..138b9bb 100644
--- a/dlls/dmime/segment.c
+++ b/dlls/dmime/segment.c
@@ -169,7 +169,7 @@ static HRESULT WINAPI IDirectMusicSegment8Impl_IDirectMusicSegment8_GetTrack (LP
}
LIST_FOR_EACH (pEntry, &This->Tracks) {
- pIt = LIST_ENTRY(pEntry, DMUS_PRIVATE_SEGMENT_TRACK, entry);
+ pIt = WINE_LIST_ENTRY(pEntry, DMUS_PRIVATE_SEGMENT_TRACK, entry);
TRACE(" - %p -> 0x%x,%p\n", pIt, pIt->dwGroupBits, pIt->pTrack);
if (0xFFFFFFFF != dwGroupBits && 0 == (pIt->dwGroupBits & dwGroupBits)) continue ;
if (FALSE == IsEqualGUID(&GUID_NULL, rguidType)) {
@@ -214,7 +214,7 @@ static HRESULT WINAPI IDirectMusicSegment8Impl_IDirectMusicSegment8_GetTrackGrou
}
LIST_FOR_EACH (pEntry, &This->Tracks) {
- pIt = LIST_ENTRY(pEntry, DMUS_PRIVATE_SEGMENT_TRACK, entry);
+ pIt = WINE_LIST_ENTRY(pEntry, DMUS_PRIVATE_SEGMENT_TRACK, entry);
TRACE(" - %p -> %d,%p\n", pIt, pIt->dwGroupBits, pIt->pTrack);
if (NULL != pIt && pIt->pTrack == pTrack) {
*pdwGroupBits = pIt->dwGroupBits;
@@ -237,7 +237,7 @@ static HRESULT WINAPI IDirectMusicSegment8Impl_IDirectMusicSegment8_InsertTrack
LIST_FOR_EACH (pEntry, &This->Tracks) {
i++;
- pIt = LIST_ENTRY(pEntry, DMUS_PRIVATE_SEGMENT_TRACK, entry);
+ pIt = WINE_LIST_ENTRY(pEntry, DMUS_PRIVATE_SEGMENT_TRACK, entry);
TRACE(" - #%u: %p -> %d,%p\n", i, pIt, pIt->dwGroupBits, pIt->pTrack);
if (NULL != pIt && pIt->pTrack == pTrack) {
ERR("(%p, %p): track is already in list\n", This, pTrack);
@@ -268,7 +268,7 @@ static HRESULT WINAPI IDirectMusicSegment8Impl_IDirectMusicSegment8_RemoveTrack
TRACE("(%p, %p)\n", This, pTrack);
LIST_FOR_EACH (pEntry, &This->Tracks) {
- pIt = LIST_ENTRY(pEntry, DMUS_PRIVATE_SEGMENT_TRACK, entry);
+ pIt = WINE_LIST_ENTRY(pEntry, DMUS_PRIVATE_SEGMENT_TRACK, entry);
if (pIt->pTrack == pTrack) {
TRACE("(%p, %p): track in list\n", This, pTrack);
@@ -357,7 +357,7 @@ static HRESULT WINAPI IDirectMusicSegment8Impl_IDirectMusicSegment8_GetParam (LP
if (DMUS_SEG_ANYTRACK == dwIndex) {
LIST_FOR_EACH (pEntry, &This->Tracks) {
- pIt = LIST_ENTRY(pEntry, DMUS_PRIVATE_SEGMENT_TRACK, entry);
+ pIt = WINE_LIST_ENTRY(pEntry, DMUS_PRIVATE_SEGMENT_TRACK, entry);
hr = IDirectMusicTrack_QueryInterface(pIt->pTrack, &IID_IPersistStream, (void**) &pCLSIDStream);
if (FAILED(hr)) {
diff --git a/dlls/dmime/tempotrack.c b/dlls/dmime/tempotrack.c
index 21a4685..1a79b9b 100644
--- a/dlls/dmime/tempotrack.c
+++ b/dlls/dmime/tempotrack.c
@@ -174,7 +174,7 @@ static HRESULT WINAPI IDirectMusicTempoTrack_IDirectMusicTrack_GetParam (LPDIREC
prm->dblTempo = 0.123456;
LIST_FOR_EACH (pEntry, &This->Items) {
- pIt = LIST_ENTRY(pEntry, DMUS_PRIVATE_TEMPO_ITEM, entry);
+ pIt = WINE_LIST_ENTRY(pEntry, DMUS_PRIVATE_TEMPO_ITEM, entry);
/*TRACE(" - %p -> 0x%lx,%p\n", pIt, pIt->item.lTime, pIt->item.dblTempo);*/
if (pIt->item.lTime <= mtTime) {
MUSIC_TIME ofs = pIt->item.lTime - mtTime;
diff --git a/dlls/dmloader/container.c b/dlls/dmloader/container.c
index a1fa878..efab89f 100644
--- a/dlls/dmloader/container.c
+++ b/dlls/dmloader/container.c
@@ -52,7 +52,7 @@ static HRESULT DMUSIC_DestroyDirectMusicContainerImpl (LPDIRECTMUSICCONTAINER if
/* release objects from loader's cache (if appropriate) */
TRACE(": releasing objects from loader's cache\n");
LIST_FOR_EACH (pEntry, This->pContainedObjects) {
- pContainedObject = LIST_ENTRY (pEntry, WINE_CONTAINER_ENTRY, entry);
+ pContainedObject = WINE_LIST_ENTRY (pEntry, WINE_CONTAINER_ENTRY, entry);
/* my tests indicate that container releases objects *only*
if they were loaded at its load-time (makes sense, it doesn't
have pointers to objects otherwise); BTW: native container seems
@@ -135,7 +135,7 @@ static HRESULT WINAPI IDirectMusicContainerImpl_IDirectMusicContainer_EnumObject
DM_STRUCT_INIT(pDesc);
LIST_FOR_EACH (pEntry, This->pContainedObjects) {
- pContainedObject = LIST_ENTRY (pEntry, WINE_CONTAINER_ENTRY, entry);
+ pContainedObject = WINE_LIST_ENTRY (pEntry, WINE_CONTAINER_ENTRY, entry);
if (IsEqualGUID (rguidClass, &GUID_DirectMusicAllTypes) || IsEqualGUID (rguidClass, &pContainedObject->Desc.guidClass)) {
if (dwCount == dwIndex) {
@@ -852,7 +852,7 @@ static HRESULT WINAPI IDirectMusicContainerImpl_IPersistStream_Load (LPPERSISTST
LIST_FOR_EACH (pEntry, This->pContainedObjects) {
IDirectMusicObject* pObject;
- pContainedObject = LIST_ENTRY (pEntry, WINE_CONTAINER_ENTRY, entry);
+ pContainedObject = WINE_LIST_ENTRY (pEntry, WINE_CONTAINER_ENTRY, entry);
/* get object from loader and then release it */
if (SUCCEEDED(IDirectMusicLoader_GetObject (pLoader, &pContainedObject->Desc, &IID_IDirectMusicObject, (LPVOID*)&pObject))) {
pContainedObject->pObject = pObject; /* for final release */
@@ -876,7 +876,7 @@ static HRESULT WINAPI IDirectMusicContainerImpl_IPersistStream_Load (LPPERSISTST
TRACE("*** IDirectMusicContainer (%p) ***\n", This->ContainerVtbl);
TRACE(" - Objects:\n");
LIST_FOR_EACH (listEntry, This->pContainedObjects) {
- tmpEntry = LIST_ENTRY( listEntry, WINE_CONTAINER_ENTRY, entry );
+ tmpEntry = WINE_LIST_ENTRY( listEntry, WINE_CONTAINER_ENTRY, entry );
TRACE(" - Object[%i]:\n", r);
TRACE(" - wszAlias: %s\n", debugstr_w(tmpEntry->wszAlias));
TRACE(" - Object descriptor:\n%s\n", debugstr_DMUS_OBJECTDESC(&tmpEntry->Desc));
diff --git a/dlls/dmloader/loader.c b/dlls/dmloader/loader.c
index 0e9748d..dbe02b4 100644
--- a/dlls/dmloader/loader.c
+++ b/dlls/dmloader/loader.c
@@ -139,7 +139,7 @@ static HRESULT WINAPI IDirectMusicLoaderImpl_IDirectMusicLoader_GetObject (LPDIR
or set via SetObject; */
TRACE(": looking if we have object in the cache or if it can be found via alias\n");
LIST_FOR_EACH(pEntry, This->pObjects) {
- LPWINE_LOADER_ENTRY pExistingEntry = LIST_ENTRY(pEntry, WINE_LOADER_ENTRY, entry);
+ LPWINE_LOADER_ENTRY pExistingEntry = WINE_LIST_ENTRY(pEntry, WINE_LOADER_ENTRY, entry);
if ((pDesc->dwValidData & DMUS_OBJ_OBJECT) &&
(pExistingEntry->Desc.dwValidData & DMUS_OBJ_OBJECT) &&
IsEqualGUID (&pDesc->guidObject, &pExistingEntry->Desc.guidObject)) {
@@ -351,7 +351,7 @@ static HRESULT WINAPI IDirectMusicLoaderImpl_IDirectMusicLoader_GetObject (LPDIR
int i = 0;
LIST_FOR_EACH (pEntry, This->pObjects) {
i++;
- pObjectEntry = LIST_ENTRY(pEntry, WINE_LOADER_ENTRY, entry);
+ pObjectEntry = WINE_LIST_ENTRY(pEntry, WINE_LOADER_ENTRY, entry);
TRACE(": entry nr. %i:\n%s\n - bInvalidDefaultDLS = %i\n - pObject = %p\n", i, debugstr_DMUS_OBJECTDESC(&pObjectEntry->Desc), pObjectEntry->bInvalidDefaultDLS, pObjectEntry->pObject);
}
#endif
@@ -470,7 +470,7 @@ static HRESULT WINAPI IDirectMusicLoaderImpl_IDirectMusicLoader_SetObject (LPDIR
/* sometimes it happens that twisted programs call SetObject for same object twice...
in such cases, native loader returns S_OK and does nothing... a sound plan */
LIST_FOR_EACH (pEntry, This->pObjects) {
- pObjectEntry = LIST_ENTRY (pEntry, WINE_LOADER_ENTRY, entry);
+ pObjectEntry = WINE_LIST_ENTRY (pEntry, WINE_LOADER_ENTRY, entry);
if (!memcmp (&pObjectEntry->Desc, pDesc, sizeof(DMUS_OBJECTDESC))) {
TRACE(": exactly same entry already exists\n");
return S_OK;
@@ -571,7 +571,7 @@ static HRESULT WINAPI IDirectMusicLoaderImpl_IDirectMusicLoader_CacheObject (LPD
/* now iterate thru list and check if we have alias (without object), corresponding
to descriptor of input object */
LIST_FOR_EACH(pEntry, This->pObjects) {
- pObjectEntry = LIST_ENTRY(pEntry, WINE_LOADER_ENTRY, entry);
+ pObjectEntry = WINE_LIST_ENTRY(pEntry, WINE_LOADER_ENTRY, entry);
if ((Desc.dwValidData & DMUS_OBJ_OBJECT) &&
(pObjectEntry->Desc.dwValidData & DMUS_OBJ_OBJECT) &&
IsEqualGUID (&Desc.guidObject, &pObjectEntry->Desc.guidObject)) {
@@ -653,7 +653,7 @@ static HRESULT WINAPI IDirectMusicLoaderImpl_IDirectMusicLoader_ReleaseObject (L
/* iterate thru the list of objects we know about; check only those with DMUS_OBJ_LOADED */
TRACE(": looking for the object in cache\n");
LIST_FOR_EACH(pEntry, This->pObjects) {
- pObjectEntry = LIST_ENTRY(pEntry, WINE_LOADER_ENTRY, entry);
+ pObjectEntry = WINE_LIST_ENTRY(pEntry, WINE_LOADER_ENTRY, entry);
if ((Desc.dwValidData & DMUS_OBJ_OBJECT) &&
(pObjectEntry->Desc.dwValidData & (DMUS_OBJ_OBJECT | DMUS_OBJ_LOADED)) &&
IsEqualGUID (&Desc.guidObject, &pObjectEntry->Desc.guidObject)) {
@@ -707,7 +707,7 @@ static HRESULT WINAPI IDirectMusicLoaderImpl_IDirectMusicLoader_ClearCache (LPDI
TRACE("(%p, %s)\n", This, debugstr_dmguid(rguidClass));
LIST_FOR_EACH (pEntry, This->pObjects) {
- pObjectEntry = LIST_ENTRY (pEntry, WINE_LOADER_ENTRY, entry);
+ pObjectEntry = WINE_LIST_ENTRY (pEntry, WINE_LOADER_ENTRY, entry);
if ((IsEqualGUID (rguidClass, &GUID_DirectMusicAllTypes) || IsEqualGUID (rguidClass, &pObjectEntry->Desc.guidClass)) &&
(pObjectEntry->Desc.dwValidData & DMUS_OBJ_LOADED)) {
@@ -740,7 +740,7 @@ static HRESULT WINAPI IDirectMusicLoaderImpl_IDirectMusicLoader_EnumObject (LPDI
DM_STRUCT_INIT(pDesc);
LIST_FOR_EACH (pEntry, This->pObjects) {
- pObjectEntry = LIST_ENTRY (pEntry, WINE_LOADER_ENTRY, entry);
+ pObjectEntry = WINE_LIST_ENTRY (pEntry, WINE_LOADER_ENTRY, entry);
if (IsEqualGUID (rguidClass, &GUID_DirectMusicAllTypes) || IsEqualGUID (rguidClass, &pObjectEntry->Desc.guidClass)) {
if (dwCount == dwIndex) {
@@ -890,7 +890,7 @@ HRESULT WINAPI DMUSIC_CreateDirectMusicLoaderImpl (LPCGUID lpcGUID, LPVOID *ppob
DMUS_E_LOADER_NOFILENAME for all requests for it; basically, we check
if out input guidObject was overwritten */
pEntry = list_head (obj->pObjects);
- pDefaultDLSEntry = LIST_ENTRY (pEntry, WINE_LOADER_ENTRY, entry);
+ pDefaultDLSEntry = WINE_LIST_ENTRY (pEntry, WINE_LOADER_ENTRY, entry);
if (!IsEqualGUID(&Desc.guidObject, &GUID_DefaultGMCollection)) {
pDefaultDLSEntry->bInvalidDefaultDLS = TRUE;
}
@@ -908,7 +908,7 @@ static HRESULT DMUSIC_GetLoaderSettings (LPDIRECTMUSICLOADER8 iface, REFGUID pCl
TRACE(": (%p, %s, %p, %p)\n", This, debugstr_dmguid(pClassID), wszSearchPath, pbCache);
LIST_FOR_EACH(pEntry, This->pClassSettings) {
- LPWINE_LOADER_OPTION pOptionEntry = LIST_ENTRY(pEntry, WINE_LOADER_OPTION, entry);
+ LPWINE_LOADER_OPTION pOptionEntry = WINE_LIST_ENTRY(pEntry, WINE_LOADER_OPTION, entry);
if (IsEqualCLSID (pClassID, &pOptionEntry->guidClass)) {
if (wszSearchPath)
strcpyW(wszSearchPath, pOptionEntry->wszSearchPath);
@@ -928,7 +928,7 @@ static HRESULT DMUSIC_SetLoaderSettings (LPDIRECTMUSICLOADER8 iface, REFGUID pCl
TRACE(": (%p, %s, %p, %p)\n", This, debugstr_dmguid(pClassID), wszSearchPath, pbCache);
LIST_FOR_EACH(pEntry, This->pClassSettings) {
- LPWINE_LOADER_OPTION pOptionEntry = LIST_ENTRY(pEntry, WINE_LOADER_OPTION, entry);
+ LPWINE_LOADER_OPTION pOptionEntry = WINE_LIST_ENTRY(pEntry, WINE_LOADER_OPTION, entry);
/* well, either we have GUID_DirectMusicAllTypes and need to set it to all,
or specific CLSID is given and we set it only to it */
if (IsEqualGUID (pClassID, &GUID_DirectMusicAllTypes) ||
diff --git a/dlls/dmstyle/commandtrack.c b/dlls/dmstyle/commandtrack.c
index 17dc8f8..9867845 100644
--- a/dlls/dmstyle/commandtrack.c
+++ b/dlls/dmstyle/commandtrack.c
@@ -297,7 +297,7 @@ static HRESULT WINAPI IDirectMusicCommandTrack_IPersistStream_Load (LPPERSISTSTR
TRACE("*** IDirectMusicCommandTrack (%p) ***\n", This->TrackVtbl);
TRACE(" - Commands:\n");
LIST_FOR_EACH (listEntry, &This->Commands) {
- tmpEntry = LIST_ENTRY (listEntry, DMUS_PRIVATE_COMMAND, entry);
+ tmpEntry = WINE_LIST_ENTRY (listEntry, DMUS_PRIVATE_COMMAND, entry);
TRACE(" - Command[%i]:\n", r);
TRACE(" - mtTime = %i\n", tmpEntry->pCommand.mtTime);
TRACE(" - wMeasure = %d\n", tmpEntry->pCommand.wMeasure);
diff --git a/dlls/dmusic/collection.c b/dlls/dmusic/collection.c
index 06ec651..a478924 100644
--- a/dlls/dmusic/collection.c
+++ b/dlls/dmusic/collection.c
@@ -115,7 +115,7 @@ static HRESULT WINAPI IDirectMusicCollectionImpl_IDirectMusicCollection_GetInstr
TRACE("(%p, %d, %p)\n", This, dwPatch, ppInstrument);
LIST_FOR_EACH (listEntry, &This->Instruments) {
- tmpEntry = LIST_ENTRY(listEntry, DMUS_PRIVATE_INSTRUMENTENTRY, entry);
+ tmpEntry = WINE_LIST_ENTRY(listEntry, DMUS_PRIVATE_INSTRUMENTENTRY, entry);
IDirectMusicInstrument_GetPatch (tmpEntry->pInstrument, &dwInstPatch);
if (dwPatch == dwInstPatch) {
*ppInstrument = tmpEntry->pInstrument;
@@ -140,7 +140,7 @@ static HRESULT WINAPI IDirectMusicCollectionImpl_IDirectMusicCollection_EnumInst
TRACE("(%p, %d, %p, %p, %d)\n", This, dwIndex, pdwPatch, pwszName, dwNameLen);
LIST_FOR_EACH (listEntry, &This->Instruments) {
- tmpEntry = LIST_ENTRY(listEntry, DMUS_PRIVATE_INSTRUMENTENTRY, entry);
+ tmpEntry = WINE_LIST_ENTRY(listEntry, DMUS_PRIVATE_INSTRUMENTENTRY, entry);
if (r == dwIndex) {
ICOM_NAME_MULTI (IDirectMusicInstrumentImpl, InstrumentVtbl, tmpEntry->pInstrument, pInstrument);
IDirectMusicInstrument_GetPatch (tmpEntry->pInstrument, pdwPatch);
@@ -725,7 +725,7 @@ static HRESULT WINAPI IDirectMusicCollectionImpl_IPersistStream_Load (LPPERSISTS
TRACE(" - Instruments:\n");
LIST_FOR_EACH (listEntry, &This->Instruments) {
- tmpEntry = LIST_ENTRY( listEntry, DMUS_PRIVATE_INSTRUMENTENTRY, entry );
+ tmpEntry = WINE_LIST_ENTRY( listEntry, DMUS_PRIVATE_INSTRUMENTENTRY, entry );
TRACE(" - Instrument[%i]: %p\n", r, tmpEntry->pInstrument);
r++;
}
diff --git a/dlls/fusion/asmenum.c b/dlls/fusion/asmenum.c
index 3706f07..f8d082f 100644
--- a/dlls/fusion/asmenum.c
+++ b/dlls/fusion/asmenum.c
@@ -95,7 +95,7 @@ static ULONG WINAPI IAssemblyEnumImpl_Release(IAssemblyEnum *iface)
{
LIST_FOR_EACH_SAFE(item, cursor, &This->assemblies)
{
- ASMNAME *asmname = LIST_ENTRY(item, ASMNAME, entry);
+ ASMNAME *asmname = WINE_LIST_ENTRY(item, ASMNAME, entry);
list_remove(&asmname->entry);
IAssemblyName_Release(asmname->name);
@@ -121,7 +121,7 @@ static HRESULT WINAPI IAssemblyEnumImpl_GetNextAssembly(IAssemblyEnum *iface,
if (!ppName)
return E_INVALIDARG;
- asmname = LIST_ENTRY(asmenum->iter, ASMNAME, entry);
+ asmname = WINE_LIST_ENTRY(asmenum->iter, ASMNAME, entry);
if (!asmname)
return S_FALSE;
@@ -270,7 +270,7 @@ static void insert_assembly(struct list *assemblies, ASMNAME *to_insert)
LIST_FOR_EACH(item, assemblies)
{
- ASMNAME *name = LIST_ENTRY(item, ASMNAME, entry);
+ ASMNAME *name = WINE_LIST_ENTRY(item, ASMNAME, entry);
if (compare_assembly_names(name, to_insert) > 0)
{
diff --git a/dlls/fusion/tests/asmenum.c b/dlls/fusion/tests/asmenum.c
index cb6ea3d..3c9c9c5 100644
--- a/dlls/fusion/tests/asmenum.c
+++ b/dlls/fusion/tests/asmenum.c
@@ -337,7 +337,7 @@ static void test_enumerate(void)
found = FALSE;
LIST_FOR_EACH_SAFE(item, cursor, &assemblies)
{
- ASMNAME *asmname = LIST_ENTRY(item, ASMNAME, entry);
+ ASMNAME *asmname = WINE_LIST_ENTRY(item, ASMNAME, entry);
if (!lstrcmpA(asmname->data, disp))
{
@@ -363,7 +363,7 @@ static void test_enumerate(void)
LIST_FOR_EACH_SAFE(item, cursor, &assemblies)
{
- ASMNAME *asmname = LIST_ENTRY(item, ASMNAME, entry);
+ ASMNAME *asmname = WINE_LIST_ENTRY(item, ASMNAME, entry);
ok(FALSE, "Assembly not enumerated: %s\n", asmname->data);
diff --git a/dlls/gdi32/freetype.c b/dlls/gdi32/freetype.c
index a93cb60..85cab18 100644
--- a/dlls/gdi32/freetype.c
+++ b/dlls/gdi32/freetype.c
@@ -1199,7 +1199,7 @@ static void AddFaceToFamily(Face *face, Family *family)
LIST_FOR_EACH( entry, &family->faces )
{
- Face *ent = LIST_ENTRY(entry, Face, entry);
+ Face *ent = WINE_LIST_ENTRY(entry, Face, entry);
if (StyleOrdering(face) < StyleOrdering(ent)) break;
}
list_add_before( entry, &face->entry );
@@ -1360,7 +1360,7 @@ static INT AddFontToList(const char *file, void *font_data_ptr, DWORD font_data_
family = NULL;
LIST_FOR_EACH(family_elem_ptr, &font_list) {
- family = LIST_ENTRY(family_elem_ptr, Family, entry);
+ family = WINE_LIST_ENTRY(family_elem_ptr, Family, entry);
if(!strcmpiW(family->FamilyName, localised_family ? localised_family : english_family))
break;
family = NULL;
@@ -1420,7 +1420,7 @@ static INT AddFontToList(const char *file, void *font_data_ptr, DWORD font_data_
face_elem_ptr = list_head(&family->faces);
while(face_elem_ptr) {
- face = LIST_ENTRY(face_elem_ptr, Face, entry);
+ face = WINE_LIST_ENTRY(face_elem_ptr, Face, entry);
face_elem_ptr = list_next(&family->faces, face_elem_ptr);
if(!strcmpiW(face->StyleName, StyleW) &&
(FT_IS_SCALABLE(ft_face) || ((size->y_ppem == face->size.y_ppem) && !memcmp(&fs, &face->fs, sizeof(fs)) ))) {
@@ -1550,10 +1550,10 @@ static void DumpFontList(void)
struct list *family_elem_ptr, *face_elem_ptr;
LIST_FOR_EACH(family_elem_ptr, &font_list) {
- family = LIST_ENTRY(family_elem_ptr, Family, entry);
+ family = WINE_LIST_ENTRY(family_elem_ptr, Family, entry);
TRACE("Family: %s\n", debugstr_w(family->FamilyName));
LIST_FOR_EACH(face_elem_ptr, &family->faces) {
- face = LIST_ENTRY(face_elem_ptr, Face, entry);
+ face = WINE_LIST_ENTRY(face_elem_ptr, Face, entry);
TRACE("\t%s\t%08x", debugstr_w(face->StyleName), face->fs.fsCsb[0]);
if(!face->scalable)
TRACE(" %d", face->size.height);
@@ -1607,10 +1607,10 @@ static void LoadReplaceList(void)
/* Find the old family and hence all of the font files
in that family */
LIST_FOR_EACH(family_elem_ptr, &font_list) {
- family = LIST_ENTRY(family_elem_ptr, Family, entry);
+ family = WINE_LIST_ENTRY(family_elem_ptr, Family, entry);
if(!strcmpiW(family->FamilyName, data)) {
LIST_FOR_EACH(face_elem_ptr, &family->faces) {
- face = LIST_ENTRY(face_elem_ptr, Face, entry);
+ face = WINE_LIST_ENTRY(face_elem_ptr, Face, entry);
TRACE("mapping %s %s to %s\n", debugstr_w(family->FamilyName),
debugstr_w(face->StyleName), familyA);
/* Now add a new entry with the new family name */
@@ -1989,10 +1989,10 @@ static void update_reg_entries(void)
/* enumerate the fonts and add external ones to the two keys */
LIST_FOR_EACH(family_elem_ptr, &font_list) {
- family = LIST_ENTRY(family_elem_ptr, Family, entry);
+ family = WINE_LIST_ENTRY(family_elem_ptr, Family, entry);
len_fam = strlenW(family->FamilyName) + sizeof(TrueType) / sizeof(WCHAR) + 1;
LIST_FOR_EACH(face_elem_ptr, &family->faces) {
- face = LIST_ENTRY(face_elem_ptr, Face, entry);
+ face = WINE_LIST_ENTRY(face_elem_ptr, Face, entry);
if(!face->external) continue;
len = len_fam;
if (!(face->ntmFlags & NTM_REGULAR))
@@ -3085,14 +3085,14 @@ static void free_font(GdiFont *font)
LIST_FOR_EACH_SAFE(cursor, cursor2, &font->child_fonts)
{
- CHILD_FONT *child = LIST_ENTRY(cursor, CHILD_FONT, entry);
+ CHILD_FONT *child = WINE_LIST_ENTRY(cursor, CHILD_FONT, entry);
struct list *first_hfont;
HFONTLIST *hfontlist;
list_remove(cursor);
if(child->font)
{
first_hfont = list_head(&child->font->hfontlist);
- hfontlist = LIST_ENTRY(first_hfont, HFONTLIST, entry);
+ hfontlist = WINE_LIST_ENTRY(first_hfont, HFONTLIST, entry);
DeleteObject(hfontlist->hfont);
HeapFree(GetProcessHeap(), 0, hfontlist);
free_font(child->font);
@@ -3312,11 +3312,11 @@ static GdiFont *find_in_cache(HFONT hfont, const LOGFONTW *plf, const FMAT2 *pma
/* try the child list */
LIST_FOR_EACH(font_elem_ptr, &child_font_list) {
- ret = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
+ ret = WINE_LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
if(!fontcmp(ret, &fd)) {
if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
LIST_FOR_EACH(hfontlist_elem_ptr, &ret->hfontlist) {
- hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
+ hflist = WINE_LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
if(hflist->hfont == hfont)
return ret;
}
@@ -3325,11 +3325,11 @@ static GdiFont *find_in_cache(HFONT hfont, const LOGFONTW *plf, const FMAT2 *pma
/* try the in-use list */
LIST_FOR_EACH(font_elem_ptr, &gdi_font_list) {
- ret = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
+ ret = WINE_LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
if(!fontcmp(ret, &fd)) {
if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
LIST_FOR_EACH(hfontlist_elem_ptr, &ret->hfontlist) {
- hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
+ hflist = WINE_LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
if(hflist->hfont == hfont)
return ret;
}
@@ -3343,7 +3343,7 @@ static GdiFont *find_in_cache(HFONT hfont, const LOGFONTW *plf, const FMAT2 *pma
/* then the unused list */
font_elem_ptr = list_head(&unused_gdi_font_list);
while(font_elem_ptr) {
- ret = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
+ ret = WINE_LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
if(!fontcmp(ret, &fd)) {
if(!can_use_bitmap && !FT_IS_SCALABLE(ret->ft_face)) continue;
@@ -3616,12 +3616,12 @@ GdiFont *WineEngCreateFontInstance(DC *dc, HFONT hfont)
or if that's unavailable the first charset that the font supports.
*/
LIST_FOR_EACH(family_elem_ptr, &font_list) {
- family = LIST_ENTRY(family_elem_ptr, Family, entry);
+ family = WINE_LIST_ENTRY(family_elem_ptr, Family, entry);
if (!strcmpiW(family->FamilyName, FaceName) ||
(psub && !strcmpiW(family->FamilyName, psub->to.name)))
{
LIST_FOR_EACH(face_elem_ptr, &family->faces) {
- face = LIST_ENTRY(face_elem_ptr, Face, entry);
+ face = WINE_LIST_ENTRY(face_elem_ptr, Face, entry);
if((csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) || !csi.fs.fsCsb[0])
if(face->scalable || can_use_bitmap)
goto found;
@@ -3681,10 +3681,10 @@ GdiFont *WineEngCreateFontInstance(DC *dc, HFONT hfont)
else
strcpyW(lf.lfFaceName, defSans);
LIST_FOR_EACH(family_elem_ptr, &font_list) {
- family = LIST_ENTRY(family_elem_ptr, Family, entry);
+ family = WINE_LIST_ENTRY(family_elem_ptr, Family, entry);
if(!strcmpiW(family->FamilyName, lf.lfFaceName)) {
LIST_FOR_EACH(face_elem_ptr, &family->faces) {
- face = LIST_ENTRY(face_elem_ptr, Face, entry);
+ face = WINE_LIST_ENTRY(face_elem_ptr, Face, entry);
if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0]))
if(face->scalable || can_use_bitmap)
goto found;
@@ -3694,9 +3694,9 @@ GdiFont *WineEngCreateFontInstance(DC *dc, HFONT hfont)
last_resort_family = NULL;
LIST_FOR_EACH(family_elem_ptr, &font_list) {
- family = LIST_ENTRY(family_elem_ptr, Family, entry);
+ family = WINE_LIST_ENTRY(family_elem_ptr, Family, entry);
LIST_FOR_EACH(face_elem_ptr, &family->faces) {
- face = LIST_ENTRY(face_elem_ptr, Face, entry);
+ face = WINE_LIST_ENTRY(face_elem_ptr, Face, entry);
if(csi.fs.fsCsb[0] & (face->fs.fsCsb[0] | face->fs_links.fsCsb[0])) {
if(face->scalable)
goto found;
@@ -3713,9 +3713,9 @@ GdiFont *WineEngCreateFontInstance(DC *dc, HFONT hfont)
}
LIST_FOR_EACH(family_elem_ptr, &font_list) {
- family = LIST_ENTRY(family_elem_ptr, Family, entry);
+ family = WINE_LIST_ENTRY(family_elem_ptr, Family, entry);
LIST_FOR_EACH(face_elem_ptr, &family->faces) {
- face = LIST_ENTRY(face_elem_ptr, Face, entry);
+ face = WINE_LIST_ENTRY(face_elem_ptr, Face, entry);
if(face->scalable) {
csi.fs.fsCsb[0] = 0;
WARN("just using first face for now\n");
@@ -3877,14 +3877,14 @@ static void dump_gdi_font_list(void)
TRACE("---------- gdiFont Cache ----------\n");
LIST_FOR_EACH(elem_ptr, &gdi_font_list) {
- gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
+ gdiFont = WINE_LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
TRACE("gdiFont=%p %s %d\n",
gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
}
TRACE("---------- Unused gdiFont Cache ----------\n");
LIST_FOR_EACH(elem_ptr, &unused_gdi_font_list) {
- gdiFont = LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
+ gdiFont = WINE_LIST_ENTRY(elem_ptr, struct tagGdiFont, entry);
TRACE("gdiFont=%p %s %d\n",
gdiFont, debugstr_w(gdiFont->font_desc.lf.lfFaceName), gdiFont->font_desc.lf.lfHeight);
}
@@ -3910,7 +3910,7 @@ BOOL WineEngDestroyFontInstance(HFONT handle)
LIST_FOR_EACH_ENTRY(gdiFont, &child_font_list, struct tagGdiFont, entry)
{
struct list *first_hfont = list_head(&gdiFont->hfontlist);
- hflist = LIST_ENTRY(first_hfont, HFONTLIST, entry);
+ hflist = WINE_LIST_ENTRY(first_hfont, HFONTLIST, entry);
if(hflist->hfont == handle)
{
TRACE("removing child font %p from child list\n", gdiFont);
@@ -3926,12 +3926,12 @@ BOOL WineEngDestroyFontInstance(HFONT handle)
font_elem_ptr = list_head(&gdi_font_list);
while(font_elem_ptr) {
- gdiFont = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
+ gdiFont = WINE_LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
font_elem_ptr = list_next(&gdi_font_list, font_elem_ptr);
hfontlist_elem_ptr = list_head(&gdiFont->hfontlist);
while(hfontlist_elem_ptr) {
- hflist = LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
+ hflist = WINE_LIST_ENTRY(hfontlist_elem_ptr, struct tagHFONTLIST, entry);
hfontlist_elem_ptr = list_next(&gdiFont->hfontlist, hfontlist_elem_ptr);
if(hflist->hfont == handle) {
list_remove(&hflist->entry);
@@ -3951,7 +3951,7 @@ BOOL WineEngDestroyFontInstance(HFONT handle)
while(font_elem_ptr && i++ < UNUSED_CACHE_SIZE)
font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
while(font_elem_ptr) {
- gdiFont = LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
+ gdiFont = WINE_LIST_ENTRY(font_elem_ptr, struct tagGdiFont, entry);
font_elem_ptr = list_next(&unused_gdi_font_list, font_elem_ptr);
TRACE("freeing %p\n", gdiFont);
list_remove(&gdiFont->entry);
@@ -4105,10 +4105,10 @@ DWORD WineEngEnumFonts(LPLOGFONTW plf, FONTENUMPROCW proc, LPARAM lparam)
}
LIST_FOR_EACH(family_elem_ptr, &font_list) {
- family = LIST_ENTRY(family_elem_ptr, Family, entry);
+ family = WINE_LIST_ENTRY(family_elem_ptr, Family, entry);
if(!strcmpiW(plf->lfFaceName, family->FamilyName)) {
LIST_FOR_EACH(face_elem_ptr, &family->faces) {
- face = LIST_ENTRY(face_elem_ptr, Face, entry);
+ face = WINE_LIST_ENTRY(face_elem_ptr, Face, entry);
GetEnumStructs(face, &elf, &ntm, &type);
for(i = 0; i < 32; i++) {
if(!face->scalable && face->fs.fsCsb[0] == 0) { /* OEM bitmap */
@@ -4149,9 +4149,9 @@ DWORD WineEngEnumFonts(LPLOGFONTW plf, FONTENUMPROCW proc, LPARAM lparam)
}
} else {
LIST_FOR_EACH(family_elem_ptr, &font_list) {
- family = LIST_ENTRY(family_elem_ptr, Family, entry);
+ family = WINE_LIST_ENTRY(family_elem_ptr, Family, entry);
face_elem_ptr = list_head(&family->faces);
- face = LIST_ENTRY(face_elem_ptr, Face, entry);
+ face = WINE_LIST_ENTRY(face_elem_ptr, Face, entry);
GetEnumStructs(face, &elf, &ntm, &type);
for(i = 0; i < 32; i++) {
if(!face->scalable && face->fs.fsCsb[0] == 0) { /* OEM bitmap */
@@ -6158,7 +6158,7 @@ BOOL WineEngGetLinkedHFont(DC *dc, WCHAR c, HFONT *new_hfont, UINT *glyph)
else
{
first_hfont = list_head(&linked_font->hfontlist);
- *new_hfont = LIST_ENTRY(first_hfont, struct tagHFONTLIST, entry)->hfont;
+ *new_hfont = WINE_LIST_ENTRY(first_hfont, struct tagHFONTLIST, entry)->hfont;
}
LeaveCriticalSection( &freetype_cs );
return ret;
diff --git a/dlls/inetcomm/mimeole.c b/dlls/inetcomm/mimeole.c
index 992949a..2b4c6bd 100644
--- a/dlls/inetcomm/mimeole.c
+++ b/dlls/inetcomm/mimeole.c
@@ -1806,7 +1806,7 @@ static HRESULT find_body(struct list *list, HBODY hbody, body_t **body)
if(hbody == HBODY_ROOT)
{
- *body = LIST_ENTRY(list_head(list), body_t, entry);
+ *body = WINE_LIST_ENTRY(list_head(list), body_t, entry);
return S_OK;
}
@@ -1861,7 +1861,7 @@ static HRESULT WINAPI MimeMessage_SaveBody(
static HRESULT get_body(MimeMessage *msg, BODYLOCATION location, HBODY pivot, body_t **out)
{
- body_t *root = LIST_ENTRY(list_head(&msg->body_tree), body_t, entry);
+ body_t *root = WINE_LIST_ENTRY(list_head(&msg->body_tree), body_t, entry);
body_t *body;
HRESULT hr;
struct list *list;
@@ -1885,7 +1885,7 @@ static HRESULT get_body(MimeMessage *msg, BODYLOCATION location, HBODY pivot, bo
case IBL_FIRST:
list = list_head(&body->children);
if(list)
- *out = LIST_ENTRY(list, body_t, entry);
+ *out = WINE_LIST_ENTRY(list, body_t, entry);
else
hr = MIME_E_NOT_FOUND;
break;
@@ -1893,7 +1893,7 @@ static HRESULT get_body(MimeMessage *msg, BODYLOCATION location, HBODY pivot, bo
case IBL_LAST:
list = list_tail(&body->children);
if(list)
- *out = LIST_ENTRY(list, body_t, entry);
+ *out = WINE_LIST_ENTRY(list, body_t, entry);
else
hr = MIME_E_NOT_FOUND;
break;
@@ -1901,7 +1901,7 @@ static HRESULT get_body(MimeMessage *msg, BODYLOCATION location, HBODY pivot, bo
case IBL_NEXT:
list = list_next(&body->parent->children, &body->entry);
if(list)
- *out = LIST_ENTRY(list, body_t, entry);
+ *out = WINE_LIST_ENTRY(list, body_t, entry);
else
hr = MIME_E_NOT_FOUND;
break;
@@ -1909,7 +1909,7 @@ static HRESULT get_body(MimeMessage *msg, BODYLOCATION location, HBODY pivot, bo
case IBL_PREVIOUS:
list = list_prev(&body->parent->children, &body->entry);
if(list)
- *out = LIST_ENTRY(list, body_t, entry);
+ *out = WINE_LIST_ENTRY(list, body_t, entry);
else
hr = MIME_E_NOT_FOUND;
break;
diff --git a/dlls/kernel32/resource.c b/dlls/kernel32/resource.c
index d364739..4849471 100644
--- a/dlls/kernel32/resource.c
+++ b/dlls/kernel32/resource.c
@@ -784,7 +784,7 @@ static void free_resource_directory( struct list *head, int level )
{
struct resource_dir_entry *ent;
- ent = LIST_ENTRY( ptr, struct resource_dir_entry, entry );
+ ent = WINE_LIST_ENTRY( ptr, struct resource_dir_entry, entry );
res_free_str( ent->id );
free_resource_directory( &ent->children, level - 1 );
HeapFree(GetProcessHeap(), 0, ent);
@@ -793,7 +793,7 @@ static void free_resource_directory( struct list *head, int level )
{
struct resource_data *data;
- data = LIST_ENTRY( ptr, struct resource_data, entry );
+ data = WINE_LIST_ENTRY( ptr, struct resource_data, entry );
HeapFree( GetProcessHeap(), 0, data );
}
}
diff --git a/dlls/mapi32/prop.c b/dlls/mapi32/prop.c
index 5a7e8db..c23436b 100644
--- a/dlls/mapi32/prop.c
+++ b/dlls/mapi32/prop.c
@@ -1414,7 +1414,7 @@ static IPropDataItem *IMAPIPROP_GetValue(IPropDataImpl *This, ULONG ulPropTag)
LIST_FOR_EACH(cursor, &This->values)
{
- LPIPropDataItem current = LIST_ENTRY(cursor, IPropDataItem, entry);
+ LPIPropDataItem current = WINE_LIST_ENTRY(cursor, IPropDataItem, entry);
/* Note that propery types don't have to match, just Id's */
if (PROP_ID(current->value->ulPropTag) == PROP_ID(ulPropTag))
return current;
@@ -1547,7 +1547,7 @@ static inline ULONG IMAPIProp_fnRelease(LPMAPIPROP iface)
while (!list_empty(&This->values))
{
struct list *head = list_head(&This->values);
- LPIPropDataItem current = LIST_ENTRY(head, IPropDataItem, entry);
+ LPIPropDataItem current = WINE_LIST_ENTRY(head, IPropDataItem, entry);
list_remove(head);
This->lpFree(current->value);
This->lpFree(current);
@@ -1736,7 +1736,7 @@ IMAPIProp_fnGetPropList(LPMAPIPROP iface, ULONG ulFlags,
i = 0;
LIST_FOR_EACH(cursor, &This->values)
{
- LPIPropDataItem current = LIST_ENTRY(cursor, IPropDataItem, entry);
+ LPIPropDataItem current = WINE_LIST_ENTRY(cursor, IPropDataItem, entry);
(*lppTags)->aulPropTag[i] = current->value->ulPropTag;
i++;
}
@@ -2410,7 +2410,7 @@ IPropData_fnHrGetPropAccess(LPPROPDATA iface, LPSPropTagArray *lppTags,
i = 0;
LIST_FOR_EACH(cursor, &This->values)
{
- LPIPropDataItem item = LIST_ENTRY(cursor, IPropDataItem, entry);
+ LPIPropDataItem item = WINE_LIST_ENTRY(cursor, IPropDataItem, entry);
(*lppTags)->aulPropTag[i] = item->value->ulPropTag;
(*lppAccess)[i] = item->ulAccess;
i++;
diff --git a/dlls/msctf/compartmentmgr.c b/dlls/msctf/compartmentmgr.c
index 4f6408d..24b0ed2 100644
--- a/dlls/msctf/compartmentmgr.c
+++ b/dlls/msctf/compartmentmgr.c
@@ -102,7 +102,7 @@ HRESULT CompartmentMgr_Destructor(ITfCompartmentMgr *iface)
LIST_FOR_EACH_SAFE(cursor, cursor2, &This->values)
{
- CompartmentValue* value = LIST_ENTRY(cursor,CompartmentValue,entry);
+ CompartmentValue* value = WINE_LIST_ENTRY(cursor,CompartmentValue,entry);
list_remove(cursor);
ITfCompartment_Release(value->compartment);
HeapFree(GetProcessHeap(),0,value);
@@ -177,7 +177,7 @@ static HRESULT WINAPI CompartmentMgr_GetCompartment(ITfCompartmentMgr *iface,
LIST_FOR_EACH(cursor, &This->values)
{
- value = LIST_ENTRY(cursor,CompartmentValue,entry);
+ value = WINE_LIST_ENTRY(cursor,CompartmentValue,entry);
if (IsEqualGUID(rguid,&value->guid))
{
ITfCompartment_AddRef(value->compartment);
@@ -213,7 +213,7 @@ static HRESULT WINAPI CompartmentMgr_ClearCompartment(ITfCompartmentMgr *iface,
LIST_FOR_EACH(cursor, &This->values)
{
- CompartmentValue* value = LIST_ENTRY(cursor,CompartmentValue,entry);
+ CompartmentValue* value = WINE_LIST_ENTRY(cursor,CompartmentValue,entry);
if (IsEqualGUID(rguid,&value->guid))
{
if (value->owner && tid != value->owner)
@@ -344,7 +344,7 @@ static HRESULT WINAPI CompartmentEnumGuid_Next( LPENUMGUID iface,
while (fetched < celt && This->cursor)
{
- CompartmentValue* value = LIST_ENTRY(This->cursor,CompartmentValue,entry);
+ CompartmentValue* value = WINE_LIST_ENTRY(This->cursor,CompartmentValue,entry);
if (!value)
break;
@@ -441,7 +441,7 @@ static void Compartment_Destructor(Compartment *This)
VariantClear(&This->variant);
LIST_FOR_EACH_SAFE(cursor, cursor2, &This->CompartmentEventSink)
{
- CompartmentSink* sink = LIST_ENTRY(cursor,CompartmentSink,entry);
+ CompartmentSink* sink = WINE_LIST_ENTRY(cursor,CompartmentSink,entry);
list_remove(cursor);
free_sink(sink);
}
@@ -520,7 +520,7 @@ static HRESULT WINAPI Compartment_SetValue(ITfCompartment *iface,
LIST_FOR_EACH(cursor, &This->CompartmentEventSink)
{
- CompartmentSink* sink = LIST_ENTRY(cursor,CompartmentSink,entry);
+ CompartmentSink* sink = WINE_LIST_ENTRY(cursor,CompartmentSink,entry);
ITfCompartmentEventSink_OnChange(sink->interfaces.pITfCompartmentEventSink,&This->valueData->guid);
}
diff --git a/dlls/msctf/context.c b/dlls/msctf/context.c
index 1b4e3cf..26e7031 100644
--- a/dlls/msctf/context.c
+++ b/dlls/msctf/context.c
@@ -155,31 +155,31 @@ static void Context_Destructor(Context *This)
LIST_FOR_EACH_SAFE(cursor, cursor2, &This->pContextKeyEventSink)
{
- ContextSink* sink = LIST_ENTRY(cursor,ContextSink,entry);
+ ContextSink* sink = WINE_LIST_ENTRY(cursor,ContextSink,entry);
list_remove(cursor);
free_sink(sink);
}
LIST_FOR_EACH_SAFE(cursor, cursor2, &This->pEditTransactionSink)
{
- ContextSink* sink = LIST_ENTRY(cursor,ContextSink,entry);
+ ContextSink* sink = WINE_LIST_ENTRY(cursor,ContextSink,entry);
list_remove(cursor);
free_sink(sink);
}
LIST_FOR_EACH_SAFE(cursor, cursor2, &This->pStatusSink)
{
- ContextSink* sink = LIST_ENTRY(cursor,ContextSink,entry);
+ ContextSink* sink = WINE_LIST_ENTRY(cursor,ContextSink,entry);
list_remove(cursor);
free_sink(sink);
}
LIST_FOR_EACH_SAFE(cursor, cursor2, &This->pTextEditSink)
{
- ContextSink* sink = LIST_ENTRY(cursor,ContextSink,entry);
+ ContextSink* sink = WINE_LIST_ENTRY(cursor,ContextSink,entry);
list_remove(cursor);
free_sink(sink);
}
LIST_FOR_EACH_SAFE(cursor, cursor2, &This->pTextLayoutSink)
{
- ContextSink* sink = LIST_ENTRY(cursor,ContextSink,entry);
+ ContextSink* sink = WINE_LIST_ENTRY(cursor,ContextSink,entry);
list_remove(cursor);
free_sink(sink);
}
@@ -1032,7 +1032,7 @@ static HRESULT WINAPI TextStoreACPSink_OnLockGranted(ITextStoreACPSink *iface,
/*TODO: implement ITfEditRecord */
LIST_FOR_EACH(cursor, &This->pContext->pTextEditSink)
{
- ContextSink* sink = LIST_ENTRY(cursor,ContextSink,entry);
+ ContextSink* sink = WINE_LIST_ENTRY(cursor,ContextSink,entry);
ITfTextEditSink_OnEndEdit(sink->interfaces.pITfTextEditSink,
(ITfContext*) &This->pContext, sc, NULL);
}
diff --git a/dlls/msctf/inputprocessor.c b/dlls/msctf/inputprocessor.c
index ba4a76d..15cc068 100644
--- a/dlls/msctf/inputprocessor.c
+++ b/dlls/msctf/inputprocessor.c
@@ -119,7 +119,7 @@ static void InputProcessorProfiles_Destructor(InputProcessorProfiles *This)
/* free sinks */
LIST_FOR_EACH_SAFE(cursor, cursor2, &This->LanguageProfileNotifySink)
{
- InputProcessorProfilesSink* sink = LIST_ENTRY(cursor,InputProcessorProfilesSink,entry);
+ InputProcessorProfilesSink* sink = WINE_LIST_ENTRY(cursor,InputProcessorProfilesSink,entry);
list_remove(cursor);
free_sink(sink);
}
@@ -499,7 +499,7 @@ static HRESULT WINAPI InputProcessorProfiles_ChangeCurrentLanguage(
LIST_FOR_EACH(cursor, &This->LanguageProfileNotifySink)
{
- InputProcessorProfilesSink* sink = LIST_ENTRY(cursor,InputProcessorProfilesSink,entry);
+ InputProcessorProfilesSink* sink = WINE_LIST_ENTRY(cursor,InputProcessorProfilesSink,entry);
accept = TRUE;
ITfLanguageProfileNotifySink_OnLanguageChange(sink->interfaces.pITfLanguageProfileNotifySink, langid, &accept);
if (!accept)
diff --git a/dlls/msctf/threadmgr.c b/dlls/msctf/threadmgr.c
index 5f3a90a..44ff035 100644
--- a/dlls/msctf/threadmgr.c
+++ b/dlls/msctf/threadmgr.c
@@ -180,44 +180,44 @@ static void ThreadMgr_Destructor(ThreadMgr *This)
/* free sinks */
LIST_FOR_EACH_SAFE(cursor, cursor2, &This->ActiveLanguageProfileNotifySink)
{
- ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+ ThreadMgrSink* sink = WINE_LIST_ENTRY(cursor,ThreadMgrSink,entry);
list_remove(cursor);
free_sink(sink);
}
LIST_FOR_EACH_SAFE(cursor, cursor2, &This->DisplayAttributeNotifySink)
{
- ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+ ThreadMgrSink* sink = WINE_LIST_ENTRY(cursor,ThreadMgrSink,entry);
list_remove(cursor);
free_sink(sink);
}
LIST_FOR_EACH_SAFE(cursor, cursor2, &This->KeyTraceEventSink)
{
- ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+ ThreadMgrSink* sink = WINE_LIST_ENTRY(cursor,ThreadMgrSink,entry);
list_remove(cursor);
free_sink(sink);
}
LIST_FOR_EACH_SAFE(cursor, cursor2, &This->PreservedKeyNotifySink)
{
- ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+ ThreadMgrSink* sink = WINE_LIST_ENTRY(cursor,ThreadMgrSink,entry);
list_remove(cursor);
free_sink(sink);
}
LIST_FOR_EACH_SAFE(cursor, cursor2, &This->ThreadFocusSink)
{
- ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+ ThreadMgrSink* sink = WINE_LIST_ENTRY(cursor,ThreadMgrSink,entry);
list_remove(cursor);
free_sink(sink);
}
LIST_FOR_EACH_SAFE(cursor, cursor2, &This->ThreadMgrEventSink)
{
- ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+ ThreadMgrSink* sink = WINE_LIST_ENTRY(cursor,ThreadMgrSink,entry);
list_remove(cursor);
free_sink(sink);
}
LIST_FOR_EACH_SAFE(cursor, cursor2, &This->CurrentPreservedKeys)
{
- PreservedKey* key = LIST_ENTRY(cursor,PreservedKey,entry);
+ PreservedKey* key = WINE_LIST_ENTRY(cursor,PreservedKey,entry);
list_remove(cursor);
HeapFree(GetProcessHeap(),0,key->description);
HeapFree(GetProcessHeap(),0,key);
@@ -225,7 +225,7 @@ static void ThreadMgr_Destructor(ThreadMgr *This)
LIST_FOR_EACH_SAFE(cursor, cursor2, &This->CreatedDocumentMgrs)
{
- DocumentMgrEntry *mgr = LIST_ENTRY(cursor,DocumentMgrEntry,entry);
+ DocumentMgrEntry *mgr = WINE_LIST_ENTRY(cursor,DocumentMgrEntry,entry);
list_remove(cursor);
FIXME("Left Over ITfDocumentMgr. Should we do something with it?\n");
HeapFree(GetProcessHeap(),0,mgr);
@@ -233,7 +233,7 @@ static void ThreadMgr_Destructor(ThreadMgr *This)
LIST_FOR_EACH_SAFE(cursor, cursor2, &This->AssociatedFocusWindows)
{
- AssociatedWindow *wnd = LIST_ENTRY(cursor,AssociatedWindow,entry);
+ AssociatedWindow *wnd = WINE_LIST_ENTRY(cursor,AssociatedWindow,entry);
list_remove(cursor);
HeapFree(GetProcessHeap(),0,wnd);
}
@@ -456,7 +456,7 @@ static LRESULT CALLBACK ThreadFocusHookProc(int nCode, WPARAM wParam, LPARAM lPa
LIST_FOR_EACH(cursor, &This->AssociatedFocusWindows)
{
- AssociatedWindow *wnd = LIST_ENTRY(cursor,AssociatedWindow,entry);
+ AssociatedWindow *wnd = WINE_LIST_ENTRY(cursor,AssociatedWindow,entry);
if (wnd->hwnd == (HWND)wParam)
{
TRACE("Triggering Associated window focus\n");
@@ -502,7 +502,7 @@ ITfDocumentMgr *pdimNew, ITfDocumentMgr **ppdimPrev)
LIST_FOR_EACH_SAFE(cursor, cursor2, &This->AssociatedFocusWindows)
{
- wnd = LIST_ENTRY(cursor,AssociatedWindow,entry);
+ wnd = WINE_LIST_ENTRY(cursor,AssociatedWindow,entry);
if (wnd->hwnd == hwnd)
{
if (wnd->docmgr)
@@ -844,7 +844,7 @@ static HRESULT WINAPI KeystrokeMgr_IsPreservedKey(ITfKeystrokeMgr *iface,
LIST_FOR_EACH(cursor, &This->CurrentPreservedKeys)
{
- PreservedKey* key = LIST_ENTRY(cursor,PreservedKey,entry);
+ PreservedKey* key = WINE_LIST_ENTRY(cursor,PreservedKey,entry);
if (IsEqualGUID(rguid,&key->guid) && pprekey->uVKey == key->prekey.uVKey && pprekey->uModifiers == key->prekey.uModifiers)
{
*pfRegistered = TRUE;
@@ -871,7 +871,7 @@ static HRESULT WINAPI KeystrokeMgr_PreserveKey(ITfKeystrokeMgr *iface,
LIST_FOR_EACH(cursor, &This->CurrentPreservedKeys)
{
- PreservedKey* key = LIST_ENTRY(cursor,PreservedKey,entry);
+ PreservedKey* key = WINE_LIST_ENTRY(cursor,PreservedKey,entry);
if (IsEqualGUID(rguid,&key->guid) && prekey->uVKey == key->prekey.uVKey && prekey->uModifiers == key->prekey.uModifiers)
return TF_E_ALREADY_EXISTS;
}
@@ -913,7 +913,7 @@ static HRESULT WINAPI KeystrokeMgr_UnpreserveKey(ITfKeystrokeMgr *iface,
LIST_FOR_EACH(cursor, &This->CurrentPreservedKeys)
{
- key = LIST_ENTRY(cursor,PreservedKey,entry);
+ key = WINE_LIST_ENTRY(cursor,PreservedKey,entry);
if (IsEqualGUID(rguid,&key->guid) && pprekey->uVKey == key->prekey.uVKey && pprekey->uModifiers == key->prekey.uModifiers)
break;
key = NULL;
@@ -1129,7 +1129,7 @@ static HRESULT WINAPI ThreadMgrEventSink_OnInitDocumentMgr(
LIST_FOR_EACH(cursor, &This->ThreadMgrEventSink)
{
- ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+ ThreadMgrSink* sink = WINE_LIST_ENTRY(cursor,ThreadMgrSink,entry);
ITfThreadMgrEventSink_OnInitDocumentMgr(sink->interfaces.pITfThreadMgrEventSink,pdim);
}
@@ -1146,7 +1146,7 @@ static HRESULT WINAPI ThreadMgrEventSink_OnUninitDocumentMgr(
LIST_FOR_EACH(cursor, &This->ThreadMgrEventSink)
{
- ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+ ThreadMgrSink* sink = WINE_LIST_ENTRY(cursor,ThreadMgrSink,entry);
ITfThreadMgrEventSink_OnUninitDocumentMgr(sink->interfaces.pITfThreadMgrEventSink,pdim);
}
@@ -1164,7 +1164,7 @@ static HRESULT WINAPI ThreadMgrEventSink_OnSetFocus(
LIST_FOR_EACH(cursor, &This->ThreadMgrEventSink)
{
- ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+ ThreadMgrSink* sink = WINE_LIST_ENTRY(cursor,ThreadMgrSink,entry);
ITfThreadMgrEventSink_OnSetFocus(sink->interfaces.pITfThreadMgrEventSink, pdimFocus, pdimPrevFocus);
}
@@ -1181,7 +1181,7 @@ static HRESULT WINAPI ThreadMgrEventSink_OnPushContext(
LIST_FOR_EACH(cursor, &This->ThreadMgrEventSink)
{
- ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+ ThreadMgrSink* sink = WINE_LIST_ENTRY(cursor,ThreadMgrSink,entry);
ITfThreadMgrEventSink_OnPushContext(sink->interfaces.pITfThreadMgrEventSink,pic);
}
@@ -1198,7 +1198,7 @@ static HRESULT WINAPI ThreadMgrEventSink_OnPopContext(
LIST_FOR_EACH(cursor, &This->ThreadMgrEventSink)
{
- ThreadMgrSink* sink = LIST_ENTRY(cursor,ThreadMgrSink,entry);
+ ThreadMgrSink* sink = WINE_LIST_ENTRY(cursor,ThreadMgrSink,entry);
ITfThreadMgrEventSink_OnPopContext(sink->interfaces.pITfThreadMgrEventSink,pic);
}
@@ -1374,7 +1374,7 @@ static HRESULT WINAPI EnumTfDocumentMgr_Next(IEnumTfDocumentMgrs *iface,
if (This->index == NULL)
break;
- mgrentry = LIST_ENTRY(This->index,DocumentMgrEntry,entry);
+ mgrentry = WINE_LIST_ENTRY(This->index,DocumentMgrEntry,entry);
if (mgrentry == NULL)
break;
@@ -1462,7 +1462,7 @@ void ThreadMgr_OnDocumentMgrDestruction(ITfThreadMgr *tm, ITfDocumentMgr *mgr)
struct list *cursor;
LIST_FOR_EACH(cursor, &This->CreatedDocumentMgrs)
{
- DocumentMgrEntry *mgrentry = LIST_ENTRY(cursor,DocumentMgrEntry,entry);
+ DocumentMgrEntry *mgrentry = WINE_LIST_ENTRY(cursor,DocumentMgrEntry,entry);
if (mgrentry->docmgr == mgr)
{
list_remove(cursor);
diff --git a/dlls/mshtml/dispex.c b/dlls/mshtml/dispex.c
index be44748..eb0f41d 100644
--- a/dlls/mshtml/dispex.c
+++ b/dlls/mshtml/dispex.c
@@ -195,7 +195,7 @@ void release_typelib(void)
unsigned i;
while(!list_empty(&dispex_data_list)) {
- iter = LIST_ENTRY(list_head(&dispex_data_list), dispex_data_t, entry);
+ iter = WINE_LIST_ENTRY(list_head(&dispex_data_list), dispex_data_t, entry);
list_remove(&iter->entry);
for(i=0; i < iter->func_cnt; i++)
diff --git a/dlls/mshtml/htmlwindow.c b/dlls/mshtml/htmlwindow.c
index 4a2babe..b608185 100644
--- a/dlls/mshtml/htmlwindow.c
+++ b/dlls/mshtml/htmlwindow.c
@@ -93,7 +93,7 @@ static void release_children(HTMLWindow *This)
HTMLWindow *child;
while(!list_empty(&This->children)) {
- child = LIST_ENTRY(list_tail(&This->children), HTMLWindow, sibling_entry);
+ child = WINE_LIST_ENTRY(list_tail(&This->children), HTMLWindow, sibling_entry);
list_remove(&child->sibling_entry);
child->parent = NULL;
diff --git a/dlls/mshtml/script.c b/dlls/mshtml/script.c
index efd2605..317cace 100644
--- a/dlls/mshtml/script.c
+++ b/dlls/mshtml/script.c
@@ -965,7 +965,7 @@ void release_script_hosts(HTMLWindow *window)
ScriptHost *iter;
while(!list_empty(&window->script_hosts)) {
- iter = LIST_ENTRY(list_head(&window->script_hosts), ScriptHost, entry);
+ iter = WINE_LIST_ENTRY(list_head(&window->script_hosts), ScriptHost, entry);
release_script_engine(iter);
list_remove(&iter->entry);
diff --git a/dlls/mshtml/task.c b/dlls/mshtml/task.c
index eae51ca..93a0a59 100644
--- a/dlls/mshtml/task.c
+++ b/dlls/mshtml/task.c
@@ -100,13 +100,13 @@ void remove_target_tasks(LONG target)
return;
LIST_FOR_EACH_SAFE(liter, ltmp, &thread_data->timer_list) {
- timer = LIST_ENTRY(liter, task_timer_t, entry);
+ timer = WINE_LIST_ENTRY(liter, task_timer_t, entry);
if(timer->doc->task_magic == target)
release_task_timer(thread_data->thread_hwnd, timer);
}
if(!list_empty(&thread_data->timer_list)) {
- timer = LIST_ENTRY(list_head(&thread_data->timer_list), task_timer_t, entry);
+ timer = WINE_LIST_ENTRY(list_head(&thread_data->timer_list), task_timer_t, entry);
SetTimer(thread_data->thread_hwnd, TIMER_ID, timer->time - GetTickCount(), NULL);
}
@@ -139,7 +139,7 @@ static BOOL queue_timer(thread_data_t *thread_data, task_timer_t *timer)
list_remove(&timer->entry);
if(list_empty(&thread_data->timer_list)
- || LIST_ENTRY(list_head(&thread_data->timer_list), task_timer_t, entry)->time > timer->time) {
+ || WINE_LIST_ENTRY(list_head(&thread_data->timer_list), task_timer_t, entry)->time > timer->time) {
list_add_head(&thread_data->timer_list, &timer->entry);
return TRUE;
@@ -230,7 +230,7 @@ static LRESULT process_timer(void)
TRACE("\n");
while(!list_empty(&thread_data->timer_list)) {
- timer = LIST_ENTRY(list_head(&thread_data->timer_list), task_timer_t, entry);
+ timer = WINE_LIST_ENTRY(list_head(&thread_data->timer_list), task_timer_t, entry);
tc = GetTickCount();
if(timer->time > tc) {
diff --git a/dlls/msi/action.c b/dlls/msi/action.c
index 10338ad..25f70af 100644
--- a/dlls/msi/action.c
+++ b/dlls/msi/action.c
@@ -5192,7 +5192,7 @@ static void free_list(FILE_LIST *list)
{
while (!list_empty(&list->entry))
{
- FILE_LIST *file = LIST_ENTRY(list_head(&list->entry), FILE_LIST, entry);
+ FILE_LIST *file = WINE_LIST_ENTRY(list_head(&list->entry), FILE_LIST, entry);
list_remove(&file->entry);
free_file_entry(file);
@@ -5284,7 +5284,7 @@ static BOOL move_files_wildcard(LPWSTR source, LPWSTR dest, int options)
goto done;
/* only the first wildcard match gets renamed to dest */
- file = LIST_ENTRY(list_head(&files.entry), FILE_LIST, entry);
+ file = WINE_LIST_ENTRY(list_head(&files.entry), FILE_LIST, entry);
size = (strrchrW(file->dest, '\\') - file->dest) + lstrlenW(file->destname) + 2;
file->dest = msi_realloc(file->dest, size * sizeof(WCHAR));
if (!file->dest)
@@ -5302,7 +5302,7 @@ static BOOL move_files_wildcard(LPWSTR source, LPWSTR dest, int options)
while (!list_empty(&files.entry))
{
- file = LIST_ENTRY(list_head(&files.entry), FILE_LIST, entry);
+ file = WINE_LIST_ENTRY(list_head(&files.entry), FILE_LIST, entry);
msi_move_file(file->source, file->dest, options);
@@ -5771,7 +5771,7 @@ static void free_assemblies(struct list *assemblies)
LIST_FOR_EACH_SAFE(item, cursor, assemblies)
{
- MSIASSEMBLY *assembly = LIST_ENTRY(item, MSIASSEMBLY, entry);
+ MSIASSEMBLY *assembly = WINE_LIST_ENTRY(item, MSIASSEMBLY, entry);
list_remove(&assembly->entry);
msi_free(assembly->application);
diff --git a/dlls/msi/custom.c b/dlls/msi/custom.c
index 508bf6b..bfed44f 100644
--- a/dlls/msi/custom.c
+++ b/dlls/msi/custom.c
@@ -1372,7 +1372,7 @@ void ACTION_FinishCustomActions(const MSIPACKAGE* package)
while ((item = list_head( &package->RunningActions )))
{
- MSIRUNNINGACTION *action = LIST_ENTRY( item, MSIRUNNINGACTION, entry );
+ MSIRUNNINGACTION *action = WINE_LIST_ENTRY( item, MSIRUNNINGACTION, entry );
list_remove( &action->entry );
diff --git a/dlls/msi/database.c b/dlls/msi/database.c
index b0966a2..d6ab938 100644
--- a/dlls/msi/database.c
+++ b/dlls/msi/database.c
@@ -237,7 +237,7 @@ static void free_transforms( MSIDATABASE *db )
{
while( !list_empty( &db->transforms ) )
{
- MSITRANSFORM *t = LIST_ENTRY( list_head( &db->transforms ),
+ MSITRANSFORM *t = WINE_LIST_ENTRY( list_head( &db->transforms ),
MSITRANSFORM, entry );
list_remove( &t->entry );
IStorage_Release( t->stg );
@@ -249,7 +249,7 @@ static void free_streams( MSIDATABASE *db )
{
while( !list_empty( &db->streams ) )
{
- MSISTREAM *s = LIST_ENTRY( list_head( &db->streams ),
+ MSISTREAM *s = WINE_LIST_ENTRY( list_head( &db->streams ),
MSISTREAM, entry );
list_remove( &s->entry );
IStream_Release( s->stm );
@@ -1676,7 +1676,7 @@ static void merge_free_rows(MERGETABLE *table)
LIST_FOR_EACH_SAFE(item, cursor, &table->rows)
{
- MERGEROW *row = LIST_ENTRY(item, MERGEROW, entry);
+ MERGEROW *row = WINE_LIST_ENTRY(item, MERGEROW, entry);
list_remove(&row->entry);
msiobj_release(&row->data->hdr);
@@ -1965,7 +1965,7 @@ UINT WINAPI MsiDatabaseMergeW(MSIHANDLE hDatabase, MSIHANDLE hDatabaseMerge,
LIST_FOR_EACH_SAFE(item, cursor, &tabledata)
{
- MERGETABLE *table = LIST_ENTRY(item, MERGETABLE, entry);
+ MERGETABLE *table = WINE_LIST_ENTRY(item, MERGETABLE, entry);
list_remove(&table->entry);
free_merge_table(table);
}
diff --git a/dlls/msi/dialog.c b/dlls/msi/dialog.c
index 5fd4bbd..5f11ee9 100644
--- a/dlls/msi/dialog.c
+++ b/dlls/msi/dialog.c
@@ -3760,7 +3760,7 @@ void msi_dialog_destroy( msi_dialog *dialog )
{
msi_control *t;
- t = LIST_ENTRY( list_head( &dialog->controls ),
+ t = WINE_LIST_ENTRY( list_head( &dialog->controls ),
msi_control, entry );
msi_destroy_control( t );
}
diff --git a/dlls/msi/events.c b/dlls/msi/events.c
index 6275a95..4bcf53a 100644
--- a/dlls/msi/events.c
+++ b/dlls/msi/events.c
@@ -298,7 +298,7 @@ VOID ControlEvent_CleanupDialogSubscriptions(MSIPACKAGE *package, LPWSTR dialog)
LIST_FOR_EACH_SAFE( i, t, &package->subscriptions )
{
- sub = LIST_ENTRY( i, struct subscriber, entry );
+ sub = WINE_LIST_ENTRY( i, struct subscriber, entry );
if ( lstrcmpW( msi_dialog_get_name( sub->dialog ), dialog ))
continue;
@@ -315,7 +315,7 @@ VOID ControlEvent_CleanupSubscriptions(MSIPACKAGE *package)
LIST_FOR_EACH_SAFE( i, t, &package->subscriptions )
{
- sub = LIST_ENTRY( i, struct subscriber, entry );
+ sub = WINE_LIST_ENTRY( i, struct subscriber, entry );
list_remove( &sub->entry );
free_subscriber( sub );
diff --git a/dlls/msi/format.c b/dlls/msi/format.c
index f59024a..1d494be 100644
--- a/dlls/msi/format.c
+++ b/dlls/msi/format.c
@@ -92,7 +92,7 @@ static void free_stack(STACK *stack)
{
while (!list_empty(&stack->items))
{
- FORMSTR *str = LIST_ENTRY(list_head(&stack->items), FORMSTR, entry);
+ FORMSTR *str = WINE_LIST_ENTRY(list_head(&stack->items), FORMSTR, entry);
list_remove(&str->entry);
msi_free(str);
}
@@ -112,7 +112,7 @@ static FORMSTR *stack_pop(STACK *stack)
if (list_empty(&stack->items))
return NULL;
- ret = LIST_ENTRY(list_head(&stack->items), FORMSTR, entry);
+ ret = WINE_LIST_ENTRY(list_head(&stack->items), FORMSTR, entry);
list_remove(&ret->entry);
return ret;
}
@@ -132,7 +132,7 @@ static FORMSTR *stack_find(STACK *stack, int type)
static FORMSTR *stack_peek(STACK *stack)
{
- return LIST_ENTRY(list_head(&stack->items), FORMSTR, entry);
+ return WINE_LIST_ENTRY(list_head(&stack->items), FORMSTR, entry);
}
static LPCWSTR get_formstr_data(FORMAT *format, FORMSTR *str)
diff --git a/dlls/msi/helpers.c b/dlls/msi/helpers.c
index 8356923..38611aa 100644
--- a/dlls/msi/helpers.c
+++ b/dlls/msi/helpers.c
@@ -446,7 +446,7 @@ static void remove_tracked_tempfiles(MSIPACKAGE* package)
LIST_FOR_EACH_SAFE( item, cursor, &package->tempfiles )
{
- MSITEMPFILE *temp = LIST_ENTRY( item, MSITEMPFILE, entry );
+ MSITEMPFILE *temp = WINE_LIST_ENTRY( item, MSITEMPFILE, entry );
list_remove( &temp->entry );
TRACE("deleting temp file %s\n", debugstr_w( temp->Path ));
@@ -463,14 +463,14 @@ static void free_feature( MSIFEATURE *feature )
LIST_FOR_EACH_SAFE( item, cursor, &feature->Children )
{
- FeatureList *fl = LIST_ENTRY( item, FeatureList, entry );
+ FeatureList *fl = WINE_LIST_ENTRY( item, FeatureList, entry );
list_remove( &fl->entry );
msi_free( fl );
}
LIST_FOR_EACH_SAFE( item, cursor, &feature->Components )
{
- ComponentList *cl = LIST_ENTRY( item, ComponentList, entry );
+ ComponentList *cl = WINE_LIST_ENTRY( item, ComponentList, entry );
list_remove( &cl->entry );
msi_free( cl );
}
@@ -488,7 +488,7 @@ static void free_extension( MSIEXTENSION *ext )
LIST_FOR_EACH_SAFE( item, cursor, &ext->verbs )
{
- MSIVERB *verb = LIST_ENTRY( item, MSIVERB, entry );
+ MSIVERB *verb = WINE_LIST_ENTRY( item, MSIVERB, entry );
list_remove( &verb->entry );
msi_free( verb->Verb );
@@ -514,14 +514,14 @@ void ACTION_free_package_structures( MSIPACKAGE* package)
LIST_FOR_EACH_SAFE( item, cursor, &package->features )
{
- MSIFEATURE *feature = LIST_ENTRY( item, MSIFEATURE, entry );
+ MSIFEATURE *feature = WINE_LIST_ENTRY( item, MSIFEATURE, entry );
list_remove( &feature->entry );
free_feature( feature );
}
LIST_FOR_EACH_SAFE( item, cursor, &package->folders )
{
- MSIFOLDER *folder = LIST_ENTRY( item, MSIFOLDER, entry );
+ MSIFOLDER *folder = WINE_LIST_ENTRY( item, MSIFOLDER, entry );
list_remove( &folder->entry );
msi_free( folder->Parent );
@@ -537,7 +537,7 @@ void ACTION_free_package_structures( MSIPACKAGE* package)
LIST_FOR_EACH_SAFE( item, cursor, &package->components )
{
- MSICOMPONENT *comp = LIST_ENTRY( item, MSICOMPONENT, entry );
+ MSICOMPONENT *comp = WINE_LIST_ENTRY( item, MSICOMPONENT, entry );
list_remove( &comp->entry );
msi_free( comp->Component );
@@ -551,7 +551,7 @@ void ACTION_free_package_structures( MSIPACKAGE* package)
LIST_FOR_EACH_SAFE( item, cursor, &package->files )
{
- MSIFILE *file = LIST_ENTRY( item, MSIFILE, entry );
+ MSIFILE *file = WINE_LIST_ENTRY( item, MSIFILE, entry );
list_remove( &file->entry );
msi_free( file->File );
@@ -567,7 +567,7 @@ void ACTION_free_package_structures( MSIPACKAGE* package)
/* clean up extension, progid, class and verb structures */
LIST_FOR_EACH_SAFE( item, cursor, &package->classes )
{
- MSICLASS *cls = LIST_ENTRY( item, MSICLASS, entry );
+ MSICLASS *cls = WINE_LIST_ENTRY( item, MSICLASS, entry );
list_remove( &cls->entry );
msi_free( cls->clsid );
@@ -584,7 +584,7 @@ void ACTION_free_package_structures( MSIPACKAGE* package)
LIST_FOR_EACH_SAFE( item, cursor, &package->extensions )
{
- MSIEXTENSION *ext = LIST_ENTRY( item, MSIEXTENSION, entry );
+ MSIEXTENSION *ext = WINE_LIST_ENTRY( item, MSIEXTENSION, entry );
list_remove( &ext->entry );
free_extension( ext );
@@ -592,7 +592,7 @@ void ACTION_free_package_structures( MSIPACKAGE* package)
LIST_FOR_EACH_SAFE( item, cursor, &package->progids )
{
- MSIPROGID *progid = LIST_ENTRY( item, MSIPROGID, entry );
+ MSIPROGID *progid = WINE_LIST_ENTRY( item, MSIPROGID, entry );
list_remove( &progid->entry );
msi_free( progid->ProgID );
@@ -603,7 +603,7 @@ void ACTION_free_package_structures( MSIPACKAGE* package)
LIST_FOR_EACH_SAFE( item, cursor, &package->mimes )
{
- MSIMIME *mt = LIST_ENTRY( item, MSIMIME, entry );
+ MSIMIME *mt = WINE_LIST_ENTRY( item, MSIMIME, entry );
list_remove( &mt->entry );
msi_free( mt->clsid );
@@ -613,7 +613,7 @@ void ACTION_free_package_structures( MSIPACKAGE* package)
LIST_FOR_EACH_SAFE( item, cursor, &package->appids )
{
- MSIAPPID *appid = LIST_ENTRY( item, MSIAPPID, entry );
+ MSIAPPID *appid = WINE_LIST_ENTRY( item, MSIAPPID, entry );
list_remove( &appid->entry );
msi_free( appid->AppID );
@@ -626,7 +626,7 @@ void ACTION_free_package_structures( MSIPACKAGE* package)
LIST_FOR_EACH_SAFE( item, cursor, &package->sourcelist_info )
{
- MSISOURCELISTINFO *info = LIST_ENTRY( item, MSISOURCELISTINFO, entry );
+ MSISOURCELISTINFO *info = WINE_LIST_ENTRY( item, MSISOURCELISTINFO, entry );
list_remove( &info->entry );
msi_free( info->value );
@@ -635,7 +635,7 @@ void ACTION_free_package_structures( MSIPACKAGE* package)
LIST_FOR_EACH_SAFE( item, cursor, &package->sourcelist_media )
{
- MSIMEDIADISK *info = LIST_ENTRY( item, MSIMEDIADISK, entry );
+ MSIMEDIADISK *info = WINE_LIST_ENTRY( item, MSIMEDIADISK, entry );
list_remove( &info->entry );
msi_free( info->volume_label );
diff --git a/dlls/msi/join.c b/dlls/msi/join.c
index a577aea..d06b33a 100644
--- a/dlls/msi/join.c
+++ b/dlls/msi/join.c
@@ -235,7 +235,7 @@ static UINT JOIN_delete( struct tagMSIVIEW *view )
LIST_FOR_EACH_SAFE(item, cursor, &jv->tables)
{
- JOINTABLE* table = LIST_ENTRY(item, JOINTABLE, entry);
+ JOINTABLE* table = WINE_LIST_ENTRY(item, JOINTABLE, entry);
list_remove(&table->entry);
table->view->ops->delete(table->view);
diff --git a/dlls/msi/source.c b/dlls/msi/source.c
index 0e752f5..7d0e43a 100644
--- a/dlls/msi/source.c
+++ b/dlls/msi/source.c
@@ -983,7 +983,7 @@ static void free_source_list(struct list *sourcelist)
{
while (!list_empty(sourcelist))
{
- media_info *info = LIST_ENTRY(list_head(sourcelist), media_info, entry);
+ media_info *info = WINE_LIST_ENTRY(list_head(sourcelist), media_info, entry);
list_remove(&info->entry);
msi_free(info->path);
msi_free(info);
diff --git a/dlls/msi/table.c b/dlls/msi/table.c
index cc40515..a8a6f9e 100644
--- a/dlls/msi/table.c
+++ b/dlls/msi/table.c
@@ -476,7 +476,7 @@ void free_cached_tables( MSIDATABASE *db )
{
while( !list_empty( &db->tables ) )
{
- MSITABLE *t = LIST_ENTRY( list_head( &db->tables ), MSITABLE, entry );
+ MSITABLE *t = WINE_LIST_ENTRY( list_head( &db->tables ), MSITABLE, entry );
list_remove( &t->entry );
free_table( t );
@@ -2906,7 +2906,7 @@ UINT msi_table_apply_transform( MSIDATABASE *db, IStorage *stg )
while ( !list_empty( &transforms ) )
{
- transform = LIST_ENTRY( list_head( &transforms ), TRANSFORMDATA, entry );
+ transform = WINE_LIST_ENTRY( list_head( &transforms ), TRANSFORMDATA, entry );
if ( lstrcmpW( transform->name, szColumns ) &&
lstrcmpW( transform->name, szTables ) &&
diff --git a/dlls/msxml3/dispex.c b/dlls/msxml3/dispex.c
index 529f9a4..b6d0b07 100644
--- a/dlls/msxml3/dispex.c
+++ b/dlls/msxml3/dispex.c
@@ -153,7 +153,7 @@ void release_typelib(void)
unsigned i;
while(!list_empty(&dispex_data_list)) {
- iter = LIST_ENTRY(list_head(&dispex_data_list), dispex_data_t, entry);
+ iter = WINE_LIST_ENTRY(list_head(&dispex_data_list), dispex_data_t, entry);
list_remove(&iter->entry);
for(i=0; i < iter->func_cnt; i++)
diff --git a/dlls/ntdll/directory.c b/dlls/ntdll/directory.c
index ecd9418..5869409 100644
--- a/dlls/ntdll/directory.c
+++ b/dlls/ntdll/directory.c
@@ -277,7 +277,7 @@ static NTSTATUS next_dir_in_queue( char *name )
struct list *head = list_head( &dir_queue );
if (head)
{
- struct dir_name *dir = LIST_ENTRY( head, struct dir_name, entry );
+ struct dir_name *dir = WINE_LIST_ENTRY( head, struct dir_name, entry );
strcpy( name, dir->name );
list_remove( &dir->entry );
RtlFreeHeap( GetProcessHeap(), 0, dir );
@@ -292,7 +292,7 @@ static void flush_dir_queue(void)
while ((head = list_head( &dir_queue )))
{
- struct dir_name *dir = LIST_ENTRY( head, struct dir_name, entry );
+ struct dir_name *dir = WINE_LIST_ENTRY( head, struct dir_name, entry );
list_remove( &dir->entry );
RtlFreeHeap( GetProcessHeap(), 0, dir );
}
diff --git a/dlls/ntdll/exception.c b/dlls/ntdll/exception.c
index 63fd281..de757d3 100644
--- a/dlls/ntdll/exception.c
+++ b/dlls/ntdll/exception.c
@@ -165,7 +165,7 @@ LONG call_vectored_handlers( EXCEPTION_RECORD *rec, CONTEXT *context )
RtlEnterCriticalSection( &vectored_handlers_section );
LIST_FOR_EACH( ptr, &vectored_handlers )
{
- VECTORED_HANDLER *handler = LIST_ENTRY( ptr, VECTORED_HANDLER, entry );
+ VECTORED_HANDLER *handler = WINE_LIST_ENTRY( ptr, VECTORED_HANDLER, entry );
TRACE( "calling handler at %p code=%x flags=%x\n",
handler->func, rec->ExceptionCode, rec->ExceptionFlags );
ret = handler->func( &except_ptrs );
@@ -234,7 +234,7 @@ ULONG WINAPI RtlRemoveVectoredExceptionHandler( PVOID handler )
RtlEnterCriticalSection( &vectored_handlers_section );
LIST_FOR_EACH( ptr, &vectored_handlers )
{
- VECTORED_HANDLER *curr_handler = LIST_ENTRY( ptr, VECTORED_HANDLER, entry );
+ VECTORED_HANDLER *curr_handler = WINE_LIST_ENTRY( ptr, VECTORED_HANDLER, entry );
if (curr_handler == handler)
{
list_remove( ptr );
diff --git a/dlls/ntdll/heap.c b/dlls/ntdll/heap.c
index adaf693..4b9087f 100644
--- a/dlls/ntdll/heap.c
+++ b/dlls/ntdll/heap.c
@@ -284,15 +284,15 @@ static void HEAP_Dump( HEAP *heap )
char *ptr;
DPRINTF( "Heap: %p\n", heap );
- DPRINTF( "Next: %p Sub-heaps:", LIST_ENTRY( heap->entry.next, HEAP, entry ) );
+ DPRINTF( "Next: %p Sub-heaps:", WINE_LIST_ENTRY( heap->entry.next, HEAP, entry ) );
LIST_FOR_EACH_ENTRY( subheap, &heap->subheap_list, SUBHEAP, entry ) DPRINTF( " %p", subheap );
DPRINTF( "\nFree lists:\n Block Stat Size Id\n" );
for (i = 0; i < HEAP_NB_FREE_LISTS; i++)
DPRINTF( "%p free %08lx prev=%p next=%p\n",
&heap->freeList[i].arena, HEAP_freeListSizes[i],
- LIST_ENTRY( heap->freeList[i].arena.entry.prev, ARENA_FREE, entry ),
- LIST_ENTRY( heap->freeList[i].arena.entry.next, ARENA_FREE, entry ));
+ WINE_LIST_ENTRY( heap->freeList[i].arena.entry.prev, ARENA_FREE, entry ),
+ WINE_LIST_ENTRY( heap->freeList[i].arena.entry.next, ARENA_FREE, entry ));
LIST_FOR_EACH_ENTRY( subheap, &heap->subheap_list, SUBHEAP, entry )
{
@@ -310,8 +310,8 @@ static void HEAP_Dump( HEAP *heap )
DPRINTF( "%p %08x free %08x prev=%p next=%p\n",
pArena, pArena->magic,
pArena->size & ARENA_SIZE_MASK,
- LIST_ENTRY( pArena->entry.prev, ARENA_FREE, entry ),
- LIST_ENTRY( pArena->entry.next, ARENA_FREE, entry ) );
+ WINE_LIST_ENTRY( pArena->entry.prev, ARENA_FREE, entry ),
+ WINE_LIST_ENTRY( pArena->entry.next, ARENA_FREE, entry ) );
ptr += sizeof(*pArena) + (pArena->size & ARENA_SIZE_MASK);
arenaSize += sizeof(ARENA_FREE);
freeSize += pArena->size & ARENA_SIZE_MASK;
@@ -900,7 +900,7 @@ static ARENA_FREE *HEAP_FindFreeBlock( HEAP *heap, SIZE_T size,
ptr = &pEntry->arena.entry;
while ((ptr = list_next( &heap->freeList[0].arena.entry, ptr )))
{
- ARENA_FREE *pArena = LIST_ENTRY( ptr, ARENA_FREE, entry );
+ ARENA_FREE *pArena = WINE_LIST_ENTRY( ptr, ARENA_FREE, entry );
SIZE_T arena_size = (pArena->size & ARENA_SIZE_MASK) +
sizeof(ARENA_FREE) - sizeof(ARENA_INUSE);
if (arena_size >= size)
@@ -1003,7 +1003,7 @@ static BOOL HEAP_ValidateFreeArena( SUBHEAP *subheap, ARENA_FREE *pArena )
return FALSE;
}
/* Check that next pointer is valid */
- next = LIST_ENTRY( pArena->entry.next, ARENA_FREE, entry );
+ next = WINE_LIST_ENTRY( pArena->entry.next, ARENA_FREE, entry );
if (!HEAP_IsValidArenaPtr( subheap->heap, next ))
{
ERR("Heap %p: bad next ptr %p for arena %p\n",
@@ -1018,7 +1018,7 @@ static BOOL HEAP_ValidateFreeArena( SUBHEAP *subheap, ARENA_FREE *pArena )
return FALSE;
}
/* Check that prev pointer is valid */
- prev = LIST_ENTRY( pArena->entry.prev, ARENA_FREE, entry );
+ prev = WINE_LIST_ENTRY( pArena->entry.prev, ARENA_FREE, entry );
if (!HEAP_IsValidArenaPtr( subheap->heap, prev ))
{
ERR("Heap %p: bad prev ptr %p for arena %p\n",
@@ -1878,7 +1878,7 @@ NTSTATUS WINAPI RtlWalkHeap( HANDLE heap, PVOID entry_ptr )
ret = STATUS_NO_MORE_ENTRIES;
goto HW_end;
}
- currentheap = LIST_ENTRY( next, SUBHEAP, entry );
+ currentheap = WINE_LIST_ENTRY( next, SUBHEAP, entry );
ptr = (char *)currentheap->base + currentheap->headerSize;
}
}
@@ -1956,7 +1956,7 @@ ULONG WINAPI RtlGetProcessHeaps( ULONG count, HANDLE *heaps )
{
*heaps++ = processHeap;
LIST_FOR_EACH( ptr, &processHeap->entry )
- *heaps++ = LIST_ENTRY( ptr, HEAP, entry );
+ *heaps++ = WINE_LIST_ENTRY( ptr, HEAP, entry );
}
RtlLeaveCriticalSection( &processHeap->critSection );
return total;
diff --git a/dlls/ntdll/threadpool.c b/dlls/ntdll/threadpool.c
index 31a1a56..bedffe6 100644
--- a/dlls/ntdll/threadpool.c
+++ b/dlls/ntdll/threadpool.c
@@ -96,7 +96,7 @@ static void WINAPI worker_thread_proc(void * param)
item = list_head(&work_item_list);
if (item)
{
- struct work_item *work_item_ptr = LIST_ENTRY(item, struct work_item, entry);
+ struct work_item *work_item_ptr = WINE_LIST_ENTRY(item, struct work_item, entry);
struct work_item work_item;
list_remove(&work_item_ptr->entry);
interlocked_dec(&num_work_items);
@@ -620,7 +620,7 @@ static void queue_add_timer(struct queue_timer *t, ULONGLONG time,
if (time != EXPIRE_NEVER)
LIST_FOR_EACH(ptr, &q->timers)
{
- struct queue_timer *cur = LIST_ENTRY(ptr, struct queue_timer, entry);
+ struct queue_timer *cur = WINE_LIST_ENTRY(ptr, struct queue_timer, entry);
if (time < cur->expire)
break;
}
@@ -649,7 +649,7 @@ static void queue_timer_expire(struct timer_queue *q)
RtlEnterCriticalSection(&q->cs);
if (list_head(&q->timers))
{
- t = LIST_ENTRY(list_head(&q->timers), struct queue_timer, entry);
+ t = WINE_LIST_ENTRY(list_head(&q->timers), struct queue_timer, entry);
if (!t->destroy && t->expire <= queue_current_time())
{
++t->runcount;
@@ -687,7 +687,7 @@ static ULONG queue_get_timeout(struct timer_queue *q)
RtlEnterCriticalSection(&q->cs);
if (list_head(&q->timers))
{
- t = LIST_ENTRY(list_head(&q->timers), struct queue_timer, entry);
+ t = WINE_LIST_ENTRY(list_head(&q->timers), struct queue_timer, entry);
assert(!t->destroy || t->expire == EXPIRE_NEVER);
if (t->expire != EXPIRE_NEVER)
diff --git a/dlls/ntdll/virtual.c b/dlls/ntdll/virtual.c
index 9731069..9da63bf 100644
--- a/dlls/ntdll/virtual.c
+++ b/dlls/ntdll/virtual.c
@@ -323,7 +323,7 @@ static void *find_free_area( void *base, void *end, size_t size, size_t mask, in
for (ptr = views_list.prev; ptr != &views_list; ptr = ptr->prev)
{
- struct file_view *view = LIST_ENTRY( ptr, struct file_view, entry );
+ struct file_view *view = WINE_LIST_ENTRY( ptr, struct file_view, entry );
if ((char *)view->base + view->size <= (char *)start) break;
if ((char *)view->base >= (char *)start + size) continue;
@@ -339,7 +339,7 @@ static void *find_free_area( void *base, void *end, size_t size, size_t mask, in
for (ptr = views_list.next; ptr != &views_list; ptr = ptr->next)
{
- struct file_view *view = LIST_ENTRY( ptr, struct file_view, entry );
+ struct file_view *view = WINE_LIST_ENTRY( ptr, struct file_view, entry );
if ((char *)view->base >= (char *)start + size) break;
if ((char *)view->base + view->size <= (char *)start) continue;
@@ -480,7 +480,7 @@ static NTSTATUS create_view( struct file_view **view_ret, void *base, size_t siz
LIST_FOR_EACH( ptr, &views_list )
{
- struct file_view *next = LIST_ENTRY( ptr, struct file_view, entry );
+ struct file_view *next = WINE_LIST_ENTRY( ptr, struct file_view, entry );
if (next->base > base) break;
}
list_add_before( ptr, &view->entry );
@@ -491,7 +491,7 @@ static NTSTATUS create_view( struct file_view **view_ret, void *base, size_t siz
if ((ptr = list_prev( &views_list, &view->entry )) != NULL)
{
- struct file_view *prev = LIST_ENTRY( ptr, struct file_view, entry );
+ struct file_view *prev = WINE_LIST_ENTRY( ptr, struct file_view, entry );
if ((char *)prev->base + prev->size > (char *)base)
{
TRACE( "overlapping prev view %p-%p for %p-%p\n",
@@ -503,7 +503,7 @@ static NTSTATUS create_view( struct file_view **view_ret, void *base, size_t siz
}
if ((ptr = list_next( &views_list, &view->entry )) != NULL)
{
- struct file_view *next = LIST_ENTRY( ptr, struct file_view, entry );
+ struct file_view *next = WINE_LIST_ENTRY( ptr, struct file_view, entry );
if ((char *)base + view->size > (char *)next->base)
{
TRACE( "overlapping next view %p-%p for %p-%p\n",
@@ -970,7 +970,7 @@ static NTSTATUS allocate_dos_memory( struct file_view **view, unsigned int vprot
if ((ptr = list_head( &views_list )))
{
- struct file_view *first_view = LIST_ENTRY( ptr, struct file_view, entry );
+ struct file_view *first_view = WINE_LIST_ENTRY( ptr, struct file_view, entry );
if (first_view->base < (void *)dosmem_size) return STATUS_CONFLICTING_ADDRESSES;
}
@@ -2121,7 +2121,7 @@ NTSTATUS WINAPI NtQueryVirtualMemory( HANDLE process, LPCVOID addr,
view = NULL;
break;
}
- view = LIST_ENTRY( ptr, struct file_view, entry );
+ view = WINE_LIST_ENTRY( ptr, struct file_view, entry );
if ((char *)view->base > base)
{
size = (char *)view->base - alloc_base;
diff --git a/dlls/ole32/compobj.c b/dlls/ole32/compobj.c
index 583a9cb..1b62619 100644
--- a/dlls/ole32/compobj.c
+++ b/dlls/ole32/compobj.c
@@ -596,7 +596,7 @@ DWORD apartment_release(struct apartment *apt)
LIST_FOR_EACH_SAFE(cursor, cursor2, &apt->stubmgrs)
{
- struct stub_manager *stubmgr = LIST_ENTRY(cursor, struct stub_manager, entry);
+ struct stub_manager *stubmgr = WINE_LIST_ENTRY(cursor, struct stub_manager, entry);
/* release the implicit reference given by the fact that the
* stub has external references (it must do since it is in the
* stub manager list in the apartment and all non-apartment users
@@ -608,7 +608,7 @@ DWORD apartment_release(struct apartment *apt)
LIST_FOR_EACH_SAFE(cursor, cursor2, &apt->psclsids)
{
struct registered_psclsid *registered_psclsid =
- LIST_ENTRY(cursor, struct registered_psclsid, entry);
+ WINE_LIST_ENTRY(cursor, struct registered_psclsid, entry);
list_remove(®istered_psclsid->entry);
HeapFree(GetProcessHeap(), 0, registered_psclsid);
@@ -629,7 +629,7 @@ DWORD apartment_release(struct apartment *apt)
* rest */
while ((cursor = list_head(&apt->loaded_dlls)))
{
- struct apartment_loaded_dll *apartment_loaded_dll = LIST_ENTRY(cursor, struct apartment_loaded_dll, entry);
+ struct apartment_loaded_dll *apartment_loaded_dll = WINE_LIST_ENTRY(cursor, struct apartment_loaded_dll, entry);
COMPOBJ_DllList_ReleaseRef(apartment_loaded_dll->dll, FALSE);
list_remove(cursor);
HeapFree(GetProcessHeap(), 0, apartment_loaded_dll);
@@ -657,7 +657,7 @@ APARTMENT *apartment_findfromoxid(OXID oxid, BOOL ref)
EnterCriticalSection(&csApartment);
LIST_FOR_EACH( cursor, &apts )
{
- struct apartment *apt = LIST_ENTRY( cursor, struct apartment, entry );
+ struct apartment *apt = WINE_LIST_ENTRY( cursor, struct apartment, entry );
if (apt->oxid == oxid)
{
result = apt;
@@ -681,7 +681,7 @@ APARTMENT *apartment_findfromtid(DWORD tid)
EnterCriticalSection(&csApartment);
LIST_FOR_EACH( cursor, &apts )
{
- struct apartment *apt = LIST_ENTRY( cursor, struct apartment, entry );
+ struct apartment *apt = WINE_LIST_ENTRY( cursor, struct apartment, entry );
if (apt->tid == tid)
{
result = apt;
@@ -723,7 +723,7 @@ static APARTMENT *apartment_find_multi_threaded(void)
LIST_FOR_EACH( cursor, &apts )
{
- struct apartment *apt = LIST_ENTRY( cursor, struct apartment, entry );
+ struct apartment *apt = WINE_LIST_ENTRY( cursor, struct apartment, entry );
if (apt->multi_threaded)
{
result = apt;
diff --git a/dlls/ole32/marshal.c b/dlls/ole32/marshal.c
index 54a3a87..5c1182d 100644
--- a/dlls/ole32/marshal.c
+++ b/dlls/ole32/marshal.c
@@ -280,7 +280,7 @@ static HRESULT WINAPI ClientIdentity_QueryMultipleInterfaces(IMultiQI *iface, UL
/* get the ipid of the first entry */
/* FIXME: should we implement ClientIdentity on the ifproxies instead
* of the proxy_manager so we use the correct ipid here? */
- ipid = &LIST_ENTRY(list_head(&This->interfaces), struct ifproxy, entry)->stdobjref.ipid;
+ ipid = &WINE_LIST_ENTRY(list_head(&This->interfaces), struct ifproxy, entry)->stdobjref.ipid;
/* get IRemUnknown proxy so we can communicate with the remote object */
hr = proxy_manager_get_remunknown(This, &remunk);
@@ -451,7 +451,7 @@ static HRESULT WINAPI Proxy_MarshalInterface(
/* get the ipid of the first entry */
/* FIXME: should we implement ClientIdentity on the ifproxies instead
* of the proxy_manager so we use the correct ipid here? */
- ipid = &LIST_ENTRY(list_head(&This->interfaces), struct ifproxy, entry)->stdobjref.ipid;
+ ipid = &WINE_LIST_ENTRY(list_head(&This->interfaces), struct ifproxy, entry)->stdobjref.ipid;
/* get IRemUnknown proxy so we can communicate with the remote object */
hr = proxy_manager_get_remunknown(This, &remunk);
@@ -942,7 +942,7 @@ static HRESULT proxy_manager_find_ifproxy(struct proxy_manager * This, REFIID ri
EnterCriticalSection(&This->cs);
LIST_FOR_EACH(cursor, &This->interfaces)
{
- struct ifproxy * ifproxy = LIST_ENTRY(cursor, struct ifproxy, entry);
+ struct ifproxy * ifproxy = WINE_LIST_ENTRY(cursor, struct ifproxy, entry);
if (IsEqualIID(riid, &ifproxy->iid))
{
*ifproxy_found = ifproxy;
@@ -972,7 +972,7 @@ static void proxy_manager_disconnect(struct proxy_manager * This)
{
LIST_FOR_EACH(cursor, &This->interfaces)
{
- struct ifproxy * ifproxy = LIST_ENTRY(cursor, struct ifproxy, entry);
+ struct ifproxy * ifproxy = WINE_LIST_ENTRY(cursor, struct ifproxy, entry);
ifproxy_disconnect(ifproxy);
}
}
@@ -1074,7 +1074,7 @@ static void proxy_manager_destroy(struct proxy_manager * This)
/* destroy all of the interface proxies */
while ((cursor = list_head(&This->interfaces)))
{
- struct ifproxy * ifproxy = LIST_ENTRY(cursor, struct ifproxy, entry);
+ struct ifproxy * ifproxy = WINE_LIST_ENTRY(cursor, struct ifproxy, entry);
ifproxy_destroy(ifproxy);
}
@@ -1100,7 +1100,7 @@ static BOOL find_proxy_manager(APARTMENT * apt, OXID oxid, OID oid, struct proxy
EnterCriticalSection(&apt->cs);
LIST_FOR_EACH(cursor, &apt->proxies)
{
- struct proxy_manager * proxy = LIST_ENTRY(cursor, struct proxy_manager, entry);
+ struct proxy_manager * proxy = WINE_LIST_ENTRY(cursor, struct proxy_manager, entry);
if ((oxid == proxy->oxid) && (oid == proxy->oid))
{
/* be careful of a race with ClientIdentity_Release, which would
@@ -1124,7 +1124,7 @@ HRESULT apartment_disconnectproxies(struct apartment *apt)
LIST_FOR_EACH(cursor, &apt->proxies)
{
- struct proxy_manager * proxy = LIST_ENTRY(cursor, struct proxy_manager, entry);
+ struct proxy_manager * proxy = WINE_LIST_ENTRY(cursor, struct proxy_manager, entry);
proxy_manager_disconnect(proxy);
}
diff --git a/dlls/ole32/moniker.c b/dlls/ole32/moniker.c
index a7c5a11..ff9a74c 100644
--- a/dlls/ole32/moniker.c
+++ b/dlls/ole32/moniker.c
@@ -344,7 +344,7 @@ RunningObjectTableImpl_Destroy(void)
/* free the ROT table memory */
LIST_FOR_EACH_SAFE(cursor, cursor2, &runningObjectTableInstance->rot)
{
- struct rot_entry *rot_entry = LIST_ENTRY(cursor, struct rot_entry, entry);
+ struct rot_entry *rot_entry = WINE_LIST_ENTRY(cursor, struct rot_entry, entry);
list_remove(&rot_entry->entry);
rot_entry_delete(rot_entry);
}
@@ -383,7 +383,7 @@ RunningObjectTableImpl_Release(IRunningObjectTable* iface)
struct list *cursor, *cursor2;
LIST_FOR_EACH_SAFE(cursor, cursor2, &This->rot)
{
- struct rot_entry *rot_entry = LIST_ENTRY(cursor, struct rot_entry, entry);
+ struct rot_entry *rot_entry = WINE_LIST_ENTRY(cursor, struct rot_entry, entry);
list_remove(&rot_entry->entry);
rot_entry_delete(rot_entry);
}
diff --git a/dlls/ole32/ole2.c b/dlls/ole32/ole2.c
index 6bf79fd..446e864 100644
--- a/dlls/ole32/ole2.c
+++ b/dlls/ole32/ole2.c
@@ -1908,7 +1908,7 @@ void OLEDD_UnInitialize(void)
*/
while (!list_empty(&targetListHead))
{
- DropTargetNode* curNode = LIST_ENTRY(list_head(&targetListHead), DropTargetNode, entry);
+ DropTargetNode* curNode = WINE_LIST_ENTRY(list_head(&targetListHead), DropTargetNode, entry);
OLEDD_FreeDropTarget(curNode, FALSE);
}
}
diff --git a/dlls/ole32/storage32.c b/dlls/ole32/storage32.c
index 39ed710..5256743 100644
--- a/dlls/ole32/storage32.c
+++ b/dlls/ole32/storage32.c
@@ -1934,14 +1934,14 @@ static void StorageBaseImpl_DeleteAll(StorageBaseImpl * stg)
StorageInternalImpl *childstg=NULL;
LIST_FOR_EACH_SAFE(cur, cur2, &stg->strmHead) {
- strm = LIST_ENTRY(cur,StgStreamImpl,StrmListEntry);
+ strm = WINE_LIST_ENTRY(cur,StgStreamImpl,StrmListEntry);
TRACE("Streams invalidated (stg=%p strm=%p next=%p prev=%p)\n", stg,strm,cur->next,cur->prev);
strm->parentStorage = NULL;
list_remove(cur);
}
LIST_FOR_EACH_SAFE(cur, cur2, &stg->storageHead) {
- childstg = LIST_ENTRY(cur,StorageInternalImpl,ParentListEntry);
+ childstg = WINE_LIST_ENTRY(cur,StorageInternalImpl,ParentListEntry);
StorageBaseImpl_Invalidate( &childstg->base );
}
diff --git a/dlls/ole32/stubmanager.c b/dlls/ole32/stubmanager.c
index f6b8bfa..b783438 100644
--- a/dlls/ole32/stubmanager.c
+++ b/dlls/ole32/stubmanager.c
@@ -134,7 +134,7 @@ static struct ifstub *stub_manager_ipid_to_ifstub(struct stub_manager *m, const
EnterCriticalSection(&m->lock);
LIST_FOR_EACH( cursor, &m->ifstubs )
{
- struct ifstub *ifstub = LIST_ENTRY( cursor, struct ifstub, entry );
+ struct ifstub *ifstub = WINE_LIST_ENTRY( cursor, struct ifstub, entry );
if (IsEqualGUID(ipid, &ifstub->ipid))
{
@@ -237,7 +237,7 @@ static void stub_manager_delete(struct stub_manager *m)
/* release every ifstub */
while ((cursor = list_head(&m->ifstubs)))
{
- struct ifstub *ifstub = LIST_ENTRY(cursor, struct ifstub, entry);
+ struct ifstub *ifstub = WINE_LIST_ENTRY(cursor, struct ifstub, entry);
stub_manager_delete_ifstub(m, ifstub);
}
@@ -299,7 +299,7 @@ struct stub_manager *get_stub_manager_from_object(APARTMENT *apt, void *object)
EnterCriticalSection(&apt->cs);
LIST_FOR_EACH( cursor, &apt->stubmgrs )
{
- struct stub_manager *m = LIST_ENTRY( cursor, struct stub_manager, entry );
+ struct stub_manager *m = WINE_LIST_ENTRY( cursor, struct stub_manager, entry );
if (m->object == object)
{
@@ -354,7 +354,7 @@ struct stub_manager *get_stub_manager(APARTMENT *apt, OID oid)
EnterCriticalSection(&apt->cs);
LIST_FOR_EACH( cursor, &apt->stubmgrs )
{
- struct stub_manager *m = LIST_ENTRY( cursor, struct stub_manager, entry );
+ struct stub_manager *m = WINE_LIST_ENTRY( cursor, struct stub_manager, entry );
if (m->oid == oid)
{
@@ -431,7 +431,7 @@ static struct stub_manager *get_stub_manager_from_ipid(APARTMENT *apt, const IPI
EnterCriticalSection(&apt->cs);
LIST_FOR_EACH( cursor, &apt->stubmgrs )
{
- struct stub_manager *m = LIST_ENTRY( cursor, struct stub_manager, entry );
+ struct stub_manager *m = WINE_LIST_ENTRY( cursor, struct stub_manager, entry );
if (stub_manager_ipid_to_ifstub(m, ipid))
{
diff --git a/dlls/pdh/pdh_main.c b/dlls/pdh/pdh_main.c
index 7f08c92..446c833 100644
--- a/dlls/pdh/pdh_main.c
+++ b/dlls/pdh/pdh_main.c
@@ -419,7 +419,7 @@ PDH_STATUS WINAPI PdhCloseQuery( PDH_HQUERY handle )
LIST_FOR_EACH_SAFE( item, next, &query->counters )
{
- struct counter *counter = LIST_ENTRY( item, struct counter, entry );
+ struct counter *counter = WINE_LIST_ENTRY( item, struct counter, entry );
list_remove( &counter->entry );
destroy_counter( counter );
@@ -439,7 +439,7 @@ static void collect_query_data( struct query *query )
LIST_FOR_EACH( item, &query->counters )
{
SYSTEMTIME time;
- struct counter *counter = LIST_ENTRY( item, struct counter, entry );
+ struct counter *counter = WINE_LIST_ENTRY( item, struct counter, entry );
counter->collect( counter );
@@ -591,7 +591,7 @@ PDH_STATUS WINAPI PdhCollectQueryDataWithTime( PDH_HQUERY handle, LONGLONG *time
collect_query_data( query );
item = list_head( &query->counters );
- counter = LIST_ENTRY( item, struct counter, entry );
+ counter = WINE_LIST_ENTRY( item, struct counter, entry );
*timestamp = ((LONGLONG)counter->stamp.dwHighDateTime << 32) | counter->stamp.dwLowDateTime;
diff --git a/dlls/quartz/memallocator.c b/dlls/quartz/memallocator.c
index 7f799c9..6b9d0b9 100644
--- a/dlls/quartz/memallocator.c
+++ b/dlls/quartz/memallocator.c
@@ -323,7 +323,7 @@ static HRESULT WINAPI BaseMemAllocator_GetBuffer(IMemAllocator * iface, IMediaSa
list_remove(free);
list_add_head(&This->used_list, free);
- *pSample = (IMediaSample *)LIST_ENTRY(free, StdMediaSample2, listentry);
+ *pSample = (IMediaSample *)WINE_LIST_ENTRY(free, StdMediaSample2, listentry);
assert(((StdMediaSample2 *)*pSample)->ref == 0);
@@ -827,7 +827,7 @@ static HRESULT StdMemAllocator_Free(IMemAllocator * iface)
{
StdMediaSample2 *pSample;
list_remove(cursor);
- pSample = LIST_ENTRY(cursor, StdMediaSample2, listentry);
+ pSample = WINE_LIST_ENTRY(cursor, StdMediaSample2, listentry);
pSample->pParent = NULL;
}
}
@@ -835,7 +835,7 @@ static HRESULT StdMemAllocator_Free(IMemAllocator * iface)
while ((cursor = list_head(&This->base.free_list)) != NULL)
{
list_remove(cursor);
- StdMediaSample2_Delete(LIST_ENTRY(cursor, StdMediaSample2, listentry));
+ StdMediaSample2_Delete(WINE_LIST_ENTRY(cursor, StdMediaSample2, listentry));
}
/* free memory */
diff --git a/dlls/urlmon/urlmon_main.c b/dlls/urlmon/urlmon_main.c
index 272884e..d7c178f 100644
--- a/dlls/urlmon/urlmon_main.c
+++ b/dlls/urlmon/urlmon_main.c
@@ -90,7 +90,7 @@ static void free_tls_list(void)
return;
while(!list_empty(&tls_list)) {
- data = LIST_ENTRY(list_head(&tls_list), tls_data_t, entry);
+ data = WINE_LIST_ENTRY(list_head(&tls_list), tls_data_t, entry);
list_remove(&data->entry);
heap_free(data);
}
diff --git a/dlls/user.exe16/user.c b/dlls/user.exe16/user.c
index 0b321b7..b021d14 100644
--- a/dlls/user.exe16/user.c
+++ b/dlls/user.exe16/user.c
@@ -379,7 +379,7 @@ static void free_clipboard_formats(void)
while ((head = list_head( &clipboard_formats )))
{
- struct clipboard_format *fmt = LIST_ENTRY( head, struct clipboard_format, entry );
+ struct clipboard_format *fmt = WINE_LIST_ENTRY( head, struct clipboard_format, entry );
list_remove( &fmt->entry );
GlobalFree16( fmt->data );
HeapFree( GetProcessHeap(), 0, fmt );
diff --git a/dlls/user32/class.c b/dlls/user32/class.c
index 36315b0..cd630a3 100644
--- a/dlls/user32/class.c
+++ b/dlls/user32/class.c
@@ -269,7 +269,7 @@ static CLASS *CLASS_FindClass( LPCWSTR name, HINSTANCE hinstance )
LIST_FOR_EACH( ptr, &class_list )
{
- CLASS *class = LIST_ENTRY( ptr, CLASS, entry );
+ CLASS *class = WINE_LIST_ENTRY( ptr, CLASS, entry );
if (atom)
{
if (class->atomName != atom) continue;
diff --git a/dlls/windowscodecs/info.c b/dlls/windowscodecs/info.c
index f909d3a..93746c6 100644
--- a/dlls/windowscodecs/info.c
+++ b/dlls/windowscodecs/info.c
@@ -805,7 +805,7 @@ static HRESULT WINAPI ComponentEnum_Next(IEnumUnknown *iface, ULONG celt,
*pceltFetched = num_fetched;
return S_FALSE;
}
- item = LIST_ENTRY(This->cursor, ComponentEnumItem, entry);
+ item = WINE_LIST_ENTRY(This->cursor, ComponentEnumItem, entry);
IUnknown_AddRef(item->unk);
rgelt[num_fetched] = item->unk;
num_fetched++;
diff --git a/dlls/wined3d/arb_program_shader.c b/dlls/wined3d/arb_program_shader.c
index 48f0e41..05da22f 100644
--- a/dlls/wined3d/arb_program_shader.c
+++ b/dlls/wined3d/arb_program_shader.c
@@ -2615,7 +2615,7 @@ static void shader_hw_loop(const struct wined3d_shader_instruction *ins)
{
struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
struct list *e = list_head(&priv->control_frames);
- struct control_frame *control_frame = LIST_ENTRY(e, struct control_frame, entry);
+ struct control_frame *control_frame = WINE_LIST_ENTRY(e, struct control_frame, entry);
if(priv->loop_depth > 1) shader_addline(buffer, "PUSHA aL;\n");
/* The constant loader makes sure to load -1 into iX.w */
@@ -2642,7 +2642,7 @@ static void shader_hw_rep(const struct wined3d_shader_instruction *ins)
{
struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
struct list *e = list_head(&priv->control_frames);
- struct control_frame *control_frame = LIST_ENTRY(e, struct control_frame, entry);
+ struct control_frame *control_frame = WINE_LIST_ENTRY(e, struct control_frame, entry);
if(priv->loop_depth > 1) shader_addline(buffer, "PUSHA aL;\n");
@@ -2665,7 +2665,7 @@ static void shader_hw_endloop(const struct wined3d_shader_instruction *ins)
{
struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
struct list *e = list_head(&priv->control_frames);
- struct control_frame *control_frame = LIST_ENTRY(e, struct control_frame, entry);
+ struct control_frame *control_frame = WINE_LIST_ENTRY(e, struct control_frame, entry);
shader_addline(buffer, "ARAC aL.xy, aL;\n");
shader_addline(buffer, "BRA loop_%u_start (GT.x);\n", control_frame->no.loop);
@@ -2688,7 +2688,7 @@ static void shader_hw_endrep(const struct wined3d_shader_instruction *ins)
{
struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
struct list *e = list_head(&priv->control_frames);
- struct control_frame *control_frame = LIST_ENTRY(e, struct control_frame, entry);
+ struct control_frame *control_frame = WINE_LIST_ENTRY(e, struct control_frame, entry);
shader_addline(buffer, "ARAC aL.xy, aL;\n");
shader_addline(buffer, "BRA loop_%u_start (GT.x);\n", control_frame->no.loop);
@@ -2794,7 +2794,7 @@ static void shader_hw_ifc(const struct wined3d_shader_instruction *ins)
struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
struct list *e = list_head(&priv->control_frames);
- struct control_frame *control_frame = LIST_ENTRY(e, struct control_frame, entry);
+ struct control_frame *control_frame = WINE_LIST_ENTRY(e, struct control_frame, entry);
const char *comp;
char src_name0[50];
char src_name1[50];
@@ -2823,7 +2823,7 @@ static void shader_hw_else(const struct wined3d_shader_instruction *ins)
struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
struct list *e = list_head(&priv->control_frames);
- struct control_frame *control_frame = LIST_ENTRY(e, struct control_frame, entry);
+ struct control_frame *control_frame = WINE_LIST_ENTRY(e, struct control_frame, entry);
BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
if(vshader)
@@ -2843,7 +2843,7 @@ static void shader_hw_endif(const struct wined3d_shader_instruction *ins)
struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
struct list *e = list_head(&priv->control_frames);
- struct control_frame *control_frame = LIST_ENTRY(e, struct control_frame, entry);
+ struct control_frame *control_frame = WINE_LIST_ENTRY(e, struct control_frame, entry);
BOOL vshader = shader_is_vshader_version(ins->ctx->reg_maps->shader_version.type);
if(vshader)
@@ -4972,7 +4972,7 @@ static void shader_arb_handle_instruction(const struct wined3d_shader_instructio
else
{
struct list *e = list_head(&priv->control_frames);
- control_frame = LIST_ENTRY(e, struct control_frame, entry);
+ control_frame = WINE_LIST_ENTRY(e, struct control_frame, entry);
list_remove(&control_frame->entry);
if(control_frame->outer_loop)
@@ -5076,7 +5076,7 @@ static void shader_arb_handle_instruction(const struct wined3d_shader_instructio
else if(ins->handler_idx == WINED3DSIH_ELSE)
{
struct list *e = list_head(&priv->control_frames);
- control_frame = LIST_ENTRY(e, struct control_frame, entry);
+ control_frame = WINE_LIST_ENTRY(e, struct control_frame, entry);
if(control_frame->type == IF)
{
@@ -5094,7 +5094,7 @@ static void shader_arb_handle_instruction(const struct wined3d_shader_instructio
else if(ins->handler_idx == WINED3DSIH_ENDIF)
{
struct list *e = list_head(&priv->control_frames);
- control_frame = LIST_ENTRY(e, struct control_frame, entry);
+ control_frame = WINE_LIST_ENTRY(e, struct control_frame, entry);
if(control_frame->type == IF)
{
@@ -5122,7 +5122,7 @@ static void shader_arb_handle_instruction(const struct wined3d_shader_instructio
if(ins->handler_idx == WINED3DSIH_ENDLOOP || ins->handler_idx == WINED3DSIH_ENDREP)
{
struct list *e = list_head(&priv->control_frames);
- control_frame = LIST_ENTRY(e, struct control_frame, entry);
+ control_frame = WINE_LIST_ENTRY(e, struct control_frame, entry);
list_remove(&control_frame->entry);
HeapFree(GetProcessHeap(), 0, control_frame);
priv->loop_depth--;
@@ -5131,7 +5131,7 @@ static void shader_arb_handle_instruction(const struct wined3d_shader_instructio
{
/* Non-ifc ENDIFs don't reach that place because of the return in the if block above */
struct list *e = list_head(&priv->control_frames);
- control_frame = LIST_ENTRY(e, struct control_frame, entry);
+ control_frame = WINE_LIST_ENTRY(e, struct control_frame, entry);
list_remove(&control_frame->entry);
HeapFree(GetProcessHeap(), 0, control_frame);
}
diff --git a/dlls/wined3d/baseshader.c b/dlls/wined3d/baseshader.c
index 2ec6858..be2918a 100644
--- a/dlls/wined3d/baseshader.c
+++ b/dlls/wined3d/baseshader.c
@@ -245,7 +245,7 @@ static void shader_delete_constant_list(struct list* clist) {
ptr = list_head(clist);
while (ptr) {
- constant = LIST_ENTRY(ptr, struct local_constant, entry);
+ constant = WINE_LIST_ENTRY(ptr, struct local_constant, entry);
ptr = list_next(clist, ptr);
HeapFree(GetProcessHeap(), 0, constant);
}
diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c
index 2aec7d6..691ae06 100644
--- a/dlls/wined3d/context.c
+++ b/dlls/wined3d/context.c
@@ -387,7 +387,7 @@ static struct fbo_entry *context_find_fbo_entry(struct wined3d_context *context)
}
else
{
- entry = LIST_ENTRY(list_tail(&context->fbo_list), struct fbo_entry, entry);
+ entry = WINE_LIST_ENTRY(list_tail(&context->fbo_list), struct fbo_entry, entry);
context_reuse_fbo_entry(context, entry);
list_remove(&entry->entry);
list_add_head(&context->fbo_list, &entry->entry);
diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c
index 34495d3..97fde19 100644
--- a/dlls/wined3d/device.c
+++ b/dlls/wined3d/device.c
@@ -1658,7 +1658,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_Uninit3D(IWineD3DDevice *iface,
struct list *e1, *e2;
struct WineD3DRectPatch *patch;
LIST_FOR_EACH_SAFE(e1, e2, &This->patches[i]) {
- patch = LIST_ENTRY(e1, struct WineD3DRectPatch, entry);
+ patch = WINE_LIST_ENTRY(e1, struct WineD3DRectPatch, entry);
IWineD3DDevice_DeletePatch(iface, patch->Handle);
}
}
@@ -2154,7 +2154,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetLight(IWineD3DDevice *iface, DWORD I
LIST_FOR_EACH(e, &This->updateStateBlock->lightMap[Hi])
{
- object = LIST_ENTRY(e, struct wined3d_light_info, entry);
+ object = WINE_LIST_ENTRY(e, struct wined3d_light_info, entry);
if(object->OriginalIndex == Index) break;
object = NULL;
}
@@ -2266,7 +2266,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_GetLight(IWineD3DDevice *iface, DWORD I
LIST_FOR_EACH(e, &This->stateBlock->lightMap[Hi])
{
- lightInfo = LIST_ENTRY(e, struct wined3d_light_info, entry);
+ lightInfo = WINE_LIST_ENTRY(e, struct wined3d_light_info, entry);
if(lightInfo->OriginalIndex == Index) break;
lightInfo = NULL;
}
@@ -2294,7 +2294,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetLightEnable(IWineD3DDevice *iface, D
LIST_FOR_EACH(e, &This->updateStateBlock->lightMap[Hi])
{
- lightInfo = LIST_ENTRY(e, struct wined3d_light_info, entry);
+ lightInfo = WINE_LIST_ENTRY(e, struct wined3d_light_info, entry);
if(lightInfo->OriginalIndex == Index) break;
lightInfo = NULL;
}
@@ -2309,7 +2309,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_SetLightEnable(IWineD3DDevice *iface, D
/* Search for it again! Should be fairly quick as near head of list */
LIST_FOR_EACH(e, &This->updateStateBlock->lightMap[Hi])
{
- lightInfo = LIST_ENTRY(e, struct wined3d_light_info, entry);
+ lightInfo = WINE_LIST_ENTRY(e, struct wined3d_light_info, entry);
if(lightInfo->OriginalIndex == Index) break;
lightInfo = NULL;
}
@@ -2378,7 +2378,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_GetLightEnable(IWineD3DDevice *iface, D
LIST_FOR_EACH(e, &This->stateBlock->lightMap[Hi])
{
- lightInfo = LIST_ENTRY(e, struct wined3d_light_info, entry);
+ lightInfo = WINE_LIST_ENTRY(e, struct wined3d_light_info, entry);
if(lightInfo->OriginalIndex == Index) break;
lightInfo = NULL;
}
@@ -5220,7 +5220,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_DrawRectPatch(IWineD3DDevice *iface, UI
i = PATCHMAP_HASHFUNC(Handle);
found = FALSE;
LIST_FOR_EACH(e, &This->patches[i]) {
- patch = LIST_ENTRY(e, struct WineD3DRectPatch, entry);
+ patch = WINE_LIST_ENTRY(e, struct WineD3DRectPatch, entry);
if(patch->Handle == Handle) {
found = TRUE;
break;
@@ -5306,7 +5306,7 @@ static HRESULT WINAPI IWineD3DDeviceImpl_DeletePatch(IWineD3DDevice *iface, UINT
i = PATCHMAP_HASHFUNC(Handle);
LIST_FOR_EACH(e, &This->patches[i]) {
- patch = LIST_ENTRY(e, struct WineD3DRectPatch, entry);
+ patch = WINE_LIST_ENTRY(e, struct WineD3DRectPatch, entry);
if(patch->Handle == Handle) {
TRACE("Deleting patch %p\n", patch);
list_remove(&patch->entry);
diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c
index 7392dc7..259ac82 100644
--- a/dlls/wined3d/glsl_shader.c
+++ b/dlls/wined3d/glsl_shader.c
@@ -482,7 +482,7 @@ static void shader_glsl_load_constantsI(IWineD3DBaseShaderImpl *This, const stru
/* Load immediate constants */
ptr = list_head(&This->baseShader.constantsI);
while (ptr) {
- const struct local_constant *lconst = LIST_ENTRY(ptr, const struct local_constant, entry);
+ const struct local_constant *lconst = WINE_LIST_ENTRY(ptr, const struct local_constant, entry);
unsigned int idx = lconst->idx;
const GLint *values = (const GLint *)lconst->value;
@@ -551,7 +551,7 @@ static void shader_glsl_load_constantsB(IWineD3DBaseShaderImpl *This, const stru
/* Load immediate constants */
ptr = list_head(&This->baseShader.constantsB);
while (ptr) {
- const struct local_constant *lconst = LIST_ENTRY(ptr, const struct local_constant, entry);
+ const struct local_constant *lconst = WINE_LIST_ENTRY(ptr, const struct local_constant, entry);
unsigned int idx = lconst->idx;
const GLint *values = (const GLint *)lconst->value;
diff --git a/dlls/wined3d/resource.c b/dlls/wined3d/resource.c
index b867586..19a09f0 100644
--- a/dlls/wined3d/resource.c
+++ b/dlls/wined3d/resource.c
@@ -91,7 +91,7 @@ void resource_cleanup(IWineD3DResource *iface)
}
LIST_FOR_EACH_SAFE(e1, e2, &This->resource.privateData) {
- data = LIST_ENTRY(e1, PrivateData, entry);
+ data = WINE_LIST_ENTRY(e1, PrivateData, entry);
hr = resource_free_private_data(iface, &data->tag);
if(hr != WINED3D_OK) {
ERR("Failed to free private data when destroying resource %p, hr = %08x\n", This, hr);
@@ -113,7 +113,7 @@ static PrivateData* resource_find_private_data(IWineD3DResourceImpl *This, REFGU
TRACE("Searching for private data %s\n", debugstr_guid(tag));
LIST_FOR_EACH(entry, &This->resource.privateData)
{
- data = LIST_ENTRY(entry, PrivateData, entry);
+ data = WINE_LIST_ENTRY(entry, PrivateData, entry);
if (IsEqualGUID(&data->tag, tag)) {
TRACE("Found %p\n", data);
return data;
diff --git a/dlls/wined3d/stateblock.c b/dlls/wined3d/stateblock.c
index 48f9eac..53149b1 100644
--- a/dlls/wined3d/stateblock.c
+++ b/dlls/wined3d/stateblock.c
@@ -515,7 +515,7 @@ static ULONG WINAPI IWineD3DStateBlockImpl_Release(IWineD3DStateBlock *iface) {
struct list *e1, *e2;
LIST_FOR_EACH_SAFE(e1, e2, &This->lightMap[counter])
{
- struct wined3d_light_info *light = LIST_ENTRY(e1, struct wined3d_light_info, entry);
+ struct wined3d_light_info *light = WINE_LIST_ENTRY(e1, struct wined3d_light_info, entry);
list_remove(&light->entry);
HeapFree(GetProcessHeap(), 0, light);
}
@@ -546,11 +546,11 @@ static void record_lights(IWineD3DStateBlockImpl *This, const IWineD3DStateBlock
struct list *e, *f;
LIST_FOR_EACH(e, &This->lightMap[i]) {
BOOL updated = FALSE;
- struct wined3d_light_info *src = LIST_ENTRY(e, struct wined3d_light_info, entry), *realLight;
+ struct wined3d_light_info *src = WINE_LIST_ENTRY(e, struct wined3d_light_info, entry), *realLight;
/* Look up the light in the destination */
LIST_FOR_EACH(f, &targetStateBlock->lightMap[i]) {
- realLight = LIST_ENTRY(f, struct wined3d_light_info, entry);
+ realLight = WINE_LIST_ENTRY(f, struct wined3d_light_info, entry);
if (realLight->OriginalIndex == src->OriginalIndex)
{
src->OriginalParms = realLight->OriginalParms;
@@ -874,7 +874,7 @@ static void apply_lights(IWineD3DDevice *pDevice, const IWineD3DStateBlockImpl *
LIST_FOR_EACH(e, &This->lightMap[i])
{
- const struct wined3d_light_info *light = LIST_ENTRY(e, struct wined3d_light_info, entry);
+ const struct wined3d_light_info *light = WINE_LIST_ENTRY(e, struct wined3d_light_info, entry);
IWineD3DDevice_SetLight(pDevice, light->OriginalIndex, &light->OriginalParms);
IWineD3DDevice_SetLightEnable(pDevice, light->OriginalIndex, light->glIndex != -1);
diff --git a/dlls/wineps.drv/ppd.c b/dlls/wineps.drv/ppd.c
index e29bbc9..bbec5ba 100644
--- a/dlls/wineps.drv/ppd.c
+++ b/dlls/wineps.drv/ppd.c
@@ -955,7 +955,7 @@ PPD *PSDRV_ParsePPD(char *fname)
HeapFree(PSDRV_Heap, 0, default_pagesize);
}
if(!ppd->DefaultPageSize) {
- ppd->DefaultPageSize = LIST_ENTRY(list_head(&ppd->PageSizes), PAGESIZE, entry);
+ ppd->DefaultPageSize = WINE_LIST_ENTRY(list_head(&ppd->PageSizes), PAGESIZE, entry);
TRACE("Setting DefaultPageSize to first in list\n");
}
diff --git a/dlls/winex11.drv/dib.c b/dlls/winex11.drv/dib.c
index 587c7c7..f5a9365 100644
--- a/dlls/winex11.drv/dib.c
+++ b/dlls/winex11.drv/dib.c
@@ -4419,7 +4419,7 @@ static LONG CALLBACK X11DRV_DIB_FaultHandler( PEXCEPTION_POINTERS ep )
EnterCriticalSection(&dibs_cs);
LIST_FOR_EACH( ptr, &dibs_list )
{
- physBitmap = LIST_ENTRY( ptr, X_PHYSBITMAP, entry );
+ physBitmap = WINE_LIST_ENTRY( ptr, X_PHYSBITMAP, entry );
if ((physBitmap->base <= addr) &&
(addr < physBitmap->base + ((physBitmap->size + pagemask) & ~pagemask)))
{
diff --git a/dlls/winhttp/cookie.c b/dlls/winhttp/cookie.c
index af881ea..bfff9fa 100644
--- a/dlls/winhttp/cookie.c
+++ b/dlls/winhttp/cookie.c
@@ -53,7 +53,7 @@ static cookie_t *find_cookie( domain_t *domain, const WCHAR *path, const WCHAR *
LIST_FOR_EACH( item, &domain->cookies )
{
- cookie = LIST_ENTRY( item, cookie_t, entry );
+ cookie = WINE_LIST_ENTRY( item, cookie_t, entry );
if (!strcmpW( cookie->path, path ) && !strcmpiW( cookie->name, name ))
{
TRACE("found %s=%s\n", debugstr_w(cookie->name), debugstr_w(cookie->value));
@@ -93,7 +93,7 @@ void delete_domain( domain_t *domain )
LIST_FOR_EACH_SAFE( item, next, &domain->cookies )
{
- cookie = LIST_ENTRY( item, cookie_t, entry );
+ cookie = WINE_LIST_ENTRY( item, cookie_t, entry );
delete_cookie( cookie );
}
@@ -110,7 +110,7 @@ static BOOL add_cookie( session_t *session, cookie_t *cookie, WCHAR *domain_name
LIST_FOR_EACH( item, &session->cookie_cache )
{
- domain = LIST_ENTRY( item, domain_t, entry );
+ domain = WINE_LIST_ENTRY( item, domain_t, entry );
if (domain_match( domain_name, domain, FALSE )) break;
domain = NULL;
}
@@ -244,7 +244,7 @@ BOOL add_cookie_headers( request_t *request )
LIST_FOR_EACH( domain_cursor, &session->cookie_cache )
{
- domain_t *domain = LIST_ENTRY( domain_cursor, domain_t, entry );
+ domain_t *domain = WINE_LIST_ENTRY( domain_cursor, domain_t, entry );
if (domain_match( request->connect->servername, domain, TRUE ))
{
struct list *cookie_cursor;
@@ -252,7 +252,7 @@ BOOL add_cookie_headers( request_t *request )
LIST_FOR_EACH( cookie_cursor, &domain->cookies )
{
- cookie_t *cookie = LIST_ENTRY( cookie_cursor, cookie_t, entry );
+ cookie_t *cookie = WINE_LIST_ENTRY( cookie_cursor, cookie_t, entry );
TRACE("comparing path %s with %s\n", debugstr_w(request->path), debugstr_w(cookie->path));
diff --git a/dlls/winhttp/session.c b/dlls/winhttp/session.c
index 9992e5b..814f637 100644
--- a/dlls/winhttp/session.c
+++ b/dlls/winhttp/session.c
@@ -78,7 +78,7 @@ static void session_destroy( object_header_t *hdr )
LIST_FOR_EACH_SAFE( item, next, &session->cookie_cache )
{
- domain = LIST_ENTRY( item, domain_t, entry );
+ domain = WINE_LIST_ENTRY( item, domain_t, entry );
delete_domain( domain );
}
heap_free( session->agent );
diff --git a/dlls/wininet/cookie.c b/dlls/wininet/cookie.c
index 75cf049..9c505e0 100644
--- a/dlls/wininet/cookie.c
+++ b/dlls/wininet/cookie.c
@@ -114,7 +114,7 @@ static cookie *COOKIE_findCookie(cookie_domain *domain, LPCWSTR lpszCookieName)
LIST_FOR_EACH(cursor, &domain->cookie_list)
{
- cookie *searchCookie = LIST_ENTRY(cursor, cookie, entry);
+ cookie *searchCookie = WINE_LIST_ENTRY(cursor, cookie, entry);
BOOL candidate = TRUE;
if (candidate && lpszCookieName)
{
@@ -248,7 +248,7 @@ static void COOKIE_deleteDomain(cookie_domain *deadDomain)
struct list * cursor;
while ((cursor = list_tail(&deadDomain->cookie_list)))
{
- COOKIE_deleteCookie(LIST_ENTRY(cursor, cookie, entry), FALSE);
+ COOKIE_deleteCookie(WINE_LIST_ENTRY(cursor, cookie, entry), FALSE);
list_remove(cursor);
}
@@ -299,7 +299,7 @@ BOOL WINAPI InternetGetCookieW(LPCWSTR lpszUrl, LPCWSTR lpszCookieName,
LIST_FOR_EACH(cursor, &domain_list)
{
- cookie_domain *cookiesDomain = LIST_ENTRY(cursor, cookie_domain, entry);
+ cookie_domain *cookiesDomain = WINE_LIST_ENTRY(cursor, cookie_domain, entry);
if (COOKIE_matchDomain(hostName, path, cookiesDomain, TRUE))
{
struct list * cursor;
@@ -308,7 +308,7 @@ BOOL WINAPI InternetGetCookieW(LPCWSTR lpszUrl, LPCWSTR lpszCookieName,
LIST_FOR_EACH(cursor, &cookiesDomain->cookie_list)
{
- cookie *thisCookie = LIST_ENTRY(cursor, cookie, entry);
+ cookie *thisCookie = WINE_LIST_ENTRY(cursor, cookie, entry);
/* check for expiry */
if ((thisCookie->expiry.dwLowDateTime != 0 || thisCookie->expiry.dwHighDateTime != 0) && CompareFileTime(&tm,&thisCookie->expiry) > 0)
{
@@ -513,7 +513,7 @@ static BOOL set_cookie(LPCWSTR domain, LPCWSTR path, LPCWSTR cookie_name, LPCWST
LIST_FOR_EACH(cursor, &domain_list)
{
- thisCookieDomain = LIST_ENTRY(cursor, cookie_domain, entry);
+ thisCookieDomain = WINE_LIST_ENTRY(cursor, cookie_domain, entry);
if (COOKIE_matchDomain(domain, path, thisCookieDomain, FALSE))
break;
thisCookieDomain = NULL;
diff --git a/dlls/wininet/http.c b/dlls/wininet/http.c
index 5b1bb22..3af7dff 100644
--- a/dlls/wininet/http.c
+++ b/dlls/wininet/http.c
@@ -599,7 +599,7 @@ static void cache_basic_authorization(LPWSTR host, LPWSTR realm, LPSTR auth_data
EnterCriticalSection(&authcache_cs);
LIST_FOR_EACH(cursor, &basicAuthorizationCache)
{
- authorizationData *check = LIST_ENTRY(cursor,authorizationData,entry);
+ authorizationData *check = WINE_LIST_ENTRY(cursor,authorizationData,entry);
if (!strcmpiW(host,check->lpszwHost) && !strcmpW(realm,check->lpszwRealm))
{
ad = check;
diff --git a/dlls/wininet/urlcache.c b/dlls/wininet/urlcache.c
index 29d26ab..56b5b02 100644
--- a/dlls/wininet/urlcache.c
+++ b/dlls/wininet/urlcache.c
@@ -580,7 +580,7 @@ void URLCacheContainers_DeleteAll(void)
{
while(!list_empty(&UrlContainers))
URLCacheContainer_DeleteContainer(
- LIST_ENTRY(list_head(&UrlContainers), URLCACHECONTAINER, entry)
+ WINE_LIST_ENTRY(list_head(&UrlContainers), URLCACHECONTAINER, entry)
);
}
diff --git a/dlls/winmm/time.c b/dlls/winmm/time.c
index 85577c2..8349d4f 100644
--- a/dlls/winmm/time.c
+++ b/dlls/winmm/time.c
@@ -148,7 +148,7 @@ static int TIME_MMSysTimeCallback(void)
break;
}
- timer = LIST_ENTRY( ptr, WINE_TIMERENTRY, entry );
+ timer = WINE_LIST_ENTRY( ptr, WINE_TIMERENTRY, entry );
delta_time = timer->dwTriggerTime - GetTickCount();
if (delta_time > 0) break;
diff --git a/dlls/winspool.drv/info.c b/dlls/winspool.drv/info.c
index 4993a78..49f9a09 100644
--- a/dlls/winspool.drv/info.c
+++ b/dlls/winspool.drv/info.c
@@ -2658,7 +2658,7 @@ BOOL WINAPI ClosePrinter(HANDLE hPrinter)
{
LIST_FOR_EACH_SAFE(cursor, cursor2, &printer->queue->jobs)
{
- job_t *job = LIST_ENTRY(cursor, job_t, entry);
+ job_t *job = WINE_LIST_ENTRY(cursor, job_t, entry);
ScheduleJob(hPrinter, job->job_id);
}
HeapFree(GetProcessHeap(), 0, printer->queue);
@@ -7419,7 +7419,7 @@ BOOL WINAPI ScheduleJob( HANDLE hPrinter, DWORD dwJobID )
LIST_FOR_EACH_SAFE(cursor, cursor2, &printer->queue->jobs)
{
- job_t *job = LIST_ENTRY(cursor, job_t, entry);
+ job_t *job = WINE_LIST_ENTRY(cursor, job_t, entry);
HANDLE hf;
if(job->job_id != dwJobID) continue;
diff --git a/include/wine/list.h b/include/wine/list.h
index da3ce91..ca1f57c 100644
--- a/include/wine/list.h
+++ b/include/wine/list.h
@@ -184,17 +184,17 @@ static inline void list_move_head( struct list *dst, struct list *src )
/* iterate through the list using a list entry */
#define LIST_FOR_EACH_ENTRY(elem, list, type, field) \
- for ((elem) = LIST_ENTRY((list)->next, type, field); \
+ for ((elem) = WINE_LIST_ENTRY((list)->next, type, field); \
&(elem)->field != (list); \
- (elem) = LIST_ENTRY((elem)->field.next, type, field))
+ (elem) = WINE_LIST_ENTRY((elem)->field.next, type, field))
/* iterate through the list using a list entry, with safety against removal */
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field) \
- for ((cursor) = LIST_ENTRY((list)->next, type, field), \
- (cursor2) = LIST_ENTRY((cursor)->field.next, type, field); \
+ for ((cursor) = WINE_LIST_ENTRY((list)->next, type, field), \
+ (cursor2) = WINE_LIST_ENTRY((cursor)->field.next, type, field); \
&(cursor)->field != (list); \
(cursor) = (cursor2), \
- (cursor2) = LIST_ENTRY((cursor)->field.next, type, field))
+ (cursor2) = WINE_LIST_ENTRY((cursor)->field.next, type, field))
/* iterate through the list in reverse order */
#define LIST_FOR_EACH_REV(cursor,list) \
@@ -208,25 +208,24 @@ static inline void list_move_head( struct list *dst, struct list *src )
/* iterate through the list in reverse order using a list entry */
#define LIST_FOR_EACH_ENTRY_REV(elem, list, type, field) \
- for ((elem) = LIST_ENTRY((list)->prev, type, field); \
+ for ((elem) = WINE_LIST_ENTRY((list)->prev, type, field); \
&(elem)->field != (list); \
- (elem) = LIST_ENTRY((elem)->field.prev, type, field))
+ (elem) = WINE_LIST_ENTRY((elem)->field.prev, type, field))
/* iterate through the list in reverse order using a list entry, with safety against removal */
#define LIST_FOR_EACH_ENTRY_SAFE_REV(cursor, cursor2, list, type, field) \
- for ((cursor) = LIST_ENTRY((list)->prev, type, field), \
- (cursor2) = LIST_ENTRY((cursor)->field.prev, type, field); \
+ for ((cursor) = WINE_LIST_ENTRY((list)->prev, type, field), \
+ (cursor2) = WINE_LIST_ENTRY((cursor)->field.prev, type, field); \
&(cursor)->field != (list); \
(cursor) = (cursor2), \
- (cursor2) = LIST_ENTRY((cursor)->field.prev, type, field))
+ (cursor2) = WINE_LIST_ENTRY((cursor)->field.prev, type, field))
/* macros for statically initialized lists */
#undef LIST_INIT
#define LIST_INIT(list) { &(list), &(list) }
/* get pointer to object containing list element */
-#undef LIST_ENTRY
-#define LIST_ENTRY(elem, type, field) \
+#define WINE_LIST_ENTRY(elem, type, field) \
((type *)((char *)(elem) - (unsigned long)(&((type *)0)->field)))
#endif /* __WINE_SERVER_LIST_H */
diff --git a/libs/wine/mmap.c b/libs/wine/mmap.c
index b400189..24483f7 100644
--- a/libs/wine/mmap.c
+++ b/libs/wine/mmap.c
@@ -360,7 +360,7 @@ void mmap_init(void)
/* to avoid wasting time trying to allocate it again */
LIST_FOR_EACH( ptr, &reserved_areas )
{
- area = LIST_ENTRY( ptr, struct reserved_area, entry );
+ area = WINE_LIST_ENTRY( ptr, struct reserved_area, entry );
if ((char *)area->base > user_space_limit) break;
if ((char *)area->base + area->size > user_space_limit)
{
@@ -390,7 +390,7 @@ void mmap_init(void)
ptr = list_head( &reserved_areas );
if (ptr)
{
- area = LIST_ENTRY( ptr, struct reserved_area, entry );
+ area = WINE_LIST_ENTRY( ptr, struct reserved_area, entry );
if (!area->base) return; /* already reserved */
}
reserve_dos_area();
@@ -415,7 +415,7 @@ void wine_mmap_add_reserved_area( void *addr, size_t size )
LIST_FOR_EACH( ptr, &reserved_areas )
{
- area = LIST_ENTRY( ptr, struct reserved_area, entry );
+ area = WINE_LIST_ENTRY( ptr, struct reserved_area, entry );
if (area->base > addr)
{
/* try to merge with the next one */
@@ -435,7 +435,7 @@ void wine_mmap_add_reserved_area( void *addr, size_t size )
/* try to merge with the next one too */
if ((ptr = list_next( &reserved_areas, ptr )))
{
- struct reserved_area *next = LIST_ENTRY( ptr, struct reserved_area, entry );
+ struct reserved_area *next = WINE_LIST_ENTRY( ptr, struct reserved_area, entry );
if ((char *)addr + size == (char *)next->base)
{
area->size += next->size;
@@ -476,7 +476,7 @@ void wine_mmap_remove_reserved_area( void *addr, size_t size, int unmap )
/* find the first area covering address */
while (ptr)
{
- area = LIST_ENTRY( ptr, struct reserved_area, entry );
+ area = WINE_LIST_ENTRY( ptr, struct reserved_area, entry );
if ((char *)area->base >= (char *)addr + size) break; /* outside the range */
if ((char *)area->base + area->size > (char *)addr) /* overlaps range */
{
@@ -547,7 +547,7 @@ int wine_mmap_is_in_reserved_area( void *addr, size_t size )
LIST_FOR_EACH( ptr, &reserved_areas )
{
- area = LIST_ENTRY( ptr, struct reserved_area, entry );
+ area = WINE_LIST_ENTRY( ptr, struct reserved_area, entry );
if (area->base > addr) break;
if ((char *)area->base + area->size <= (char *)addr) continue;
/* area must contain block completely */
@@ -577,7 +577,7 @@ int wine_mmap_enum_reserved_areas( int (*enum_func)(void *base, size_t size, voi
{
for (ptr = reserved_areas.prev; ptr != &reserved_areas; ptr = ptr->prev)
{
- struct reserved_area *area = LIST_ENTRY( ptr, struct reserved_area, entry );
+ struct reserved_area *area = WINE_LIST_ENTRY( ptr, struct reserved_area, entry );
if ((ret = enum_func( area->base, area->size, arg ))) break;
}
}
@@ -585,7 +585,7 @@ int wine_mmap_enum_reserved_areas( int (*enum_func)(void *base, size_t size, voi
{
for (ptr = reserved_areas.next; ptr != &reserved_areas; ptr = ptr->next)
{
- struct reserved_area *area = LIST_ENTRY( ptr, struct reserved_area, entry );
+ struct reserved_area *area = WINE_LIST_ENTRY( ptr, struct reserved_area, entry );
if ((ret = enum_func( area->base, area->size, arg ))) break;
}
}
diff --git a/programs/winecfg/winecfg.c b/programs/winecfg/winecfg.c
index 1abf8ed..fe92595 100644
--- a/programs/winecfg/winecfg.c
+++ b/programs/winecfg/winecfg.c
@@ -274,7 +274,7 @@ WCHAR *get_reg_keyW(HKEY root, const WCHAR *path, const WCHAR *name, const WCHAR
/* check if it's in the list */
LIST_FOR_EACH( cursor, settings )
{
- s = LIST_ENTRY(cursor, struct setting, entry);
+ s = WINE_LIST_ENTRY(cursor, struct setting, entry);
if (root != s->root) continue;
if (lstrcmpiW(path, s->path) != 0) continue;
@@ -360,7 +360,7 @@ static void set_reg_key_ex(HKEY root, const WCHAR *path, const WCHAR *name, cons
/* firstly, see if we already set this setting */
LIST_FOR_EACH( cursor, settings )
{
- struct setting *s = LIST_ENTRY(cursor, struct setting, entry);
+ struct setting *s = WINE_LIST_ENTRY(cursor, struct setting, entry);
if (root != s->root) continue;
if (lstrcmpiW(s->path, path) != 0) continue;
@@ -503,7 +503,7 @@ static WCHAR **enumerate_valuesW(HKEY root, WCHAR *path)
/* check if this value name has been removed in the settings list */
LIST_FOR_EACH( cursor, settings )
{
- struct setting *s = LIST_ENTRY(cursor, struct setting, entry);
+ struct setting *s = WINE_LIST_ENTRY(cursor, struct setting, entry);
if (lstrcmpiW(s->path, path) != 0) continue;
if (lstrcmpiW(s->name, name) != 0) continue;
@@ -542,7 +542,7 @@ static WCHAR **enumerate_valuesW(HKEY root, WCHAR *path)
/* now we have to add the values that aren't in the registry but are in the settings list */
LIST_FOR_EACH( cursor, settings )
{
- struct setting *setting = LIST_ENTRY(cursor, struct setting, entry);
+ struct setting *setting = WINE_LIST_ENTRY(cursor, struct setting, entry);
BOOL found = FALSE;
if (lstrcmpiW(setting->path, path) != 0) continue;
diff --git a/server/async.c b/server/async.c
index 73cd76d..e44d5b5 100644
--- a/server/async.c
+++ b/server/async.c
@@ -284,7 +284,7 @@ int async_waiting( struct async_queue *queue )
if (!queue) return 0;
if (!(ptr = list_head( &queue->queue ))) return 0;
- async = LIST_ENTRY( ptr, struct async, queue_entry );
+ async = WINE_LIST_ENTRY( ptr, struct async, queue_entry );
return async->status == STATUS_PENDING;
}
@@ -298,7 +298,7 @@ int async_wake_up_by( struct async_queue *queue, struct process *process,
LIST_FOR_EACH_SAFE( ptr, next, &queue->queue )
{
- struct async *async = LIST_ENTRY( ptr, struct async, queue_entry );
+ struct async *async = WINE_LIST_ENTRY( ptr, struct async, queue_entry );
if ( (!process || async->thread->process == process) &&
(!thread || async->thread == thread) &&
(!iosb || async->data.iosb == iosb) )
@@ -319,7 +319,7 @@ void async_wake_up( struct async_queue *queue, unsigned int status )
LIST_FOR_EACH_SAFE( ptr, next, &queue->queue )
{
- struct async *async = LIST_ENTRY( ptr, struct async, queue_entry );
+ struct async *async = WINE_LIST_ENTRY( ptr, struct async, queue_entry );
async_terminate( async, status );
if (status == STATUS_ALERTED) break; /* only wake up the first one */
}
diff --git a/server/change.c b/server/change.c
index 9a1a02d..455f273 100644
--- a/server/change.c
+++ b/server/change.c
@@ -390,7 +390,7 @@ static struct change_record *get_first_change_record( struct dir *dir )
struct list *ptr = list_head( &dir->change_records );
if (!ptr) return NULL;
list_remove( ptr );
- return LIST_ENTRY( ptr, struct change_record, entry );
+ return WINE_LIST_ENTRY( ptr, struct change_record, entry );
}
static void dir_destroy( struct object *obj )
@@ -698,7 +698,7 @@ static char *inode_get_path( struct inode *inode, int sz )
head = list_head( &inode->dirs );
if (head)
{
- int unix_fd = get_unix_fd( LIST_ENTRY( head, struct dir, in_entry )->fd );
+ int unix_fd = get_unix_fd( WINE_LIST_ENTRY( head, struct dir, in_entry )->fd );
path = malloc ( 32 + sz );
if (path)
sprintf( path, "/proc/self/fd/%u/", unix_fd );
diff --git a/server/class.c b/server/class.c
index 0e402ba..289b95c 100644
--- a/server/class.c
+++ b/server/class.c
@@ -86,7 +86,7 @@ void destroy_process_classes( struct process *process )
while ((ptr = list_head( &process->classes )))
{
- struct window_class *class = LIST_ENTRY( ptr, struct window_class, entry );
+ struct window_class *class = WINE_LIST_ENTRY( ptr, struct window_class, entry );
destroy_class( class );
}
}
@@ -97,7 +97,7 @@ static struct window_class *find_class( struct process *process, atom_t atom, mo
LIST_FOR_EACH( ptr, &process->classes )
{
- struct window_class *class = LIST_ENTRY( ptr, struct window_class, entry );
+ struct window_class *class = WINE_LIST_ENTRY( ptr, struct window_class, entry );
if (class->atom != atom) continue;
if (!instance || !class->local || class->instance == instance) return class;
}
diff --git a/server/completion.c b/server/completion.c
index 2a8f9ac..d6edb80 100644
--- a/server/completion.c
+++ b/server/completion.c
@@ -232,7 +232,7 @@ DECL_HANDLER(remove_completion)
{
list_remove( entry );
completion->depth--;
- msg = LIST_ENTRY( entry, struct comp_msg, queue_entry );
+ msg = WINE_LIST_ENTRY( entry, struct comp_msg, queue_entry );
reply->ckey = msg->ckey;
reply->cvalue = msg->cvalue;
reply->status = msg->status;
diff --git a/server/debugger.c b/server/debugger.c
index 795a24a..9d4b757 100644
--- a/server/debugger.c
+++ b/server/debugger.c
@@ -341,7 +341,7 @@ static void debug_ctx_destroy( struct object *obj )
/* free all pending events */
while ((ptr = list_head( &debug_ctx->event_queue )))
- unlink_event( debug_ctx, LIST_ENTRY( ptr, struct debug_event, entry ));
+ unlink_event( debug_ctx, WINE_LIST_ENTRY( ptr, struct debug_event, entry ));
}
/* continue a debug event */
@@ -516,7 +516,7 @@ void generate_startup_debug_events( struct process *process, client_ptr_t entry
ptr = list_tail( &process->dlls );
while (ptr != list_head( &process->dlls ))
{
- struct process_dll *dll = LIST_ENTRY( ptr, struct process_dll, entry );
+ struct process_dll *dll = WINE_LIST_ENTRY( ptr, struct process_dll, entry );
generate_debug_event( first_thread, LOAD_DLL_DEBUG_EVENT, dll );
ptr = list_prev( &process->dlls, ptr );
}
diff --git a/server/device.c b/server/device.c
index 4d134a3..276cab7 100644
--- a/server/device.c
+++ b/server/device.c
@@ -407,7 +407,7 @@ static void device_manager_destroy( struct object *obj )
while ((ptr = list_head( &manager->devices )))
{
- struct device *device = LIST_ENTRY( ptr, struct device, entry );
+ struct device *device = WINE_LIST_ENTRY( ptr, struct device, entry );
delete_device( device );
}
}
@@ -507,7 +507,7 @@ DECL_HANDLER(get_next_device_request)
if ((ptr = list_head( &manager->requests )))
{
- ioctl = LIST_ENTRY( ptr, struct ioctl_call, mgr_entry );
+ ioctl = WINE_LIST_ENTRY( ptr, struct ioctl_call, mgr_entry );
reply->code = ioctl->code;
reply->user_ptr = ioctl->device->user_ptr;
reply->in_size = ioctl->in_size;
diff --git a/server/fd.c b/server/fd.c
index e26ce04..338828b 100644
--- a/server/fd.c
+++ b/server/fd.c
@@ -79,7 +79,6 @@
#ifdef HAVE_SYS_EVENT_H
#include <sys/event.h>
#undef LIST_INIT
-#undef LIST_ENTRY
#endif
#ifdef HAVE_STDINT_H
#include <stdint.h>
@@ -393,7 +392,7 @@ struct timeout_user *add_timeout_user( timeout_t when, timeout_callback func, vo
LIST_FOR_EACH( ptr, &timeout_list )
{
- struct timeout_user *timeout = LIST_ENTRY( ptr, struct timeout_user, entry );
+ struct timeout_user *timeout = WINE_LIST_ENTRY( ptr, struct timeout_user, entry );
if (timeout->when >= user->when) break;
}
list_add_before( ptr, &user->entry );
@@ -858,7 +857,7 @@ static int get_next_timeout(void)
list_init( &expired_list );
while ((ptr = list_head( &timeout_list )) != NULL)
{
- struct timeout_user *timeout = LIST_ENTRY( ptr, struct timeout_user, entry );
+ struct timeout_user *timeout = WINE_LIST_ENTRY( ptr, struct timeout_user, entry );
if (timeout->when <= current_time)
{
@@ -872,7 +871,7 @@ static int get_next_timeout(void)
while ((ptr = list_head( &expired_list )) != NULL)
{
- struct timeout_user *timeout = LIST_ENTRY( ptr, struct timeout_user, entry );
+ struct timeout_user *timeout = WINE_LIST_ENTRY( ptr, struct timeout_user, entry );
list_remove( &timeout->entry );
timeout->callback( timeout->private );
free( timeout );
@@ -880,7 +879,7 @@ static int get_next_timeout(void)
if ((ptr = list_head( &timeout_list )) != NULL)
{
- struct timeout_user *timeout = LIST_ENTRY( ptr, struct timeout_user, entry );
+ struct timeout_user *timeout = WINE_LIST_ENTRY( ptr, struct timeout_user, entry );
int diff = (timeout->when - current_time + 9999) / 10000;
if (diff < 0) diff = 0;
return diff;
@@ -1022,7 +1021,7 @@ static void inode_close_pending( struct inode *inode, int keep_unlinks )
while (ptr)
{
- struct closed_fd *fd = LIST_ENTRY( ptr, struct closed_fd, entry );
+ struct closed_fd *fd = WINE_LIST_ENTRY( ptr, struct closed_fd, entry );
struct list *next = list_next( &inode->closed, ptr );
if (fd->unix_fd != -1)
@@ -1059,7 +1058,7 @@ static void inode_destroy( struct object *obj )
while ((ptr = list_head( &inode->closed )))
{
- struct closed_fd *fd = LIST_ENTRY( ptr, struct closed_fd, entry );
+ struct closed_fd *fd = WINE_LIST_ENTRY( ptr, struct closed_fd, entry );
list_remove( ptr );
if (fd->unix_fd != -1) close( fd->unix_fd );
if (fd->unlink[0])
@@ -1243,7 +1242,7 @@ static void remove_unix_locks( struct fd *fd, file_pos_t start, file_pos_t end )
LIST_FOR_EACH( ptr, &fd->inode->locks )
{
- struct file_lock *lock = LIST_ENTRY( ptr, struct file_lock, inode_entry );
+ struct file_lock *lock = WINE_LIST_ENTRY( ptr, struct file_lock, inode_entry );
if (lock->start == lock->end) continue;
if (lock_overlaps( lock, start, end )) count++;
}
@@ -1269,7 +1268,7 @@ static void remove_unix_locks( struct fd *fd, file_pos_t start, file_pos_t end )
LIST_FOR_EACH( ptr, &fd->inode->locks )
{
- struct file_lock *lock = LIST_ENTRY( ptr, struct file_lock, inode_entry );
+ struct file_lock *lock = WINE_LIST_ENTRY( ptr, struct file_lock, inode_entry );
if (lock->start == lock->end) continue;
if (!lock_overlaps( lock, start, end )) continue;
@@ -1366,7 +1365,7 @@ void remove_process_locks( struct process *process )
while ((ptr = list_head( &process->locks )))
{
- struct file_lock *lock = LIST_ENTRY( ptr, struct file_lock, proc_entry );
+ struct file_lock *lock = WINE_LIST_ENTRY( ptr, struct file_lock, proc_entry );
remove_lock( lock, 1 ); /* this removes it from the list */
}
}
@@ -1379,7 +1378,7 @@ static void remove_fd_locks( struct fd *fd )
while ((ptr = list_head( &fd->locks )))
{
- struct file_lock *lock = LIST_ENTRY( ptr, struct file_lock, fd_entry );
+ struct file_lock *lock = WINE_LIST_ENTRY( ptr, struct file_lock, fd_entry );
if (lock->start < start) start = lock->start;
if (!lock->end || lock->end > end) end = lock->end - 1;
remove_lock( lock, 0 );
@@ -1410,7 +1409,7 @@ obj_handle_t lock_fd( struct fd *fd, file_pos_t start, file_pos_t count, int sha
/* check if another lock on that file overlaps the area */
LIST_FOR_EACH( ptr, &fd->inode->locks )
{
- struct file_lock *lock = LIST_ENTRY( ptr, struct file_lock, inode_entry );
+ struct file_lock *lock = WINE_LIST_ENTRY( ptr, struct file_lock, inode_entry );
if (!lock_overlaps( lock, start, end )) continue;
if (lock->shared && shared) continue;
/* found one */
@@ -1442,7 +1441,7 @@ void unlock_fd( struct fd *fd, file_pos_t start, file_pos_t count )
/* find an existing lock with the exact same parameters */
LIST_FOR_EACH( ptr, &fd->locks )
{
- struct file_lock *lock = LIST_ENTRY( ptr, struct file_lock, fd_entry );
+ struct file_lock *lock = WINE_LIST_ENTRY( ptr, struct file_lock, fd_entry );
if ((lock->start == start) && (lock->end == end))
{
remove_lock( lock, 1 );
@@ -1666,7 +1665,7 @@ static unsigned int check_sharing( struct fd *fd, unsigned int access, unsigned
LIST_FOR_EACH( ptr, &fd->inode->open )
{
- struct fd *fd_ptr = LIST_ENTRY( ptr, struct fd, inode_entry );
+ struct fd *fd_ptr = WINE_LIST_ENTRY( ptr, struct fd, inode_entry );
if (fd_ptr != fd)
{
/* if access mode is 0, sharing mode is ignored */
diff --git a/server/hook.c b/server/hook.c
index 7b889d8..bcbab59 100644
--- a/server/hook.c
+++ b/server/hook.c
@@ -61,7 +61,7 @@ struct hook
#define WH_WINEVENT (WH_MAXHOOK+1)
#define NB_HOOKS (WH_WINEVENT-WH_MINHOOK+1)
-#define HOOK_ENTRY(p) LIST_ENTRY( (p), struct hook, chain )
+#define HOOK_ENTRY(p) WINE_LIST_ENTRY( (p), struct hook, chain )
struct hook_table
{
diff --git a/server/mailslot.c b/server/mailslot.c
index 97da8d2..0eb67c8 100644
--- a/server/mailslot.c
+++ b/server/mailslot.c
@@ -266,7 +266,7 @@ static struct object *mailslot_open_file( struct object *obj, unsigned int acces
/* Readers and writers cannot be mixed.
* If there's more than one writer, all writers must open with FILE_SHARE_WRITE
*/
- writer = LIST_ENTRY( list_head(&mailslot->writers), struct mail_writer, entry );
+ writer = WINE_LIST_ENTRY( list_head(&mailslot->writers), struct mail_writer, entry );
if (((access & (GENERIC_WRITE|FILE_WRITE_DATA)) || (writer->access & FILE_WRITE_DATA)) &&
!((sharing & FILE_SHARE_WRITE) && (writer->sharing & FILE_SHARE_WRITE)))
diff --git a/server/mutex.c b/server/mutex.c
index 31a529a..4247f76 100644
--- a/server/mutex.c
+++ b/server/mutex.c
@@ -113,7 +113,7 @@ void abandon_mutexes( struct thread *thread )
while ((ptr = list_head( &thread->mutex_list )) != NULL)
{
- struct mutex *mutex = LIST_ENTRY( ptr, struct mutex, entry );
+ struct mutex *mutex = WINE_LIST_ENTRY( ptr, struct mutex, entry );
assert( mutex->owner == thread );
mutex->count = 0;
mutex->abandoned = 1;
diff --git a/server/object.c b/server/object.c
index d2a3930..f5f8ddd 100644
--- a/server/object.c
+++ b/server/object.c
@@ -66,13 +66,13 @@ void dump_objects(void)
LIST_FOR_EACH( p, &static_object_list )
{
- struct object *ptr = LIST_ENTRY( p, struct object, obj_list );
+ struct object *ptr = WINE_LIST_ENTRY( p, struct object, obj_list );
fprintf( stderr, "%p:%d: ", ptr, ptr->refcount );
ptr->ops->dump( ptr, 1 );
}
LIST_FOR_EACH( p, &object_list )
{
- struct object *ptr = LIST_ENTRY( p, struct object, obj_list );
+ struct object *ptr = WINE_LIST_ENTRY( p, struct object, obj_list );
fprintf( stderr, "%p:%d: ", ptr, ptr->refcount );
ptr->ops->dump( ptr, 1 );
}
@@ -85,7 +85,7 @@ void close_objects(void)
/* release the static objects */
while ((ptr = list_head( &static_object_list )))
{
- struct object *obj = LIST_ENTRY( ptr, struct object, obj_list );
+ struct object *obj = WINE_LIST_ENTRY( ptr, struct object, obj_list );
/* move it back to the standard list before freeing */
list_remove( &obj->obj_list );
list_add_head( &object_list, &obj->obj_list );
@@ -331,7 +331,7 @@ struct object *find_object( const struct namespace *namespace, const struct unic
list = &namespace->names[ get_name_hash( namespace, name->str, name->len ) ];
LIST_FOR_EACH( p, list )
{
- const struct object_name *ptr = LIST_ENTRY( p, struct object_name, entry );
+ const struct object_name *ptr = WINE_LIST_ENTRY( p, struct object_name, entry );
if (ptr->len != name->len) continue;
if (attributes & OBJ_CASE_INSENSITIVE)
{
diff --git a/server/process.c b/server/process.c
index 379bec6..83f99d2 100644
--- a/server/process.c
+++ b/server/process.c
@@ -214,7 +214,7 @@ struct thread *get_process_first_thread( struct process *process )
{
struct list *ptr = list_head( &process->thread_list );
if (!ptr) return NULL;
- return LIST_ENTRY( ptr, struct thread, proc_entry );
+ return WINE_LIST_ENTRY( ptr, struct thread, proc_entry );
}
/* set the state of the process startup info */
@@ -574,7 +574,7 @@ static void terminate_process( struct process *process, struct thread *skip, int
grab_object( process ); /* make sure it doesn't get freed when threads die */
while ((ptr = list_head( &process->thread_list )))
{
- struct thread *thread = LIST_ENTRY( ptr, struct thread, proc_entry );
+ struct thread *thread = WINE_LIST_ENTRY( ptr, struct thread, proc_entry );
if (exit_code) thread->exit_code = exit_code;
if (thread == skip) break;
@@ -643,7 +643,7 @@ static void process_killed( struct process *process )
while ((ptr = list_head( &process->dlls )))
{
- struct process_dll *dll = LIST_ENTRY( ptr, struct process_dll, entry );
+ struct process_dll *dll = WINE_LIST_ENTRY( ptr, struct process_dll, entry );
if (dll->file) release_object( dll->file );
free( dll->filename );
list_remove( &dll->entry );
@@ -705,7 +705,7 @@ void suspend_process( struct process *process )
LIST_FOR_EACH_SAFE( ptr, next, &process->thread_list )
{
- struct thread *thread = LIST_ENTRY( ptr, struct thread, proc_entry );
+ struct thread *thread = WINE_LIST_ENTRY( ptr, struct thread, proc_entry );
if (!thread->suspend) stop_thread( thread );
}
}
@@ -721,7 +721,7 @@ void resume_process( struct process *process )
LIST_FOR_EACH_SAFE( ptr, next, &process->thread_list )
{
- struct thread *thread = LIST_ENTRY( ptr, struct thread, proc_entry );
+ struct thread *thread = WINE_LIST_ENTRY( ptr, struct thread, proc_entry );
if (!thread->suspend) wake_thread( thread );
}
}
@@ -752,7 +752,7 @@ void kill_process( struct process *process, int violent_death )
grab_object( process ); /* make sure it doesn't get freed when threads die */
while ((ptr = list_head( &process->thread_list )))
{
- struct thread *thread = LIST_ENTRY( ptr, struct thread, proc_entry );
+ struct thread *thread = WINE_LIST_ENTRY( ptr, struct thread, proc_entry );
kill_thread( thread, 0 );
}
release_object( process );
@@ -822,7 +822,7 @@ void enum_processes( int (*cb)(struct process*, void*), void *user )
LIST_FOR_EACH_SAFE( ptr, next, &process_list )
{
- struct process *process = LIST_ENTRY( ptr, struct process, entry );
+ struct process *process = WINE_LIST_ENTRY( ptr, struct process, entry );
if ((cb)(process, user)) break;
}
}
@@ -1204,7 +1204,7 @@ DECL_HANDLER(get_dll_info)
dll = find_process_dll( process, req->base_address );
else /* NULL means main module */
dll = list_head( &process->dlls ) ?
- LIST_ENTRY(list_head( &process->dlls ), struct process_dll, entry) : NULL;
+ WINE_LIST_ENTRY(list_head( &process->dlls ), struct process_dll, entry) : NULL;
if (dll)
{
diff --git a/server/process.h b/server/process.h
index 87e12e0..c3ab72b 100644
--- a/server/process.h
+++ b/server/process.h
@@ -150,7 +150,7 @@ static inline int is_process_init_done( struct process *process )
static inline struct process_dll *get_process_exe_module( struct process *process )
{
struct list *ptr = list_head( &process->dlls );
- return ptr ? LIST_ENTRY( ptr, struct process_dll, entry ) : NULL;
+ return ptr ? WINE_LIST_ENTRY( ptr, struct process_dll, entry ) : NULL;
}
#endif /* __WINE_SERVER_PROCESS_H */
diff --git a/server/queue.c b/server/queue.c
index cfe9818..cd60118 100644
--- a/server/queue.c
+++ b/server/queue.c
@@ -389,7 +389,7 @@ static int merge_message( struct thread_input *input, const struct message *msg
struct list *ptr = list_tail( &input->msg_list );
if (!ptr) return 0;
- prev = LIST_ENTRY( ptr, struct message, entry );
+ prev = WINE_LIST_ENTRY( ptr, struct message, entry );
if (prev->result) return 0;
if (prev->win && msg->win && prev->win != msg->win) return 0;
if (prev->msg != msg->msg) return 0;
@@ -719,7 +719,7 @@ static void empty_msg_list( struct list *list )
while ((ptr = list_head( list )) != NULL)
{
- struct message *msg = LIST_ENTRY( ptr, struct message, entry );
+ struct message *msg = WINE_LIST_ENTRY( ptr, struct message, entry );
list_remove( &msg->entry );
free_message( msg );
}
@@ -732,12 +732,12 @@ static void cleanup_results( struct msg_queue *queue )
while ((entry = list_head( &queue->send_result )) != NULL)
{
- remove_result_from_sender( LIST_ENTRY( entry, struct message_result, sender_entry ) );
+ remove_result_from_sender( WINE_LIST_ENTRY( entry, struct message_result, sender_entry ) );
}
while ((entry = list_head( &queue->callback_result )) != NULL)
{
- remove_result_from_sender( LIST_ENTRY( entry, struct message_result, sender_entry ) );
+ remove_result_from_sender( WINE_LIST_ENTRY( entry, struct message_result, sender_entry ) );
}
while (queue->recv_result)
@@ -831,13 +831,13 @@ static void msg_queue_destroy( struct object *obj )
while ((ptr = list_head( &queue->pending_timers )))
{
- struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
+ struct timer *timer = WINE_LIST_ENTRY( ptr, struct timer, entry );
list_remove( &timer->entry );
free( timer );
}
while ((ptr = list_head( &queue->expired_timers )))
{
- struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
+ struct timer *timer = WINE_LIST_ENTRY( ptr, struct timer, entry );
list_remove( &timer->entry );
free( timer );
}
@@ -968,7 +968,7 @@ static void set_next_timer( struct msg_queue *queue )
}
if ((ptr = list_head( &queue->pending_timers )))
{
- struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
+ struct timer *timer = WINE_LIST_ENTRY( ptr, struct timer, entry );
queue->timeout = add_timeout_user( timer->when, timer_callback, queue );
}
/* set/clear QS_TIMER bit */
@@ -988,12 +988,12 @@ static struct timer *find_timer( struct msg_queue *queue, user_handle_t win,
LIST_FOR_EACH( ptr, &queue->pending_timers )
{
- struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
+ struct timer *timer = WINE_LIST_ENTRY( ptr, struct timer, entry );
if (timer->win == win && timer->msg == msg && timer->id == id) return timer;
}
LIST_FOR_EACH( ptr, &queue->expired_timers )
{
- struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
+ struct timer *timer = WINE_LIST_ENTRY( ptr, struct timer, entry );
if (timer->win == win && timer->msg == msg && timer->id == id) return timer;
}
return NULL;
@@ -1020,7 +1020,7 @@ static void link_timer( struct msg_queue *queue, struct timer *timer )
for (ptr = queue->pending_timers.next; ptr != &queue->pending_timers; ptr = ptr->next)
{
- struct timer *t = LIST_ENTRY( ptr, struct timer, entry );
+ struct timer *t = WINE_LIST_ENTRY( ptr, struct timer, entry );
if (t->when >= timer->when) break;
}
list_add_before( ptr, &timer->entry );
@@ -1052,7 +1052,7 @@ static struct timer *find_expired_timer( struct msg_queue *queue, user_handle_t
LIST_FOR_EACH( ptr, &queue->expired_timers )
{
- struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
+ struct timer *timer = WINE_LIST_ENTRY( ptr, struct timer, entry );
if (win && timer->win != win) continue;
if (check_msg_filter( timer->msg, get_first, get_last ))
{
@@ -1321,7 +1321,7 @@ static int get_hardware_message( struct thread *thread, unsigned int hw_id, user
{
while (ptr)
{
- struct message *msg = LIST_ENTRY( ptr, struct message, entry );
+ struct message *msg = WINE_LIST_ENTRY( ptr, struct message, entry );
if (msg->unique_id == hw_id) break;
ptr = list_next( &input->msg_list, ptr );
}
@@ -1336,7 +1336,7 @@ static int get_hardware_message( struct thread *thread, unsigned int hw_id, user
while (ptr)
{
- struct message *msg = LIST_ENTRY( ptr, struct message, entry );
+ struct message *msg = WINE_LIST_ENTRY( ptr, struct message, entry );
struct hardware_msg_data *data = msg->data;
ptr = list_next( &input->msg_list, ptr );
@@ -1425,7 +1425,7 @@ void queue_cleanup_window( struct thread *thread, user_handle_t win )
while (ptr)
{
struct list *next = list_next( &queue->pending_timers, ptr );
- struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
+ struct timer *timer = WINE_LIST_ENTRY( ptr, struct timer, entry );
if (timer->win == win) free_timer( queue, timer );
ptr = next;
}
@@ -1433,7 +1433,7 @@ void queue_cleanup_window( struct thread *thread, user_handle_t win )
while (ptr)
{
struct list *next = list_next( &queue->expired_timers, ptr );
- struct timer *timer = LIST_ENTRY( ptr, struct timer, entry );
+ struct timer *timer = WINE_LIST_ENTRY( ptr, struct timer, entry );
if (timer->win == win) free_timer( queue, timer );
ptr = next;
}
@@ -1445,7 +1445,7 @@ void queue_cleanup_window( struct thread *thread, user_handle_t win )
LIST_FOR_EACH_SAFE( ptr, next, &queue->msg_list[i] )
{
- struct message *msg = LIST_ENTRY( ptr, struct message, entry );
+ struct message *msg = WINE_LIST_ENTRY( ptr, struct message, entry );
if (msg->win == win) remove_queue_message( queue, msg, i );
}
}
@@ -1759,7 +1759,7 @@ DECL_HANDLER(get_message)
/* first check for sent messages */
if ((ptr = list_head( &queue->msg_list[SEND_MESSAGE] )))
{
- struct message *msg = LIST_ENTRY( ptr, struct message, entry );
+ struct message *msg = WINE_LIST_ENTRY( ptr, struct message, entry );
receive_message( queue, msg, reply );
return;
}
@@ -1859,7 +1859,7 @@ DECL_HANDLER(get_message_reply)
if (!(entry = list_head( &queue->send_result ))) return; /* no reply ready */
- result = LIST_ENTRY( entry, struct message_result, sender_entry );
+ result = WINE_LIST_ENTRY( entry, struct message_result, sender_entry );
if (result->replied || req->cancel)
{
if (result->replied)
@@ -1880,7 +1880,7 @@ DECL_HANDLER(get_message_reply)
if (!entry) clear_queue_bits( queue, QS_SMRESULT );
else
{
- result = LIST_ENTRY( entry, struct message_result, sender_entry );
+ result = WINE_LIST_ENTRY( entry, struct message_result, sender_entry );
if (!result->replied) clear_queue_bits( queue, QS_SMRESULT );
}
}
diff --git a/server/registry.c b/server/registry.c
index afdffed..271f2b4 100644
--- a/server/registry.c
+++ b/server/registry.c
@@ -343,7 +343,7 @@ static void key_destroy( struct object *obj )
/* unconditionally notify everything waiting on this key */
while ((ptr = list_head( &key->notify_list )))
{
- struct notify *notify = LIST_ENTRY( ptr, struct notify, entry );
+ struct notify *notify = WINE_LIST_ENTRY( ptr, struct notify, entry );
do_notification( key, notify, 1 );
}
}
@@ -449,7 +449,7 @@ static void check_notify( struct key *key, unsigned int change, int not_subtree
LIST_FOR_EACH_SAFE( ptr, next, &key->notify_list )
{
- struct notify *n = LIST_ENTRY( ptr, struct notify, entry );
+ struct notify *n = WINE_LIST_ENTRY( ptr, struct notify, entry );
if ( ( not_subtree || n->subtree ) && ( change & n->filter ) )
do_notification( key, n, 0 );
}
diff --git a/server/thread.c b/server/thread.c
index b50193a..88d17cf 100644
--- a/server/thread.c
+++ b/server/thread.c
@@ -748,7 +748,7 @@ void wake_up( struct object *obj, int max )
LIST_FOR_EACH( ptr, &obj->wait_queue )
{
- struct wait_queue_entry *entry = LIST_ENTRY( ptr, struct wait_queue_entry, entry );
+ struct wait_queue_entry *entry = WINE_LIST_ENTRY( ptr, struct wait_queue_entry, entry );
if (!wake_thread( entry->thread )) continue;
if (max && !--max) break;
/* restart at the head of the list since a wake up can change the object wait queue */
@@ -872,7 +872,7 @@ static struct thread_apc *thread_dequeue_apc( struct thread *thread, int system_
if (!ptr && !system_only) ptr = list_head( &thread->user_apc );
if (ptr)
{
- apc = LIST_ENTRY( ptr, struct thread_apc, entry );
+ apc = WINE_LIST_ENTRY( ptr, struct thread_apc, entry );
list_remove( ptr );
}
return apc;
@@ -885,7 +885,7 @@ static void clear_apc_queue( struct list *queue )
while ((ptr = list_head( queue )))
{
- struct thread_apc *apc = LIST_ENTRY( ptr, struct thread_apc, entry );
+ struct thread_apc *apc = WINE_LIST_ENTRY( ptr, struct thread_apc, entry );
list_remove( &apc->entry );
apc->executed = 1;
wake_up( &apc->obj, 0 );
diff --git a/server/token.c b/server/token.c
index 69ffab7..824b359 100644
--- a/server/token.c
+++ b/server/token.c
@@ -394,13 +394,13 @@ static void token_destroy( struct object *obj )
LIST_FOR_EACH_SAFE( cursor, cursor_next, &token->privileges )
{
- struct privilege *privilege = LIST_ENTRY( cursor, struct privilege, entry );
+ struct privilege *privilege = WINE_LIST_ENTRY( cursor, struct privilege, entry );
privilege_remove( privilege );
}
LIST_FOR_EACH_SAFE( cursor, cursor_next, &token->groups )
{
- struct group *group = LIST_ENTRY( cursor, struct group, entry );
+ struct group *group = WINE_LIST_ENTRY( cursor, struct group, entry );
list_remove( &group->entry );
free( group );
}
diff --git a/server/window.c b/server/window.c
index a0e0788..09370ab 100644
--- a/server/window.c
+++ b/server/window.c
@@ -136,28 +136,28 @@ static inline int is_desktop_window( const struct window *win )
static inline struct window *get_next_window( struct window *win )
{
struct list *ptr = list_next( &win->parent->children, &win->entry );
- return ptr ? LIST_ENTRY( ptr, struct window, entry ) : NULL;
+ return ptr ? WINE_LIST_ENTRY( ptr, struct window, entry ) : NULL;
}
/* get previous window in Z-order list */
static inline struct window *get_prev_window( struct window *win )
{
struct list *ptr = list_prev( &win->parent->children, &win->entry );
- return ptr ? LIST_ENTRY( ptr, struct window, entry ) : NULL;
+ return ptr ? WINE_LIST_ENTRY( ptr, struct window, entry ) : NULL;
}
/* get first child in Z-order list */
static inline struct window *get_first_child( struct window *win )
{
struct list *ptr = list_head( &win->children );
- return ptr ? LIST_ENTRY( ptr, struct window, entry ) : NULL;
+ return ptr ? WINE_LIST_ENTRY( ptr, struct window, entry ) : NULL;
}
/* get last child in Z-order list */
static inline struct window *get_last_child( struct window *win )
{
struct list *ptr = list_tail( &win->children );
- return ptr ? LIST_ENTRY( ptr, struct window, entry ) : NULL;
+ return ptr ? WINE_LIST_ENTRY( ptr, struct window, entry ) : NULL;
}
/* link a window at the right place in the siblings list */
@@ -188,7 +188,7 @@ static void link_window( struct window *win, struct window *previous )
if (!(win->ex_style & WS_EX_TOPMOST)) /* put it above the first non-topmost window */
{
while (entry != &win->parent->children &&
- LIST_ENTRY( entry, struct window, entry )->ex_style & WS_EX_TOPMOST)
+ WINE_LIST_ENTRY( entry, struct window, entry )->ex_style & WS_EX_TOPMOST)
entry = entry->next;
}
list_add_before( entry, &win->entry );
@@ -1683,9 +1683,9 @@ void destroy_window( struct window *win )
/* destroy all children */
while (!list_empty(&win->children))
- destroy_window( LIST_ENTRY( list_head(&win->children), struct window, entry ));
+ destroy_window( WINE_LIST_ENTRY( list_head(&win->children), struct window, entry ));
while (!list_empty(&win->unlinked))
- destroy_window( LIST_ENTRY( list_head(&win->unlinked), struct window, entry ));
+ destroy_window( WINE_LIST_ENTRY( list_head(&win->unlinked), struct window, entry ));
/* reset global window pointers, if the corresponding window is destroyed */
if (win == shell_window) shell_window = NULL;
diff --git a/tools/widl/parser.y b/tools/widl/parser.y
index dda4a37..68ae8e3 100644
--- a/tools/widl/parser.y
+++ b/tools/widl/parser.y
@@ -587,7 +587,7 @@ enum_list: enum { if (!$1->eval)
}
| enum_list ',' enum { if (!$3->eval)
{
- var_t *last = LIST_ENTRY( list_tail($$), var_t, entry );
+ var_t *last = WINE_LIST_ENTRY( list_tail($$), var_t, entry );
$3->eval = make_exprl(EXPR_NUM, last->eval->cval + 1);
}
$$ = append_var( $1, $3 );
@@ -689,7 +689,7 @@ fields: { $$ = NULL; }
;
field: m_attributes decl_spec struct_declarator_list ';'
- { const char *first = LIST_ENTRY(list_head($3), declarator_t, entry)->var->name;
+ { const char *first = WINE_LIST_ENTRY(list_head($3), declarator_t, entry)->var->name;
check_field_attrs(first, $1);
$$ = set_var_types($1, $2, $3);
}
@@ -1169,7 +1169,7 @@ static attr_list_t *append_attr_list(attr_list_t *new_list, attr_list_t *old_lis
while ((entry = list_head(old_list)))
{
- attr_t *attr = LIST_ENTRY(entry, attr_t, entry);
+ attr_t *attr = WINE_LIST_ENTRY(entry, attr_t, entry);
list_remove(entry);
new_list = append_attr(new_list, attr);
}
diff --git a/tools/widl/typegen.c b/tools/widl/typegen.c
index 68e9da1..153999c 100644
--- a/tools/widl/typegen.c
+++ b/tools/widl/typegen.c
@@ -2251,7 +2251,7 @@ static const var_t *find_array_or_string_in_struct(const type_t *type)
if (!fields || list_empty(fields))
return NULL;
- last_field = LIST_ENTRY( list_tail(fields), const var_t, entry );
+ last_field = WINE_LIST_ENTRY( list_tail(fields), const var_t, entry );
ft = last_field->type;
if (is_conformant_array(ft) && !type_array_is_decl_as_ptr(ft))
@@ -2726,8 +2726,8 @@ static unsigned int write_range_tfs(FILE *file, const attr_list_t *attrs,
{
unsigned char fc;
unsigned int start_offset = *typeformat_offset;
- const expr_t *range_min = LIST_ENTRY(list_head(range_list), const expr_t, entry);
- const expr_t *range_max = LIST_ENTRY(list_next(range_list, list_head(range_list)), const expr_t, entry);
+ const expr_t *range_min = WINE_LIST_ENTRY(list_head(range_list), const expr_t, entry);
+ const expr_t *range_max = WINE_LIST_ENTRY(list_next(range_list, list_head(range_list)), const expr_t, entry);
if (type_get_type(type) == TYPE_BASIC)
fc = get_basic_fc(type);
@@ -3605,8 +3605,8 @@ static void write_remoting_arg(FILE *file, int indent, const var_t *func, const
expr_list_t *range_list = get_attrp(var->attrs, ATTR_RANGE);
if (!range_list)
range_list = get_aliaschain_attrp(type, ATTR_RANGE);
- range_min = LIST_ENTRY(list_head(range_list), const expr_t, entry);
- range_max = LIST_ENTRY(list_next(range_list, list_head(range_list)), const expr_t, entry);
+ range_min = WINE_LIST_ENTRY(list_head(range_list), const expr_t, entry);
+ range_max = WINE_LIST_ENTRY(list_next(range_list, list_head(range_list)), const expr_t, entry);
print_file(file, indent, "if ((%s%s < (", local_var_prefix, var->name);
write_type_decl(file, var->type, NULL);
diff --git a/tools/widl/typetree.c b/tools/widl/typetree.c
index a60e757..b4392ec 100644
--- a/tools/widl/typetree.c
+++ b/tools/widl/typetree.c
@@ -84,7 +84,7 @@ type_t *type_new_function(var_list_t *args)
if (args)
{
- arg = LIST_ENTRY(list_head(args), var_t, entry);
+ arg = WINE_LIST_ENTRY(list_head(args), var_t, entry);
if (list_count(args) == 1 && !arg->name && arg->type && type_get_type(arg->type) == TYPE_VOID)
{
list_remove(&arg->entry);
diff --git a/tools/widl/typetree.h b/tools/widl/typetree.h
index 591406b..6c3a37e 100644
--- a/tools/widl/typetree.h
+++ b/tools/widl/typetree.h
@@ -110,7 +110,7 @@ static inline var_t *type_union_get_switch_value(const type_t *type)
{
type = type_get_real_type(type);
assert(type_get_type(type) == TYPE_ENCAPSULATED_UNION);
- return LIST_ENTRY(list_head(type->details.structure->fields), var_t, entry);
+ return WINE_LIST_ENTRY(list_head(type->details.structure->fields), var_t, entry);
}
static inline var_list_t *type_encapsulated_union_get_fields(const type_t *type)
@@ -130,7 +130,7 @@ static inline var_list_t *type_union_get_cases(const type_t *type)
assert(type_type == TYPE_UNION || type_type == TYPE_ENCAPSULATED_UNION);
if (type_type == TYPE_ENCAPSULATED_UNION)
{
- const var_t *uv = LIST_ENTRY(list_tail(type->details.structure->fields), const var_t, entry);
+ const var_t *uv = WINE_LIST_ENTRY(list_tail(type->details.structure->fields), const var_t, entry);
return uv->type->details.structure->fields;
}
else
--
1.6.0.2
More information about the wine-patches
mailing list