[PATCH 2/2] Namespace list api to reduce conflicts with similar system headers

Peter Hutterer peter.hutterer at who-t.net
Sat Jan 28 03:33:14 PST 2012


On Fri, Jan 27, 2012 at 09:55:31PM -0800, Alan Coopersmith wrote:
> Rename functions/macros from list_* to xorg_list_*
> Rename struct from struct list to struct xorg_list.
> 
> Signed-off-by: Alan Coopersmith <alan.coopersmith at oracle.com>

I think if we're renaming the API, we should also prefix the nt_list macros.
Not that anyone should use them, but...

In-sed-I-trust: Peter Hutterer <peter.hutterer at who-t.net>

Cheers,
  Peter

> ---
>  dix/events.c                   |   18 +++---
>  hw/xfree86/common/xf86Xinput.c |   10 ++--
>  hw/xfree86/dri2/dri2.c         |   20 +++---
>  hw/xfree86/parser/InputClass.c |   76 ++++++++++++------------
>  hw/xfree86/parser/xf86Parser.h |   20 +++---
>  include/inputstr.h             |    4 +-
>  include/list.h                 |  114 +++++++++++++++++-----------------
>  test/input.c                   |   12 ++--
>  test/list.c                    |  132 ++++++++++++++++++++--------------------
>  xfixes/cursor.c                |   16 +++---
>  10 files changed, 211 insertions(+), 211 deletions(-)
> 
> diff --git a/dix/events.c b/dix/events.c
> index 04d7fb5..e9f3685 100644
> --- a/dix/events.c
> +++ b/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 */
> diff --git a/hw/xfree86/common/xf86Xinput.c b/hw/xfree86/common/xf86Xinput.c
> index fd40f28..f6be999 100644
> --- a/hw/xfree86/common/xf86Xinput.c
> +++ b/hw/xfree86/common/xf86Xinput.c
> @@ -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;
> diff --git a/hw/xfree86/dri2/dri2.c b/hw/xfree86/dri2/dri2.c
> index d6441a2..5cc9068 100644
> --- a/hw/xfree86/dri2/dri2.c
> +++ b/hw/xfree86/dri2/dri2.c
> @@ -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);
>  }
>  
> diff --git a/hw/xfree86/parser/InputClass.c b/hw/xfree86/parser/InputClass.c
> index 919ae18..c25117c 100644
> --- a/hw/xfree86/parser/InputClass.c
> +++ b/hw/xfree86/parser/InputClass.c
> @@ -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);
> diff --git a/hw/xfree86/parser/xf86Parser.h b/hw/xfree86/parser/xf86Parser.h
> index 7d4662b..beac354 100644
> --- a/hw/xfree86/parser/xf86Parser.h
> +++ b/hw/xfree86/parser/xf86Parser.h
> @@ -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;
> diff --git a/include/inputstr.h b/include/inputstr.h
> index c3297db..8a08f67 100644
> --- a/include/inputstr.h
> +++ b/include/inputstr.h
> @@ -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. */
> diff --git a/include/list.h b/include/list.h
> index 6ec2bac..14c671f 100644
> --- a/include/list.h
> +++ b/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.
> diff --git a/test/input.c b/test/input.c
> index 576cd85..e029141 100644
> --- a/test/input.c
> +++ b/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;
>  }
> diff --git a/test/list.c b/test/list.c
> index ffb85ef..14bc74a 100644
> --- a/test/list.c
> +++ b/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();
> diff --git a/xfixes/cursor.c b/xfixes/cursor.c
> index 53f9f20..7c46269 100644
> --- a/xfixes/cursor.c
> +++ b/xfixes/cursor.c
> @@ -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);
> -- 
> 1.7.3.2
> 
> _______________________________________________
> xorg-devel at lists.x.org: X.Org development
> Archives: http://lists.x.org/archives/xorg-devel
> Info: http://lists.x.org/mailman/listinfo/xorg-devel
> 


More information about the xorg-devel mailing list