Namespace list api to reduce conflicts with similar system headers
Rename functions/macros from list_* to xorg_list_* Rename struct from struct list to struct xorg_list. Signed-off-by: Alan Coopersmith <alan.coopersmith@oracle.com> Reviewed-by: Keith Packard <keithp@keithp.com> In-sed-I-trust: Peter Hutterer <peter.hutterer@who-t.net>
This commit is contained in:
Alan Coopersmith
parent
1541e242d1
commit
ca64912c02
18
dix/events.c
18
dix/events.c
|
|
@ -1122,8 +1122,8 @@ EnqueueEvent(InternalEvent *ev, DeviceIntPtr device)
|
|||
int eventlen;
|
||||
DeviceEvent *event = &ev->device_event;
|
||||
|
||||
if (!list_is_empty(&syncEvents.pending))
|
||||
tail = list_last_entry(&syncEvents.pending, QdEventRec, next);
|
||||
if (!xorg_list_is_empty(&syncEvents.pending))
|
||||
tail = xorg_list_last_entry(&syncEvents.pending, QdEventRec, next);
|
||||
|
||||
NoticeTime((InternalEvent*)event);
|
||||
|
||||
|
|
@ -1183,13 +1183,13 @@ EnqueueEvent(InternalEvent *ev, DeviceIntPtr device)
|
|||
qe = malloc(sizeof(QdEventRec) + eventlen);
|
||||
if (!qe)
|
||||
return;
|
||||
list_init(&qe->next);
|
||||
xorg_list_init(&qe->next);
|
||||
qe->device = device;
|
||||
qe->pScreen = pSprite->hotPhys.pScreen;
|
||||
qe->months = currentTime.months;
|
||||
qe->event = (InternalEvent *)(qe + 1);
|
||||
memcpy(qe->event, event, eventlen);
|
||||
list_append(&qe->next, &syncEvents.pending);
|
||||
xorg_list_append(&qe->next, &syncEvents.pending);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -1210,10 +1210,10 @@ PlayReleasedEvents(void)
|
|||
DeviceIntPtr pDev;
|
||||
|
||||
restart:
|
||||
list_for_each_entry_safe(qe, tmp, &syncEvents.pending, next) {
|
||||
xorg_list_for_each_entry_safe(qe, tmp, &syncEvents.pending, next) {
|
||||
if (!qe->device->deviceGrab.sync.frozen)
|
||||
{
|
||||
list_del(&qe->next);
|
||||
xorg_list_del(&qe->next);
|
||||
pDev = qe->device;
|
||||
if (qe->event->any.type == ET_Motion)
|
||||
CheckVirtualMotion(pDev, qe, NullWindow);
|
||||
|
|
@ -1297,7 +1297,7 @@ ComputeFreezes(void)
|
|||
FreezeThaw(dev, dev->deviceGrab.sync.other ||
|
||||
(dev->deviceGrab.sync.state >= FROZEN));
|
||||
if (syncEvents.playingEvents ||
|
||||
(!replayDev && list_is_empty(&syncEvents.pending)))
|
||||
(!replayDev && xorg_list_is_empty(&syncEvents.pending)))
|
||||
return;
|
||||
syncEvents.playingEvents = TRUE;
|
||||
if (replayDev)
|
||||
|
|
@ -5392,9 +5392,9 @@ InitEvents(void)
|
|||
syncEvents.replayDev = (DeviceIntPtr)NULL;
|
||||
syncEvents.replayWin = NullWindow;
|
||||
if (syncEvents.pending.next)
|
||||
list_for_each_entry_safe(qe, tmp, &syncEvents.pending, next)
|
||||
xorg_list_for_each_entry_safe(qe, tmp, &syncEvents.pending, next)
|
||||
free(qe);
|
||||
list_init(&syncEvents.pending);
|
||||
xorg_list_init(&syncEvents.pending);
|
||||
syncEvents.playingEvents = FALSE;
|
||||
syncEvents.time.months = 0;
|
||||
syncEvents.time.milliseconds = 0; /* hardly matters */
|
||||
|
|
|
|||
|
|
@ -516,13 +516,13 @@ match_string_implicit(const char *attr, const char *pattern)
|
|||
* If a pattern in each list entry is matched, return TRUE.
|
||||
*/
|
||||
static Bool
|
||||
MatchAttrToken(const char *attr, struct list *patterns,
|
||||
MatchAttrToken(const char *attr, struct xorg_list *patterns,
|
||||
int (*compare)(const char *attr, const char *pattern))
|
||||
{
|
||||
const xf86MatchGroup *group;
|
||||
|
||||
/* If there are no patterns, accept the match */
|
||||
if (list_is_empty(patterns))
|
||||
if (xorg_list_is_empty(patterns))
|
||||
return TRUE;
|
||||
|
||||
/* If there are patterns but no attribute, reject the match */
|
||||
|
|
@ -533,7 +533,7 @@ MatchAttrToken(const char *attr, struct list *patterns,
|
|||
* Otherwise, iterate the list of patterns ensuring each entry has a
|
||||
* match. Each list entry is a separate Match line of the same type.
|
||||
*/
|
||||
list_for_each_entry(group, patterns, entry) {
|
||||
xorg_list_for_each_entry(group, patterns, entry) {
|
||||
char * const *cur;
|
||||
Bool match = FALSE;
|
||||
|
||||
|
|
@ -590,7 +590,7 @@ InputClassMatches(const XF86ConfInputClassPtr iclass, const InputInfoPtr idev,
|
|||
* MatchTag string
|
||||
* See if any of the device's tags match any of the MatchTag tokens.
|
||||
*/
|
||||
if (!list_is_empty(&iclass->match_tag)) {
|
||||
if (!xorg_list_is_empty(&iclass->match_tag)) {
|
||||
char * const *tag;
|
||||
Bool match;
|
||||
|
||||
|
|
@ -607,7 +607,7 @@ InputClassMatches(const XF86ConfInputClassPtr iclass, const InputInfoPtr idev,
|
|||
}
|
||||
|
||||
/* MatchLayout string */
|
||||
if (!list_is_empty(&iclass->match_layout)) {
|
||||
if (!xorg_list_is_empty(&iclass->match_layout)) {
|
||||
if (!MatchAttrToken(xf86ConfigLayout.id,
|
||||
&iclass->match_layout, match_string_implicit))
|
||||
return FALSE;
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ typedef struct _DRI2Screen *DRI2ScreenPtr;
|
|||
typedef struct _DRI2Drawable {
|
||||
DRI2ScreenPtr dri2_screen;
|
||||
DrawablePtr drawable;
|
||||
struct list reference_list;
|
||||
struct xorg_list reference_list;
|
||||
int width;
|
||||
int height;
|
||||
DRI2BufferPtr *buffers;
|
||||
|
|
@ -179,7 +179,7 @@ DRI2AllocateDrawable(DrawablePtr pDraw)
|
|||
pPriv->swap_limit = 1; /* default to double buffering */
|
||||
pPriv->last_swap_msc = 0;
|
||||
pPriv->last_swap_ust = 0;
|
||||
list_init(&pPriv->reference_list);
|
||||
xorg_list_init(&pPriv->reference_list);
|
||||
pPriv->serialNumber = DRI2DrawableSerial(pDraw);
|
||||
pPriv->needInvalidate = FALSE;
|
||||
|
||||
|
|
@ -229,7 +229,7 @@ typedef struct DRI2DrawableRefRec {
|
|||
XID dri2_id;
|
||||
DRI2InvalidateProcPtr invalidate;
|
||||
void *priv;
|
||||
struct list link;
|
||||
struct xorg_list link;
|
||||
} DRI2DrawableRefRec, *DRI2DrawableRefPtr;
|
||||
|
||||
static DRI2DrawableRefPtr
|
||||
|
|
@ -237,7 +237,7 @@ DRI2LookupDrawableRef(DRI2DrawablePtr pPriv, XID id)
|
|||
{
|
||||
DRI2DrawableRefPtr ref;
|
||||
|
||||
list_for_each_entry(ref, &pPriv->reference_list, link) {
|
||||
xorg_list_for_each_entry(ref, &pPriv->reference_list, link) {
|
||||
if (ref->id == id)
|
||||
return ref;
|
||||
}
|
||||
|
|
@ -270,7 +270,7 @@ DRI2AddDrawableRef(DRI2DrawablePtr pPriv, XID id, XID dri2_id,
|
|||
ref->dri2_id = dri2_id;
|
||||
ref->invalidate = invalidate;
|
||||
ref->priv = priv;
|
||||
list_add(&ref->link, &pPriv->reference_list);
|
||||
xorg_list_add(&ref->link, &pPriv->reference_list);
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
|
@ -307,9 +307,9 @@ static int DRI2DrawableGone(pointer p, XID id)
|
|||
DrawablePtr pDraw;
|
||||
int i;
|
||||
|
||||
list_for_each_entry_safe(ref, next, &pPriv->reference_list, link) {
|
||||
xorg_list_for_each_entry_safe(ref, next, &pPriv->reference_list, link) {
|
||||
if (ref->dri2_id == id) {
|
||||
list_del(&ref->link);
|
||||
xorg_list_del(&ref->link);
|
||||
/* If this was the last ref under this X drawable XID,
|
||||
* unregister the X drawable resource. */
|
||||
if (!DRI2LookupDrawableRef(pPriv, ref->id))
|
||||
|
|
@ -319,13 +319,13 @@ static int DRI2DrawableGone(pointer p, XID id)
|
|||
}
|
||||
|
||||
if (ref->id == id) {
|
||||
list_del(&ref->link);
|
||||
xorg_list_del(&ref->link);
|
||||
FreeResourceByType(ref->dri2_id, dri2DrawableRes, TRUE);
|
||||
free(ref);
|
||||
}
|
||||
}
|
||||
|
||||
if (!list_is_empty(&pPriv->reference_list))
|
||||
if (!xorg_list_is_empty(&pPriv->reference_list))
|
||||
return Success;
|
||||
|
||||
pDraw = pPriv->drawable;
|
||||
|
|
@ -586,7 +586,7 @@ DRI2InvalidateDrawable(DrawablePtr pDraw)
|
|||
|
||||
pPriv->needInvalidate = FALSE;
|
||||
|
||||
list_for_each_entry(ref, &pPriv->reference_list, link)
|
||||
xorg_list_for_each_entry(ref, &pPriv->reference_list, link)
|
||||
ref->invalidate(pDraw, ref->priv, ref->id);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -67,14 +67,14 @@ xf86ConfigSymTabRec InputClassTab[] =
|
|||
#define TOKEN_SEP "|"
|
||||
|
||||
static void
|
||||
add_group_entry(struct list *head, char **values)
|
||||
add_group_entry(struct xorg_list *head, char **values)
|
||||
{
|
||||
xf86MatchGroup *group;
|
||||
|
||||
group = malloc(sizeof(*group));
|
||||
if (group) {
|
||||
group->values = values;
|
||||
list_add(&group->entry, head);
|
||||
xorg_list_add(&group->entry, head);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -87,15 +87,15 @@ xf86parseInputClassSection(void)
|
|||
parsePrologue(XF86ConfInputClassPtr, XF86ConfInputClassRec)
|
||||
|
||||
/* Initialize MatchGroup lists */
|
||||
list_init(&ptr->match_product);
|
||||
list_init(&ptr->match_vendor);
|
||||
list_init(&ptr->match_device);
|
||||
list_init(&ptr->match_os);
|
||||
list_init(&ptr->match_pnpid);
|
||||
list_init(&ptr->match_usbid);
|
||||
list_init(&ptr->match_driver);
|
||||
list_init(&ptr->match_tag);
|
||||
list_init(&ptr->match_layout);
|
||||
xorg_list_init(&ptr->match_product);
|
||||
xorg_list_init(&ptr->match_vendor);
|
||||
xorg_list_init(&ptr->match_device);
|
||||
xorg_list_init(&ptr->match_os);
|
||||
xorg_list_init(&ptr->match_pnpid);
|
||||
xorg_list_init(&ptr->match_usbid);
|
||||
xorg_list_init(&ptr->match_driver);
|
||||
xorg_list_init(&ptr->match_tag);
|
||||
xorg_list_init(&ptr->match_layout);
|
||||
|
||||
while ((token = xf86getToken(InputClassTab)) != ENDSECTION) {
|
||||
switch (token) {
|
||||
|
|
@ -274,63 +274,63 @@ xf86printInputClassSection (FILE * cf, XF86ConfInputClassPtr ptr)
|
|||
if (ptr->driver)
|
||||
fprintf(cf, "\tDriver \"%s\"\n", ptr->driver);
|
||||
|
||||
list_for_each_entry(group, &ptr->match_product, entry) {
|
||||
xorg_list_for_each_entry(group, &ptr->match_product, entry) {
|
||||
fprintf(cf, "\tMatchProduct \"");
|
||||
for (cur = group->values; *cur; cur++)
|
||||
fprintf(cf, "%s%s", cur == group->values ? "" : TOKEN_SEP,
|
||||
*cur);
|
||||
fprintf(cf, "\"\n");
|
||||
}
|
||||
list_for_each_entry(group, &ptr->match_vendor, entry) {
|
||||
xorg_list_for_each_entry(group, &ptr->match_vendor, entry) {
|
||||
fprintf(cf, "\tMatchVendor \"");
|
||||
for (cur = group->values; *cur; cur++)
|
||||
fprintf(cf, "%s%s", cur == group->values ? "" : TOKEN_SEP,
|
||||
*cur);
|
||||
fprintf(cf, "\"\n");
|
||||
}
|
||||
list_for_each_entry(group, &ptr->match_device, entry) {
|
||||
xorg_list_for_each_entry(group, &ptr->match_device, entry) {
|
||||
fprintf(cf, "\tMatchDevicePath \"");
|
||||
for (cur = group->values; *cur; cur++)
|
||||
fprintf(cf, "%s%s", cur == group->values ? "" : TOKEN_SEP,
|
||||
*cur);
|
||||
fprintf(cf, "\"\n");
|
||||
}
|
||||
list_for_each_entry(group, &ptr->match_os, entry) {
|
||||
xorg_list_for_each_entry(group, &ptr->match_os, entry) {
|
||||
fprintf(cf, "\tMatchOS \"");
|
||||
for (cur = group->values; *cur; cur++)
|
||||
fprintf(cf, "%s%s", cur == group->values ? "" : TOKEN_SEP,
|
||||
*cur);
|
||||
fprintf(cf, "\"\n");
|
||||
}
|
||||
list_for_each_entry(group, &ptr->match_pnpid, entry) {
|
||||
xorg_list_for_each_entry(group, &ptr->match_pnpid, entry) {
|
||||
fprintf(cf, "\tMatchPnPID \"");
|
||||
for (cur = group->values; *cur; cur++)
|
||||
fprintf(cf, "%s%s", cur == group->values ? "" : TOKEN_SEP,
|
||||
*cur);
|
||||
fprintf(cf, "\"\n");
|
||||
}
|
||||
list_for_each_entry(group, &ptr->match_usbid, entry) {
|
||||
xorg_list_for_each_entry(group, &ptr->match_usbid, entry) {
|
||||
fprintf(cf, "\tMatchUSBID \"");
|
||||
for (cur = group->values; *cur; cur++)
|
||||
fprintf(cf, "%s%s", cur == group->values ? "" : TOKEN_SEP,
|
||||
*cur);
|
||||
fprintf(cf, "\"\n");
|
||||
}
|
||||
list_for_each_entry(group, &ptr->match_driver, entry) {
|
||||
xorg_list_for_each_entry(group, &ptr->match_driver, entry) {
|
||||
fprintf(cf, "\tMatchDriver \"");
|
||||
for (cur = group->values; *cur; cur++)
|
||||
fprintf(cf, "%s%s", cur == group->values ? "" : TOKEN_SEP,
|
||||
*cur);
|
||||
fprintf(cf, "\"\n");
|
||||
}
|
||||
list_for_each_entry(group, &ptr->match_tag, entry) {
|
||||
xorg_list_for_each_entry(group, &ptr->match_tag, entry) {
|
||||
fprintf(cf, "\tMatchTag \"");
|
||||
for (cur = group->values; *cur; cur++)
|
||||
fprintf(cf, "%s%s", cur == group->values ? "" : TOKEN_SEP,
|
||||
*cur);
|
||||
fprintf(cf, "\"\n");
|
||||
}
|
||||
list_for_each_entry(group, &ptr->match_layout, entry) {
|
||||
xorg_list_for_each_entry(group, &ptr->match_layout, entry) {
|
||||
fprintf(cf, "\tMatchLayout \"");
|
||||
for (cur = group->values; *cur; cur++)
|
||||
fprintf(cf, "%s%s", cur == group->values ? "" : TOKEN_SEP,
|
||||
|
|
@ -374,56 +374,56 @@ xf86freeInputClassList (XF86ConfInputClassPtr ptr)
|
|||
TestFree(ptr->identifier);
|
||||
TestFree(ptr->driver);
|
||||
|
||||
list_for_each_entry_safe(group, next, &ptr->match_product, entry) {
|
||||
list_del(&group->entry);
|
||||
xorg_list_for_each_entry_safe(group, next, &ptr->match_product, entry) {
|
||||
xorg_list_del(&group->entry);
|
||||
for (list = group->values; *list; list++)
|
||||
free(*list);
|
||||
free(group);
|
||||
}
|
||||
list_for_each_entry_safe(group, next, &ptr->match_vendor, entry) {
|
||||
list_del(&group->entry);
|
||||
xorg_list_for_each_entry_safe(group, next, &ptr->match_vendor, entry) {
|
||||
xorg_list_del(&group->entry);
|
||||
for (list = group->values; *list; list++)
|
||||
free(*list);
|
||||
free(group);
|
||||
}
|
||||
list_for_each_entry_safe(group, next, &ptr->match_device, entry) {
|
||||
list_del(&group->entry);
|
||||
xorg_list_for_each_entry_safe(group, next, &ptr->match_device, entry) {
|
||||
xorg_list_del(&group->entry);
|
||||
for (list = group->values; *list; list++)
|
||||
free(*list);
|
||||
free(group);
|
||||
}
|
||||
list_for_each_entry_safe(group, next, &ptr->match_os, entry) {
|
||||
list_del(&group->entry);
|
||||
xorg_list_for_each_entry_safe(group, next, &ptr->match_os, entry) {
|
||||
xorg_list_del(&group->entry);
|
||||
for (list = group->values; *list; list++)
|
||||
free(*list);
|
||||
free(group);
|
||||
}
|
||||
list_for_each_entry_safe(group, next, &ptr->match_pnpid, entry) {
|
||||
list_del(&group->entry);
|
||||
xorg_list_for_each_entry_safe(group, next, &ptr->match_pnpid, entry) {
|
||||
xorg_list_del(&group->entry);
|
||||
for (list = group->values; *list; list++)
|
||||
free(*list);
|
||||
free(group);
|
||||
}
|
||||
list_for_each_entry_safe(group, next, &ptr->match_usbid, entry) {
|
||||
list_del(&group->entry);
|
||||
xorg_list_for_each_entry_safe(group, next, &ptr->match_usbid, entry) {
|
||||
xorg_list_del(&group->entry);
|
||||
for (list = group->values; *list; list++)
|
||||
free(*list);
|
||||
free(group);
|
||||
}
|
||||
list_for_each_entry_safe(group, next, &ptr->match_driver, entry) {
|
||||
list_del(&group->entry);
|
||||
xorg_list_for_each_entry_safe(group, next, &ptr->match_driver, entry) {
|
||||
xorg_list_del(&group->entry);
|
||||
for (list = group->values; *list; list++)
|
||||
free(*list);
|
||||
free(group);
|
||||
}
|
||||
list_for_each_entry_safe(group, next, &ptr->match_tag, entry) {
|
||||
list_del(&group->entry);
|
||||
xorg_list_for_each_entry_safe(group, next, &ptr->match_tag, entry) {
|
||||
xorg_list_del(&group->entry);
|
||||
for (list = group->values; *list; list++)
|
||||
free(*list);
|
||||
free(group);
|
||||
}
|
||||
list_for_each_entry_safe(group, next, &ptr->match_layout, entry) {
|
||||
list_del(&group->entry);
|
||||
xorg_list_for_each_entry_safe(group, next, &ptr->match_layout, entry) {
|
||||
xorg_list_del(&group->entry);
|
||||
for (list = group->values; *list; list++)
|
||||
free(*list);
|
||||
free(group);
|
||||
|
|
|
|||
|
|
@ -340,7 +340,7 @@ xf86TriState;
|
|||
|
||||
typedef struct
|
||||
{
|
||||
struct list entry;
|
||||
struct xorg_list entry;
|
||||
char **values;
|
||||
}
|
||||
xf86MatchGroup;
|
||||
|
|
@ -350,15 +350,15 @@ typedef struct
|
|||
GenericListRec list;
|
||||
char *identifier;
|
||||
char *driver;
|
||||
struct list match_product;
|
||||
struct list match_vendor;
|
||||
struct list match_device;
|
||||
struct list match_os;
|
||||
struct list match_pnpid;
|
||||
struct list match_usbid;
|
||||
struct list match_driver;
|
||||
struct list match_tag;
|
||||
struct list match_layout;
|
||||
struct xorg_list match_product;
|
||||
struct xorg_list match_vendor;
|
||||
struct xorg_list match_device;
|
||||
struct xorg_list match_os;
|
||||
struct xorg_list match_pnpid;
|
||||
struct xorg_list match_usbid;
|
||||
struct xorg_list match_driver;
|
||||
struct xorg_list match_tag;
|
||||
struct xorg_list match_layout;
|
||||
xf86TriState is_keyboard;
|
||||
xf86TriState is_pointer;
|
||||
xf86TriState is_joystick;
|
||||
|
|
|
|||
|
|
@ -622,7 +622,7 @@ extern _X_EXPORT InputInfo inputInfo;
|
|||
/* for keeping the events for devices grabbed synchronously */
|
||||
typedef struct _QdEvent *QdEventPtr;
|
||||
typedef struct _QdEvent {
|
||||
struct list next;
|
||||
struct xorg_list next;
|
||||
DeviceIntPtr device;
|
||||
ScreenPtr pScreen; /* what screen the pointer was on */
|
||||
unsigned long months; /* milliseconds is in the event */
|
||||
|
|
@ -638,7 +638,7 @@ typedef struct _QdEvent {
|
|||
* replayed and processed as if they would come from the device directly.
|
||||
*/
|
||||
typedef struct _EventSyncInfo {
|
||||
struct list pending;
|
||||
struct xorg_list pending;
|
||||
|
||||
/** The device to replay events for. Only set in AllowEvents(), in which
|
||||
* case it is set to the device specified in the request. */
|
||||
|
|
|
|||
114
include/list.h
114
include/list.h
|
|
@ -23,8 +23,8 @@
|
|||
*
|
||||
*/
|
||||
|
||||
#ifndef _LIST_H_
|
||||
#define _LIST_H_
|
||||
#ifndef _XORG_LIST_H_
|
||||
#define _XORG_LIST_H_
|
||||
|
||||
/**
|
||||
* @file Classic doubly-link circular list implementation.
|
||||
|
|
@ -41,17 +41,17 @@
|
|||
* }
|
||||
*
|
||||
* We need one list head in bar and a list element in all list_of_foos (both are of
|
||||
* data type 'struct list').
|
||||
* data type 'struct xorg_list').
|
||||
*
|
||||
* struct bar {
|
||||
* ...
|
||||
* struct list list_of_foos;
|
||||
* struct xorg_list list_of_foos;
|
||||
* ...
|
||||
* }
|
||||
*
|
||||
* struct foo {
|
||||
* ...
|
||||
* struct list entry;
|
||||
* struct xorg_list entry;
|
||||
* ...
|
||||
* }
|
||||
*
|
||||
|
|
@ -59,74 +59,74 @@
|
|||
*
|
||||
* struct bar bar;
|
||||
* ...
|
||||
* list_init(&bar.list_of_foos);
|
||||
* xorg_list_init(&bar.list_of_foos);
|
||||
*
|
||||
* Then we create the first element and add it to this list:
|
||||
*
|
||||
* struct foo *foo = malloc(...);
|
||||
* ....
|
||||
* list_add(&foo->entry, &bar.list_of_foos);
|
||||
* xorg_list_add(&foo->entry, &bar.list_of_foos);
|
||||
*
|
||||
* Repeat the above for each element you want to add to the list. Deleting
|
||||
* works with the element itself.
|
||||
* list_del(&foo->entry);
|
||||
* xorg_list_del(&foo->entry);
|
||||
* free(foo);
|
||||
*
|
||||
* Note: calling list_del(&bar.list_of_foos) will set bar.list_of_foos to an empty
|
||||
* Note: calling xorg_list_del(&bar.list_of_foos) will set bar.list_of_foos to an empty
|
||||
* list again.
|
||||
*
|
||||
* Looping through the list requires a 'struct foo' as iterator and the
|
||||
* name of the field the subnodes use.
|
||||
*
|
||||
* struct foo *iterator;
|
||||
* list_for_each_entry(iterator, &bar.list_of_foos, entry) {
|
||||
* xorg_list_for_each_entry(iterator, &bar.list_of_foos, entry) {
|
||||
* if (iterator->something == ...)
|
||||
* ...
|
||||
* }
|
||||
*
|
||||
* Note: You must not call list_del() on the iterator if you continue the
|
||||
* Note: You must not call xorg_list_del() on the iterator if you continue the
|
||||
* loop. You need to run the safe for-each loop instead:
|
||||
*
|
||||
* struct foo *iterator, *next;
|
||||
* list_for_each_entry_safe(iterator, next, &bar.list_of_foos, entry) {
|
||||
* xorg_list_for_each_entry_safe(iterator, next, &bar.list_of_foos, entry) {
|
||||
* if (...)
|
||||
* list_del(&iterator->entry);
|
||||
* xorg_list_del(&iterator->entry);
|
||||
* }
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The linkage struct for list nodes. This struct must be part of your
|
||||
* to-be-linked struct. struct list is required for both the head of the
|
||||
* to-be-linked struct. struct xorg_list is required for both the head of the
|
||||
* list and for each list node.
|
||||
*
|
||||
* Position and name of the struct list field is irrelevant.
|
||||
* Position and name of the struct xorg_list field is irrelevant.
|
||||
* There are no requirements that elements of a list are of the same type.
|
||||
* There are no requirements for a list head, any struct list can be a list
|
||||
* There are no requirements for a list head, any struct xorg_list can be a list
|
||||
* head.
|
||||
*/
|
||||
struct list {
|
||||
struct list *next, *prev;
|
||||
struct xorg_list {
|
||||
struct xorg_list *next, *prev;
|
||||
};
|
||||
|
||||
/**
|
||||
* Initialize the list as an empty list.
|
||||
*
|
||||
* Example:
|
||||
* list_init(&bar->list_of_foos);
|
||||
* xorg_list_init(&bar->list_of_foos);
|
||||
*
|
||||
* @param The list to initialized.
|
||||
*/
|
||||
static void
|
||||
list_init(struct list *list)
|
||||
xorg_list_init(struct xorg_list *list)
|
||||
{
|
||||
list->next = list->prev = list;
|
||||
}
|
||||
|
||||
static inline void
|
||||
__list_add(struct list *entry,
|
||||
struct list *prev,
|
||||
struct list *next)
|
||||
__xorg_list_add(struct xorg_list *entry,
|
||||
struct xorg_list *prev,
|
||||
struct xorg_list *next)
|
||||
{
|
||||
next->prev = entry;
|
||||
entry->next = next;
|
||||
|
|
@ -144,15 +144,15 @@ __list_add(struct list *entry,
|
|||
*
|
||||
* Example:
|
||||
* struct foo *newfoo = malloc(...);
|
||||
* list_add(&newfoo->entry, &bar->list_of_foos);
|
||||
* xorg_list_add(&newfoo->entry, &bar->list_of_foos);
|
||||
*
|
||||
* @param entry The new element to prepend to the list.
|
||||
* @param head The existing list.
|
||||
*/
|
||||
static inline void
|
||||
list_add(struct list *entry, struct list *head)
|
||||
xorg_list_add(struct xorg_list *entry, struct xorg_list *head)
|
||||
{
|
||||
__list_add(entry, head, head->next);
|
||||
__xorg_list_add(entry, head, head->next);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -165,20 +165,20 @@ list_add(struct list *entry, struct list *head)
|
|||
*
|
||||
* Example:
|
||||
* struct foo *newfoo = malloc(...);
|
||||
* list_append(&newfoo->entry, &bar->list_of_foos);
|
||||
* xorg_list_append(&newfoo->entry, &bar->list_of_foos);
|
||||
*
|
||||
* @param entry The new element to prepend to the list.
|
||||
* @param head The existing list.
|
||||
*/
|
||||
static inline void
|
||||
list_append(struct list *entry, struct list *head)
|
||||
xorg_list_append(struct xorg_list *entry, struct xorg_list *head)
|
||||
{
|
||||
__list_add(entry, head->prev, head);
|
||||
__xorg_list_add(entry, head->prev, head);
|
||||
}
|
||||
|
||||
|
||||
static inline void
|
||||
__list_del(struct list *prev, struct list *next)
|
||||
__xorg_list_del(struct xorg_list *prev, struct xorg_list *next)
|
||||
{
|
||||
next->prev = prev;
|
||||
prev->next = next;
|
||||
|
|
@ -189,32 +189,32 @@ __list_del(struct list *prev, struct list *next)
|
|||
* the pointers to/from this element so it is removed from the list. It does
|
||||
* NOT free the element itself or manipulate it otherwise.
|
||||
*
|
||||
* Using list_del on a pure list head (like in the example at the top of
|
||||
* Using xorg_list_del on a pure list head (like in the example at the top of
|
||||
* this file) will NOT remove the first element from
|
||||
* the list but rather reset the list as empty list.
|
||||
*
|
||||
* Example:
|
||||
* list_del(&foo->entry);
|
||||
* xorg_list_del(&foo->entry);
|
||||
*
|
||||
* @param entry The element to remove.
|
||||
*/
|
||||
static inline void
|
||||
list_del(struct list *entry)
|
||||
xorg_list_del(struct xorg_list *entry)
|
||||
{
|
||||
__list_del(entry->prev, entry->next);
|
||||
list_init(entry);
|
||||
__xorg_list_del(entry->prev, entry->next);
|
||||
xorg_list_init(entry);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if the list is empty.
|
||||
*
|
||||
* Example:
|
||||
* list_is_empty(&bar->list_of_foos);
|
||||
* xorg_list_is_empty(&bar->list_of_foos);
|
||||
*
|
||||
* @return True if the list contains one or more elements or False otherwise.
|
||||
*/
|
||||
static inline Bool
|
||||
list_is_empty(struct list *head)
|
||||
xorg_list_is_empty(struct xorg_list *head)
|
||||
{
|
||||
return head->next == head;
|
||||
}
|
||||
|
|
@ -227,9 +227,9 @@ list_is_empty(struct list *head)
|
|||
* f = container_of(&foo->entry, struct foo, entry);
|
||||
* assert(f == foo);
|
||||
*
|
||||
* @param ptr Pointer to the struct list.
|
||||
* @param ptr Pointer to the struct xorg_list.
|
||||
* @param type Data type of the list element.
|
||||
* @param member Member name of the struct list field in the list element.
|
||||
* @param member Member name of the struct xorg_list field in the list element.
|
||||
* @return A pointer to the data struct containing the list head.
|
||||
*/
|
||||
#ifndef container_of
|
||||
|
|
@ -240,7 +240,7 @@ list_is_empty(struct list *head)
|
|||
/**
|
||||
* Alias of container_of
|
||||
*/
|
||||
#define list_entry(ptr, type, member) \
|
||||
#define xorg_list_entry(ptr, type, member) \
|
||||
container_of(ptr, type, member)
|
||||
|
||||
/**
|
||||
|
|
@ -248,30 +248,30 @@ list_is_empty(struct list *head)
|
|||
*
|
||||
* Example:
|
||||
* struct foo *first;
|
||||
* first = list_first_entry(&bar->list_of_foos, struct foo, list_of_foos);
|
||||
* first = xorg_list_first_entry(&bar->list_of_foos, struct foo, list_of_foos);
|
||||
*
|
||||
* @param ptr The list head
|
||||
* @param type Data type of the list element to retrieve
|
||||
* @param member Member name of the struct list field in the list element.
|
||||
* @param member Member name of the struct xorg_list field in the list element.
|
||||
* @return A pointer to the first list element.
|
||||
*/
|
||||
#define list_first_entry(ptr, type, member) \
|
||||
list_entry((ptr)->next, type, member)
|
||||
#define xorg_list_first_entry(ptr, type, member) \
|
||||
xorg_list_entry((ptr)->next, type, member)
|
||||
|
||||
/**
|
||||
* Retrieve the last list entry for the given listpointer.
|
||||
*
|
||||
* Example:
|
||||
* struct foo *first;
|
||||
* first = list_last_entry(&bar->list_of_foos, struct foo, list_of_foos);
|
||||
* first = xorg_list_last_entry(&bar->list_of_foos, struct foo, list_of_foos);
|
||||
*
|
||||
* @param ptr The list head
|
||||
* @param type Data type of the list element to retrieve
|
||||
* @param member Member name of the struct list field in the list element.
|
||||
* @param member Member name of the struct xorg_list field in the list element.
|
||||
* @return A pointer to the last list element.
|
||||
*/
|
||||
#define list_last_entry(ptr, type, member) \
|
||||
list_entry((ptr)->prev, type, member)
|
||||
#define xorg_list_last_entry(ptr, type, member) \
|
||||
xorg_list_entry((ptr)->prev, type, member)
|
||||
|
||||
#define __container_of(ptr, sample, member) \
|
||||
(void *)((char *)(ptr) \
|
||||
|
|
@ -281,19 +281,19 @@ list_is_empty(struct list *head)
|
|||
*
|
||||
* Example:
|
||||
* struct foo *iterator;
|
||||
* list_for_each_entry(iterator, &bar->list_of_foos, entry) {
|
||||
* xorg_list_for_each_entry(iterator, &bar->list_of_foos, entry) {
|
||||
* [modify iterator]
|
||||
* }
|
||||
*
|
||||
* This macro is not safe for node deletion. Use list_for_each_entry_safe
|
||||
* This macro is not safe for node deletion. Use xorg_list_for_each_entry_safe
|
||||
* instead.
|
||||
*
|
||||
* @param pos Iterator variable of the type of the list elements.
|
||||
* @param head List head
|
||||
* @param member Member name of the struct list in the list elements.
|
||||
* @param member Member name of the struct xorg_list in the list elements.
|
||||
*
|
||||
*/
|
||||
#define list_for_each_entry(pos, head, member) \
|
||||
#define xorg_list_for_each_entry(pos, head, member) \
|
||||
for (pos = __container_of((head)->next, pos, member); \
|
||||
&pos->member != (head); \
|
||||
pos = __container_of(pos->member.next, pos, member))
|
||||
|
|
@ -303,9 +303,9 @@ list_is_empty(struct list *head)
|
|||
* macro allows for the deletion of a list element while looping through the
|
||||
* list.
|
||||
*
|
||||
* See list_for_each_entry for more details.
|
||||
* See xorg_list_for_each_entry for more details.
|
||||
*/
|
||||
#define list_for_each_entry_safe(pos, tmp, head, member) \
|
||||
#define xorg_list_for_each_entry_safe(pos, tmp, head, member) \
|
||||
for (pos = __container_of((head)->next, pos, member), \
|
||||
tmp = __container_of(pos->member.next, pos, member); \
|
||||
&pos->member != (head); \
|
||||
|
|
@ -315,9 +315,9 @@ list_is_empty(struct list *head)
|
|||
|
||||
/* NULL-Terminated List Interface
|
||||
*
|
||||
* The interface below does _not_ use the struct list as described above.
|
||||
* The interface below does _not_ use the struct xorg_list as described above.
|
||||
* It is mainly for legacy structures that cannot easily be switched to
|
||||
* struct list.
|
||||
* struct xorg_list.
|
||||
*
|
||||
* This interface is for structs like
|
||||
* struct foo {
|
||||
|
|
@ -349,7 +349,7 @@ list_is_empty(struct list *head)
|
|||
* struct foo *element = list;
|
||||
* while ((element = nt_list_next(element, next)) { }
|
||||
*
|
||||
* This macro is not safe for node deletion. Use list_for_each_entry_safe
|
||||
* This macro is not safe for node deletion. Use xorg_list_for_each_entry_safe
|
||||
* instead.
|
||||
*
|
||||
* @param list The list or current element.
|
||||
|
|
|
|||
12
test/input.c
12
test/input.c
|
|
@ -1714,7 +1714,7 @@ dix_enqueue_events(void) {
|
|||
spriteInfo.sprite = &sprite;
|
||||
|
||||
InitEvents();
|
||||
assert(list_is_empty(&syncEvents.pending));
|
||||
assert(xorg_list_is_empty(&syncEvents.pending));
|
||||
|
||||
/* this way PlayReleasedEvents really runs through all events in the
|
||||
* queue */
|
||||
|
|
@ -1728,22 +1728,22 @@ dix_enqueue_events(void) {
|
|||
ev[i].any.length = sizeof(*ev);
|
||||
ev[i].any.type = i;
|
||||
EnqueueEvent(&ev[i], &dev);
|
||||
assert(!list_is_empty(&syncEvents.pending));
|
||||
qe = list_last_entry(&syncEvents.pending, QdEventRec, next);
|
||||
assert(!xorg_list_is_empty(&syncEvents.pending));
|
||||
qe = xorg_list_last_entry(&syncEvents.pending, QdEventRec, next);
|
||||
assert(memcmp(qe->event, &ev[i], ev[i].any.length) == 0);
|
||||
qe = list_first_entry(&syncEvents.pending, QdEventRec, next);
|
||||
qe = xorg_list_first_entry(&syncEvents.pending, QdEventRec, next);
|
||||
assert(memcmp(qe->event, &ev[0], ev[i].any.length) == 0);
|
||||
}
|
||||
|
||||
/* calls process_input_proc */
|
||||
dev.deviceGrab.sync.frozen = 1;
|
||||
PlayReleasedEvents();
|
||||
assert(!list_is_empty(&syncEvents.pending));
|
||||
assert(!xorg_list_is_empty(&syncEvents.pending));
|
||||
|
||||
|
||||
dev.deviceGrab.sync.frozen = 0;
|
||||
PlayReleasedEvents();
|
||||
assert(list_is_empty(&syncEvents.pending));
|
||||
assert(xorg_list_is_empty(&syncEvents.pending));
|
||||
|
||||
inputInfo.devices = NULL;
|
||||
}
|
||||
|
|
|
|||
132
test/list.c
132
test/list.c
|
|
@ -33,18 +33,18 @@
|
|||
|
||||
struct parent {
|
||||
int a;
|
||||
struct list children;
|
||||
struct xorg_list children;
|
||||
int b;
|
||||
};
|
||||
|
||||
struct child {
|
||||
int foo;
|
||||
int bar;
|
||||
struct list node;
|
||||
struct xorg_list node;
|
||||
};
|
||||
|
||||
static void
|
||||
test_list_init(void)
|
||||
test_xorg_list_init(void)
|
||||
{
|
||||
struct parent parent, tmp;
|
||||
|
||||
|
|
@ -54,146 +54,146 @@ test_list_init(void)
|
|||
|
||||
tmp = parent;
|
||||
|
||||
list_init(&parent.children);
|
||||
xorg_list_init(&parent.children);
|
||||
|
||||
/* test we haven't touched anything else. */
|
||||
assert(parent.a == tmp.a);
|
||||
assert(parent.b == tmp.b);
|
||||
|
||||
assert(list_is_empty(&parent.children));
|
||||
assert(xorg_list_is_empty(&parent.children));
|
||||
}
|
||||
|
||||
static void
|
||||
test_list_add(void)
|
||||
test_xorg_list_add(void)
|
||||
{
|
||||
struct parent parent = {0};
|
||||
struct child child[3];
|
||||
struct child *c;
|
||||
|
||||
list_init(&parent.children);
|
||||
xorg_list_init(&parent.children);
|
||||
|
||||
list_add(&child[0].node, &parent.children);
|
||||
assert(!list_is_empty(&parent.children));
|
||||
xorg_list_add(&child[0].node, &parent.children);
|
||||
assert(!xorg_list_is_empty(&parent.children));
|
||||
|
||||
c = list_first_entry(&parent.children, struct child, node);
|
||||
c = xorg_list_first_entry(&parent.children, struct child, node);
|
||||
assert(memcmp(c, &child[0], sizeof(struct child)) == 0);
|
||||
|
||||
/* note: list_add prepends */
|
||||
list_add(&child[1].node, &parent.children);
|
||||
c = list_first_entry(&parent.children, struct child, node);
|
||||
/* note: xorg_list_add prepends */
|
||||
xorg_list_add(&child[1].node, &parent.children);
|
||||
c = xorg_list_first_entry(&parent.children, struct child, node);
|
||||
assert(memcmp(c, &child[1], sizeof(struct child)) == 0);
|
||||
|
||||
list_add(&child[2].node, &parent.children);
|
||||
c = list_first_entry(&parent.children, struct child, node);
|
||||
xorg_list_add(&child[2].node, &parent.children);
|
||||
c = xorg_list_first_entry(&parent.children, struct child, node);
|
||||
assert(memcmp(c, &child[2], sizeof(struct child)) == 0);
|
||||
};
|
||||
|
||||
static void
|
||||
test_list_append(void)
|
||||
test_xorg_list_append(void)
|
||||
{
|
||||
struct parent parent = {0};
|
||||
struct child child[3];
|
||||
struct child *c;
|
||||
int i;
|
||||
|
||||
list_init(&parent.children);
|
||||
xorg_list_init(&parent.children);
|
||||
|
||||
list_append(&child[0].node, &parent.children);
|
||||
assert(!list_is_empty(&parent.children));
|
||||
xorg_list_append(&child[0].node, &parent.children);
|
||||
assert(!xorg_list_is_empty(&parent.children));
|
||||
|
||||
c = list_first_entry(&parent.children, struct child, node);
|
||||
c = xorg_list_first_entry(&parent.children, struct child, node);
|
||||
assert(memcmp(c, &child[0], sizeof(struct child)) == 0);
|
||||
c = list_last_entry(&parent.children, struct child, node);
|
||||
c = xorg_list_last_entry(&parent.children, struct child, node);
|
||||
assert(memcmp(c, &child[0], sizeof(struct child)) == 0);
|
||||
|
||||
list_append(&child[1].node, &parent.children);
|
||||
c = list_first_entry(&parent.children, struct child, node);
|
||||
xorg_list_append(&child[1].node, &parent.children);
|
||||
c = xorg_list_first_entry(&parent.children, struct child, node);
|
||||
assert(memcmp(c, &child[0], sizeof(struct child)) == 0);
|
||||
c = list_last_entry(&parent.children, struct child, node);
|
||||
c = xorg_list_last_entry(&parent.children, struct child, node);
|
||||
assert(memcmp(c, &child[1], sizeof(struct child)) == 0);
|
||||
|
||||
list_append(&child[2].node, &parent.children);
|
||||
c = list_first_entry(&parent.children, struct child, node);
|
||||
xorg_list_append(&child[2].node, &parent.children);
|
||||
c = xorg_list_first_entry(&parent.children, struct child, node);
|
||||
assert(memcmp(c, &child[0], sizeof(struct child)) == 0);
|
||||
c = list_last_entry(&parent.children, struct child, node);
|
||||
c = xorg_list_last_entry(&parent.children, struct child, node);
|
||||
assert(memcmp(c, &child[2], sizeof(struct child)) == 0);
|
||||
|
||||
i = 0;
|
||||
list_for_each_entry(c, &parent.children, node) {
|
||||
xorg_list_for_each_entry(c, &parent.children, node) {
|
||||
assert(memcmp(c, &child[i++], sizeof(struct child)) == 0);
|
||||
}
|
||||
};
|
||||
|
||||
static void
|
||||
test_list_del(void)
|
||||
test_xorg_list_del(void)
|
||||
{
|
||||
struct parent parent = {0};
|
||||
struct child child[3];
|
||||
struct child *c;
|
||||
|
||||
list_init(&parent.children);
|
||||
xorg_list_init(&parent.children);
|
||||
|
||||
list_add(&child[0].node, &parent.children);
|
||||
assert(!list_is_empty(&parent.children));
|
||||
xorg_list_add(&child[0].node, &parent.children);
|
||||
assert(!xorg_list_is_empty(&parent.children));
|
||||
|
||||
list_del(&parent.children);
|
||||
assert(list_is_empty(&parent.children));
|
||||
xorg_list_del(&parent.children);
|
||||
assert(xorg_list_is_empty(&parent.children));
|
||||
|
||||
list_add(&child[0].node, &parent.children);
|
||||
list_del(&child[0].node);
|
||||
assert(list_is_empty(&parent.children));
|
||||
xorg_list_add(&child[0].node, &parent.children);
|
||||
xorg_list_del(&child[0].node);
|
||||
assert(xorg_list_is_empty(&parent.children));
|
||||
|
||||
list_add(&child[0].node, &parent.children);
|
||||
list_add(&child[1].node, &parent.children);
|
||||
xorg_list_add(&child[0].node, &parent.children);
|
||||
xorg_list_add(&child[1].node, &parent.children);
|
||||
|
||||
c = list_first_entry(&parent.children, struct child, node);
|
||||
c = xorg_list_first_entry(&parent.children, struct child, node);
|
||||
assert(memcmp(c, &child[1], sizeof(struct child)) == 0);
|
||||
|
||||
/* delete first node */
|
||||
list_del(&child[1].node);
|
||||
assert(!list_is_empty(&parent.children));
|
||||
assert(list_is_empty(&child[1].node));
|
||||
c = list_first_entry(&parent.children, struct child, node);
|
||||
xorg_list_del(&child[1].node);
|
||||
assert(!xorg_list_is_empty(&parent.children));
|
||||
assert(xorg_list_is_empty(&child[1].node));
|
||||
c = xorg_list_first_entry(&parent.children, struct child, node);
|
||||
assert(memcmp(c, &child[0], sizeof(struct child)) == 0);
|
||||
|
||||
/* delete last node */
|
||||
list_add(&child[1].node, &parent.children);
|
||||
list_del(&child[0].node);
|
||||
c = list_first_entry(&parent.children, struct child, node);
|
||||
xorg_list_add(&child[1].node, &parent.children);
|
||||
xorg_list_del(&child[0].node);
|
||||
c = xorg_list_first_entry(&parent.children, struct child, node);
|
||||
assert(memcmp(c, &child[1], sizeof(struct child)) == 0);
|
||||
|
||||
/* delete list head */
|
||||
list_add(&child[0].node, &parent.children);
|
||||
list_del(&parent.children);
|
||||
assert(list_is_empty(&parent.children));
|
||||
assert(!list_is_empty(&child[1].node));
|
||||
assert(!list_is_empty(&child[2].node));
|
||||
xorg_list_add(&child[0].node, &parent.children);
|
||||
xorg_list_del(&parent.children);
|
||||
assert(xorg_list_is_empty(&parent.children));
|
||||
assert(!xorg_list_is_empty(&child[1].node));
|
||||
assert(!xorg_list_is_empty(&child[2].node));
|
||||
}
|
||||
|
||||
static void
|
||||
test_list_for_each(void)
|
||||
test_xorg_list_for_each(void)
|
||||
{
|
||||
struct parent parent = {0};
|
||||
struct child child[3];
|
||||
struct child *c;
|
||||
int i = 0;
|
||||
|
||||
list_init(&parent.children);
|
||||
xorg_list_init(&parent.children);
|
||||
|
||||
list_add(&child[2].node, &parent.children);
|
||||
list_add(&child[1].node, &parent.children);
|
||||
list_add(&child[0].node, &parent.children);
|
||||
xorg_list_add(&child[2].node, &parent.children);
|
||||
xorg_list_add(&child[1].node, &parent.children);
|
||||
xorg_list_add(&child[0].node, &parent.children);
|
||||
|
||||
list_for_each_entry(c, &parent.children, node) {
|
||||
xorg_list_for_each_entry(c, &parent.children, node) {
|
||||
assert(memcmp(c, &child[i], sizeof(struct child)) == 0);
|
||||
i++;
|
||||
}
|
||||
|
||||
/* foreach on empty list */
|
||||
list_del(&parent.children);
|
||||
assert(list_is_empty(&parent.children));
|
||||
xorg_list_del(&parent.children);
|
||||
assert(xorg_list_is_empty(&parent.children));
|
||||
|
||||
list_for_each_entry(c, &parent.children, node) {
|
||||
xorg_list_for_each_entry(c, &parent.children, node) {
|
||||
assert(0); /* we must not get here */
|
||||
}
|
||||
}
|
||||
|
|
@ -359,11 +359,11 @@ test_nt_list_delete(void)
|
|||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
test_list_init();
|
||||
test_list_add();
|
||||
test_list_append();
|
||||
test_list_del();
|
||||
test_list_for_each();
|
||||
test_xorg_list_init();
|
||||
test_xorg_list_add();
|
||||
test_xorg_list_append();
|
||||
test_xorg_list_del();
|
||||
test_xorg_list_for_each();
|
||||
|
||||
test_nt_list_init();
|
||||
test_nt_list_append();
|
||||
|
|
|
|||
|
|
@ -116,7 +116,7 @@ typedef struct PointerBarrierClient *PointerBarrierClientPtr;
|
|||
struct PointerBarrierClient {
|
||||
ScreenPtr screen;
|
||||
struct PointerBarrier barrier;
|
||||
struct list entry;
|
||||
struct xorg_list entry;
|
||||
};
|
||||
|
||||
/*
|
||||
|
|
@ -128,7 +128,7 @@ typedef struct _CursorScreen {
|
|||
CloseScreenProcPtr CloseScreen;
|
||||
ConstrainCursorHarderProcPtr ConstrainCursorHarder;
|
||||
CursorHideCountPtr pCursorHideCounts;
|
||||
struct list barriers;
|
||||
struct xorg_list barriers;
|
||||
} CursorScreenRec, *CursorScreenPtr;
|
||||
|
||||
#define GetCursorScreen(s) ((CursorScreenPtr)dixLookupPrivate(&(s)->devPrivates, CursorScreenPrivateKey))
|
||||
|
|
@ -1172,7 +1172,7 @@ barrier_find_nearest(CursorScreenPtr cs, int dir,
|
|||
struct PointerBarrier *nearest = NULL;
|
||||
double min_distance = INT_MAX; /* can't get higher than that in X anyway */
|
||||
|
||||
list_for_each_entry(c, &cs->barriers, entry) {
|
||||
xorg_list_for_each_entry(c, &cs->barriers, entry) {
|
||||
struct PointerBarrier *b = &c->barrier;
|
||||
double distance;
|
||||
|
||||
|
|
@ -1224,7 +1224,7 @@ CursorConstrainCursorHarder(DeviceIntPtr dev, ScreenPtr screen, int mode, int *x
|
|||
{
|
||||
CursorScreenPtr cs = GetCursorScreen(screen);
|
||||
|
||||
if (!list_is_empty(&cs->barriers) && !IsFloating(dev) && mode == Relative) {
|
||||
if (!xorg_list_is_empty(&cs->barriers) && !IsFloating(dev) && mode == Relative) {
|
||||
int ox, oy;
|
||||
int dir;
|
||||
struct PointerBarrier *nearest = NULL;
|
||||
|
|
@ -1285,7 +1285,7 @@ CreatePointerBarrierClient(ScreenPtr screen, ClientPtr client,
|
|||
ret->barrier.directions &= ~(BarrierPositiveX | BarrierNegativeX);
|
||||
if (barrier_is_vertical(&ret->barrier))
|
||||
ret->barrier.directions &= ~(BarrierPositiveY | BarrierNegativeY);
|
||||
list_add(&ret->entry, &cs->barriers);
|
||||
xorg_list_add(&ret->entry, &cs->barriers);
|
||||
}
|
||||
|
||||
return ret;
|
||||
|
|
@ -1364,9 +1364,9 @@ CursorFreeBarrier(void *data, XID id)
|
|||
cs = GetCursorScreen(screen);
|
||||
|
||||
/* find and unlink from the screen private */
|
||||
list_for_each_entry(b, &cs->barriers, entry) {
|
||||
xorg_list_for_each_entry(b, &cs->barriers, entry) {
|
||||
if (b == barrier) {
|
||||
list_del(&b->entry);
|
||||
xorg_list_del(&b->entry);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -1426,7 +1426,7 @@ XFixesCursorInit (void)
|
|||
cs = (CursorScreenPtr) calloc(1, sizeof (CursorScreenRec));
|
||||
if (!cs)
|
||||
return FALSE;
|
||||
list_init(&cs->barriers);
|
||||
xorg_list_init(&cs->barriers);
|
||||
Wrap (cs, pScreen, CloseScreen, CursorCloseScreen);
|
||||
Wrap (cs, pScreen, DisplayCursor, CursorDisplayCursor);
|
||||
Wrap (cs, pScreen, ConstrainCursorHarder, CursorConstrainCursorHarder);
|
||||
|
|
|
|||
Loading…
Reference in New Issue