From c12a473f29cfadb62d38b0fffc36762d8e626676 Mon Sep 17 00:00:00 2001
From: Alan Coopersmith <alan.coopersmith@oracle.com>
Date: Sun, 26 Jan 2014 20:02:20 -0800
Subject: xfixes: unvalidated length in SProcXFixesSelectSelectionInput
 [CVE-2014-8102]

Signed-off-by: Alan Coopersmith <alan.coopersmith@oracle.com>
Reviewed-by: Peter Hutterer <peter.hutterer@who-t.net>

v2: backport to nx-libs 3.6.x (Mike DePaulo)

Conflicts:
	xfixes/select.c
---
 nx-X11/programs/Xserver/xfixes/select.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nx-X11/programs/Xserver/xfixes/select.c')

diff --git a/nx-X11/programs/Xserver/xfixes/select.c b/nx-X11/programs/Xserver/xfixes/select.c
index c72e19e9a..4b8bd01ed 100755
--- a/nx-X11/programs/Xserver/xfixes/select.c
+++ b/nx-X11/programs/Xserver/xfixes/select.c
@@ -216,6 +216,7 @@ SProcXFixesSelectSelectionInput (ClientPtr client)
     register int n;
     REQUEST(xXFixesSelectSelectionInputReq);
 
+    REQUEST_SIZE_MATCH(xXFixesSelectSelectionInputReq);
     swaps(&stuff->length, n);
     swapl(&stuff->window, n);
     swapl(&stuff->selection, n);
-- 
cgit v1.2.3


From d088698324d5e71cb93ccd429f084729ba07872c Mon Sep 17 00:00:00 2001
From: Peter Åstrand <astrand@cendio.se>
Date: Fri, 13 Feb 2009 10:23:28 +0100
Subject: Backport: xserver: Avoid sending uninitialized padding data over the
 network

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>
---
 nx-X11/programs/Xserver/Xext/bigreq.c            |  1 +
 nx-X11/programs/Xserver/Xext/shape.c             |  2 ++
 nx-X11/programs/Xserver/Xext/shm.c               |  1 +
 nx-X11/programs/Xserver/Xext/sync.c              |  1 +
 nx-X11/programs/Xserver/Xi/getvers.c             |  1 +
 nx-X11/programs/Xserver/Xi/listdev.c             |  3 ++-
 nx-X11/programs/Xserver/Xi/opendev.c             |  1 +
 nx-X11/programs/Xserver/dix/devices.c            |  2 ++
 nx-X11/programs/Xserver/dix/dispatch.c           | 20 +++++++++++++++++++-
 nx-X11/programs/Xserver/dix/dixfonts.c           |  2 ++
 nx-X11/programs/Xserver/dix/events.c             |  4 ++++
 nx-X11/programs/Xserver/dix/extension.c          |  2 ++
 nx-X11/programs/Xserver/dix/main.c               |  4 ++++
 nx-X11/programs/Xserver/dix/property.c           |  1 +
 nx-X11/programs/Xserver/dix/window.c             | 13 +++++++++++++
 nx-X11/programs/Xserver/hw/nxagent/Keyboard.c    |  2 ++
 nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c  | 20 +++++++++++++++++++-
 nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c  |  2 ++
 nx-X11/programs/Xserver/hw/nxagent/NXevents.c    |  6 ++++++
 nx-X11/programs/Xserver/hw/nxagent/NXextension.c |  2 ++
 nx-X11/programs/Xserver/hw/nxagent/NXmiexpose.c  |  3 ++-
 nx-X11/programs/Xserver/hw/nxagent/NXproperty.c  |  1 +
 nx-X11/programs/Xserver/hw/nxagent/NXrender.c    |  2 ++
 nx-X11/programs/Xserver/hw/nxagent/NXshm.c       |  1 +
 nx-X11/programs/Xserver/hw/nxagent/NXwindow.c    | 13 +++++++++++++
 nx-X11/programs/Xserver/mi/miexpose.c            |  2 ++
 nx-X11/programs/Xserver/randr/rrxinerama.c       |  3 ++-
 nx-X11/programs/Xserver/render/render.c          |  3 +++
 nx-X11/programs/Xserver/xfixes/select.c          |  2 ++
 nx-X11/programs/Xserver/xfixes/xfixes.c          |  1 +
 nx-X11/programs/Xserver/xkb/xkb.c                |  9 +++++++++
 nx-X11/programs/Xserver/xkb/xkbEvents.c          |  6 ++++++
 32 files changed, 131 insertions(+), 5 deletions(-)

(limited to 'nx-X11/programs/Xserver/xfixes/select.c')

diff --git a/nx-X11/programs/Xserver/Xext/bigreq.c b/nx-X11/programs/Xserver/Xext/bigreq.c
index 1af8a930b..3d6d49ca7 100644
--- a/nx-X11/programs/Xserver/Xext/bigreq.c
+++ b/nx-X11/programs/Xserver/Xext/bigreq.c
@@ -94,6 +94,7 @@ ProcBigReqDispatch (client)
 	return BadRequest;
     REQUEST_SIZE_MATCH(xBigReqEnableReq);
     client->big_requests = TRUE;
+    memset(&rep, 0, sizeof(xBigReqEnableReply));
     rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
diff --git a/nx-X11/programs/Xserver/Xext/shape.c b/nx-X11/programs/Xserver/Xext/shape.c
index 3fa16081a..86b4b5603 100644
--- a/nx-X11/programs/Xserver/Xext/shape.c
+++ b/nx-X11/programs/Xserver/Xext/shape.c
@@ -292,6 +292,7 @@ ProcShapeQueryVersion (client)
     register int		n;
 
     REQUEST_SIZE_MATCH (xShapeQueryVersionReq);
+    memset(&rep, 0, sizeof(xShapeQueryVersionReply));
     rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
@@ -717,6 +718,7 @@ ProcShapeQueryExtents (client)
     RegionPtr		region;
 
     REQUEST_SIZE_MATCH (xShapeQueryExtentsReq);
+    memset(&rep, 0, sizeof(xShapeQueryExtentsReply));
     pWin = LookupWindow (stuff->window, client);
     if (!pWin)
 	return BadWindow;
diff --git a/nx-X11/programs/Xserver/Xext/shm.c b/nx-X11/programs/Xserver/Xext/shm.c
index f25bb9b5d..dfb85c3ec 100644
--- a/nx-X11/programs/Xserver/Xext/shm.c
+++ b/nx-X11/programs/Xserver/Xext/shm.c
@@ -346,6 +346,7 @@ ProcShmQueryVersion(client)
     register int n;
 
     REQUEST_SIZE_MATCH(xShmQueryVersionReq);
+    memset(&rep, 0, sizeof(xShmQueryVersionReply));
     rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
diff --git a/nx-X11/programs/Xserver/Xext/sync.c b/nx-X11/programs/Xserver/Xext/sync.c
index 0e0df8305..e5b8ef946 100644
--- a/nx-X11/programs/Xserver/Xext/sync.c
+++ b/nx-X11/programs/Xserver/Xext/sync.c
@@ -1346,6 +1346,7 @@ ProcSyncInitialize(client)
 
     REQUEST_SIZE_MATCH(xSyncInitializeReq);
 
+    memset(&rep, 0, sizeof(xSyncInitializeReply));
     rep.type = X_Reply;
     rep.sequenceNumber = client->sequence;
     rep.majorVersion = SYNC_MAJOR_VERSION;
diff --git a/nx-X11/programs/Xserver/Xi/getvers.c b/nx-X11/programs/Xserver/Xi/getvers.c
index 1ad0ce785..3a335dd31 100644
--- a/nx-X11/programs/Xserver/Xi/getvers.c
+++ b/nx-X11/programs/Xserver/Xi/getvers.c
@@ -114,6 +114,7 @@ ProcXGetExtensionVersion (client)
 	return Success;
 	}
 
+    memset(&rep, 0, sizeof(xGetExtensionVersionReply));
     rep.repType = X_Reply;
     rep.RepType = X_GetExtensionVersion;
     rep.length = 0;
diff --git a/nx-X11/programs/Xserver/Xi/listdev.c b/nx-X11/programs/Xserver/Xi/listdev.c
index b7eed86b7..6228352f5 100644
--- a/nx-X11/programs/Xserver/Xi/listdev.c
+++ b/nx-X11/programs/Xserver/Xi/listdev.c
@@ -114,6 +114,7 @@ ProcXListInputDevices (client)
 
     REQUEST_SIZE_MATCH(xListInputDevicesReq);
 
+    memset(&rep, 0, sizeof(xListInputDevicesReply));
     rep.repType = X_Reply;
     rep.RepType = X_ListInputDevices;
     rep.length = 0;
@@ -128,7 +129,7 @@ ProcXListInputDevices (client)
 	SizeDeviceInfo (d, &namesize, &size);
 
     total_length = numdevs * sizeof (xDeviceInfo) + size + namesize;
-    devbuf = (char *) xalloc (total_length);
+    devbuf = (char *) xcalloc (1, total_length);
     classbuf = devbuf + (numdevs * sizeof (xDeviceInfo));
     namebuf = classbuf + size;
     savbuf = devbuf;
diff --git a/nx-X11/programs/Xserver/Xi/opendev.c b/nx-X11/programs/Xserver/Xi/opendev.c
index 45bea7ae5..520c6832a 100644
--- a/nx-X11/programs/Xserver/Xi/opendev.c
+++ b/nx-X11/programs/Xserver/Xi/opendev.c
@@ -141,6 +141,7 @@ ProcXOpenDevice(client)
     if (enableit && dev->inited && dev->startup)
 	(void)EnableDevice(dev);
 
+    memset(&rep, 0, sizeof(xOpenDeviceReply));
     rep.repType = X_Reply;
     rep.RepType = X_OpenDevice;
     rep.sequenceNumber = client->sequence;
diff --git a/nx-X11/programs/Xserver/dix/devices.c b/nx-X11/programs/Xserver/dix/devices.c
index e26879f28..e29154cfc 100644
--- a/nx-X11/programs/Xserver/dix/devices.c
+++ b/nx-X11/programs/Xserver/dix/devices.c
@@ -1037,6 +1037,7 @@ ProcGetModifierMapping(ClientPtr client)
     register KeyClassPtr keyc = inputInfo.keyboard->key;
 
     REQUEST_SIZE_MATCH(xReq);
+    memset(&rep, 0, sizeof(xGetModifierMappingReply));
     rep.type = X_Reply;
     rep.numKeyPerModifier = keyc->maxKeysPerModifier;
     rep.sequenceNumber = client->sequence;
@@ -1157,6 +1158,7 @@ ProcGetKeyboardMapping(ClientPtr client)
         return BadValue;
     }
 
+    memset(&rep, 0, sizeof(xGetKeyboardMappingReply));
     rep.type = X_Reply;
     rep.sequenceNumber = client->sequence;
     rep.keySymsPerKeyCode = curKeySyms->mapWidth;
diff --git a/nx-X11/programs/Xserver/dix/dispatch.c b/nx-X11/programs/Xserver/dix/dispatch.c
index ab1064051..3fd971101 100644
--- a/nx-X11/programs/Xserver/dix/dispatch.c
+++ b/nx-X11/programs/Xserver/dix/dispatch.c
@@ -579,6 +579,7 @@ ProcGetWindowAttributes(register ClientPtr client)
 					   SecurityReadAccess);
     if (!pWin)
         return(BadWindow);
+    memset(&wa, 0, sizeof(xGetWindowAttributesReply));
     GetWindowAttributes(pWin, client, &wa);
     WriteReplyToClient(client, sizeof(xGetWindowAttributesReply), &wa);
     return(client->noClientException);
@@ -834,6 +835,7 @@ ProcGetGeometry(register ClientPtr client)
     xGetGeometryReply rep;
     int status;
 
+    memset(&rep, 0, sizeof(xGetGeometryReply));
     if ((status = GetGeometry(client, &rep)) != Success)
 	return status;
 
@@ -856,6 +858,7 @@ ProcQueryTree(register ClientPtr client)
 					   SecurityReadAccess);
     if (!pWin)
         return(BadWindow);
+    memset(&reply, 0, sizeof(xQueryTreeReply));
     reply.type = X_Reply;
     reply.root = WindowTable[pWin->drawable.pScreen->myNum]->drawable.id;
     reply.sequenceNumber = client->sequence;
@@ -909,6 +912,7 @@ ProcInternAtom(register ClientPtr client)
     if (atom != BAD_RESOURCE)
     {
 	xInternAtomReply reply;
+	memset(&reply, 0, sizeof(xInternAtomReply));
 	reply.type = X_Reply;
 	reply.length = 0;
 	reply.sequenceNumber = client->sequence;
@@ -932,6 +936,7 @@ ProcGetAtomName(register ClientPtr client)
     if ( (str = NameForAtom(stuff->id)) )
     {
 	len = strlen(str);
+	memset(&reply, 0, sizeof(xGetAtomNameReply));
 	reply.type = X_Reply;
 	reply.length = (len + 3) >> 2;
 	reply.sequenceNumber = client->sequence;
@@ -1061,6 +1066,7 @@ ProcGetSelectionOwner(register ClientPtr client)
 	i = 0;
         while ((i < NumCurrentSelections) && 
 	       CurrentSelections[i].selection != stuff->id) i++;
+	memset(&reply, 0, sizeof(xGetSelectionOwnerReply));
         reply.type = X_Reply;
 	reply.length = 0;
 	reply.sequenceNumber = client->sequence;
@@ -1112,6 +1118,7 @@ ProcConvertSelection(register ClientPtr client)
 #endif
 	    )
 	{        
+	    memset(&event, 0, sizeof(xEvent));
 	    event.u.u.type = SelectionRequest;
 	    event.u.selectionRequest.time = stuff->time;
 	    event.u.selectionRequest.owner = 
@@ -1125,6 +1132,7 @@ ProcConvertSelection(register ClientPtr client)
 		NoEventMask /* CantBeFiltered */, NullGrab))
 		return (client->noClientException);
 	}
+	memset(&event, 0, sizeof(xEvent));
 	event.u.u.type = SelectionNotify;
 	event.u.selectionNotify.time = stuff->time;
 	event.u.selectionNotify.requestor = stuff->requestor;
@@ -1221,6 +1229,7 @@ ProcTranslateCoords(register ClientPtr client)
 					   SecurityReadAccess);
     if (!pDst)
         return(BadWindow);
+    memset(&rep, 0, sizeof(xTranslateCoordsReply));
     rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
@@ -1370,6 +1379,7 @@ ProcQueryFont(register ClientPtr client)
 	    return(BadAlloc);
 	}
 
+	memset(reply, 0, rlength);
 	reply->type = X_Reply;
 	reply->length = (rlength - sizeof(xGenericReply)) >> 2;
 	reply->sequenceNumber = client->sequence;
@@ -2112,6 +2122,8 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
         return(BadValue);
     }
     SECURITY_VERIFY_DRAWABLE(pDraw, drawable, client, SecurityReadAccess);
+
+    memset(&xgi, 0, sizeof(xGetImageReply));
     if(pDraw->type == DRAWABLE_WINDOW)
     {
       if( /* check for being viewable */
@@ -2165,7 +2177,7 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
     xgi.length = length;
 
     if (im_return) {
-	pBuf = (char *)xalloc(sz_xGetImageReply + length);
+	pBuf = (char *)xcalloc(1, sz_xGetImageReply + length);
 	if (!pBuf)
 	    return (BadAlloc);
 	if (widthBytesLine == 0)
@@ -2205,6 +2217,7 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
 	}
 	if(!(pBuf = (char *) ALLOCATE_LOCAL(length)))
 	    return (BadAlloc);
+	memset(pBuf, 0, length);
 	WriteReplyToClient(client, sizeof (xGetImageReply), &xgi);
     }
 
@@ -2973,6 +2986,7 @@ ProcQueryColors(register ClientPtr client)
 	prgbs = (xrgb *)ALLOCATE_LOCAL(count * sizeof(xrgb));
 	if(!prgbs && count)
             return(BadAlloc);
+	memset(prgbs, 0, count * sizeof(xrgb));
 	if( (retval = QueryColors(pcmp, count, (Pixel *)&stuff[1], prgbs)) )
 	{
    	    if (prgbs) DEALLOCATE_LOCAL(prgbs);
@@ -2984,6 +2998,8 @@ ProcQueryColors(register ClientPtr client)
 	        return (retval);
 	    }
 	}
+
+	memset(&qcr, 0, sizeof(xQueryColorsReply));
 	qcr.type = X_Reply;
 	qcr.length = (count * sizeof(xrgb)) >> 2;
 	qcr.sequenceNumber = client->sequence;
@@ -3201,6 +3217,7 @@ ProcQueryBestSize (register ClientPtr client)
     pScreen = pDraw->pScreen;
     (* pScreen->QueryBestSize)(stuff->class, &stuff->width,
 			       &stuff->height, pScreen);
+    memset(&reply, 0, sizeof(xQueryBestSizeReply));
     reply.type = X_Reply;
     reply.length = 0;
     reply.sequenceNumber = client->sequence;
@@ -3976,6 +3993,7 @@ SendErrorToClient(ClientPtr client, unsigned majorCode, unsigned minorCode,
 {
     xError rep;
 
+    memset(&rep, 0, sizeof(xError));
     rep.type = X_Error;
     rep.sequenceNumber = client->sequence;
     rep.errorCode = errorCode;
diff --git a/nx-X11/programs/Xserver/dix/dixfonts.c b/nx-X11/programs/Xserver/dix/dixfonts.c
index 9a8b09993..c7f00ce47 100644
--- a/nx-X11/programs/Xserver/dix/dixfonts.c
+++ b/nx-X11/programs/Xserver/dix/dixfonts.c
@@ -850,6 +850,7 @@ finish:
     for (i = 0; i < nnames; i++)
 	stringLens += (names->length[i] <= 255) ? names->length[i] : 0;
 
+    memset(&reply, 0, sizeof(xListFontsReply));
     reply.type = X_Reply;
     reply.length = (stringLens + nnames + 3) >> 2;
     reply.nFonts = nnames;
@@ -1102,6 +1103,7 @@ doListFontsWithInfo(ClientPtr client, LFWIclosurePtr c)
 		    err = AllocError;
 		    break;
 		}
+		memset(reply + c->length, 0, length - c->length);
 		c->reply = reply;
 		c->length = length;
 	    }
diff --git a/nx-X11/programs/Xserver/dix/events.c b/nx-X11/programs/Xserver/dix/events.c
index 4373673f9..9d1ebe7d0 100644
--- a/nx-X11/programs/Xserver/dix/events.c
+++ b/nx-X11/programs/Xserver/dix/events.c
@@ -3733,6 +3733,7 @@ ProcGetInputFocus(ClientPtr client)
     FocusClassPtr focus = inputInfo.keyboard->focus;
 
     REQUEST_SIZE_MATCH(xReq);
+    memset(&rep, 0, sizeof(xGetInputFocusReply));
     rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
@@ -3807,6 +3808,7 @@ ProcGrabPointer(ClientPtr client)
     }
 	/* at this point, some sort of reply is guaranteed. */
     time = ClientTimeToServerTime(stuff->time);
+    memset(&rep, 0, sizeof(xGrabPointerReply));
     rep.type = X_Reply;
     rep.sequenceNumber = client->sequence;
     rep.length = 0;
@@ -3982,6 +3984,7 @@ ProcGrabKeyboard(ClientPtr client)
     int result;
 
     REQUEST_SIZE_MATCH(xGrabKeyboardReq);
+    memset(&rep, 0, sizeof(xGrabKeyboardReply));
 #ifdef XCSECURITY
     if (!SecurityCheckDeviceAccess(client, inputInfo.keyboard, TRUE))
     {
@@ -4036,6 +4039,7 @@ ProcQueryPointer(ClientPtr client)
 	return BadWindow;
     if (mouse->valuator->motionHintWindow)
 	MaybeStopHint(mouse, client);
+    memset(&rep, 0, sizeof(xQueryPointerReply));
     rep.type = X_Reply;
     rep.sequenceNumber = client->sequence;
     rep.mask = mouse->button->state | inputInfo.keyboard->key->state;
diff --git a/nx-X11/programs/Xserver/dix/extension.c b/nx-X11/programs/Xserver/dix/extension.c
index 270d54f9b..19333c151 100644
--- a/nx-X11/programs/Xserver/dix/extension.c
+++ b/nx-X11/programs/Xserver/dix/extension.c
@@ -313,6 +313,7 @@ ProcQueryExtension(ClientPtr client)
 
     REQUEST_FIXED_SIZE(xQueryExtensionReq, stuff->nbytes);
     
+    memset(&reply, 0, sizeof(xQueryExtensionReply));
     reply.type = X_Reply;
     reply.length = 0;
     reply.major_opcode = 0;
@@ -352,6 +353,7 @@ ProcListExtensions(ClientPtr client)
 
     REQUEST_SIZE_MATCH(xReq);
 
+    memset(&reply, 0, sizeof(xListExtensionsReply));
     reply.type = X_Reply;
     reply.nExtensions = 0;
     reply.length = 0;
diff --git a/nx-X11/programs/Xserver/dix/main.c b/nx-X11/programs/Xserver/dix/main.c
index 270de6ced..b7452c5c2 100644
--- a/nx-X11/programs/Xserver/dix/main.c
+++ b/nx-X11/programs/Xserver/dix/main.c
@@ -534,6 +534,7 @@ CreateConnectionBlock()
     char *pBuf;
 
     
+    memset(&setup, 0, sizeof(xConnSetup));
     /* Leave off the ridBase and ridMask, these must be sent with 
        connection */
 
@@ -574,6 +575,7 @@ CreateConnectionBlock()
     while (--i >= 0)
 	*pBuf++ = 0;
     
+    memset(&format, 0, sizeof(xPixmapFormat));
     for (i=0; i<screenInfo.numPixmapFormats; i++)
     {
 	format.depth = screenInfo.formats[i].depth;
@@ -585,6 +587,8 @@ CreateConnectionBlock()
     }
 
     connBlockScreenStart = sizesofar;
+    memset(&depth, 0, sizeof(xDepth));
+    memset(&visual, 0, sizeof(xVisualType));
     for (i=0; i<screenInfo.numScreens; i++) 
     {
 	ScreenPtr	pScreen;
diff --git a/nx-X11/programs/Xserver/dix/property.c b/nx-X11/programs/Xserver/dix/property.c
index cabe46ecc..72c8c70ef 100644
--- a/nx-X11/programs/Xserver/dix/property.c
+++ b/nx-X11/programs/Xserver/dix/property.c
@@ -531,6 +531,7 @@ ProcGetProperty(ClientPtr client)
 	pProp = pProp->next;
     }
 
+    memset(&reply, 0, sizeof(xGetPropertyReply));
     reply.type = X_Reply;
     reply.sequenceNumber = client->sequence;
     if (!pProp) 
diff --git a/nx-X11/programs/Xserver/dix/window.c b/nx-X11/programs/Xserver/dix/window.c
index c060f4a23..b65bda0e3 100644
--- a/nx-X11/programs/Xserver/dix/window.c
+++ b/nx-X11/programs/Xserver/dix/window.c
@@ -774,6 +774,7 @@ CreateWindow(Window wid, register WindowPtr pParent, int x, int y, unsigned w,
 
     if (SubSend(pParent))
     {
+	memset(&event, 0, sizeof(xEvent));
 	event.u.u.type = CreateNotify;
 	event.u.createNotify.window = wid;
 	event.u.createNotify.parent = pParent->drawable.id;
@@ -841,6 +842,7 @@ CrushTree(WindowPtr pWin)
 	    pParent = pChild->parent;
 	    if (SubStrSend(pChild, pParent))
 	    {
+		memset(&event, 0, sizeof(xEvent));
 		event.u.u.type = DestroyNotify;
 		event.u.destroyNotify.window = pChild->drawable.id;
 		DeliverEvents(pChild, &event, 1, NullWindow);		
@@ -890,6 +892,7 @@ DeleteWindow(pointer value, XID wid)
     pParent = pWin->parent;
     if (wid && pParent && SubStrSend(pWin, pParent))
     {
+	memset(&event, 0, sizeof(xEvent));
 	event.u.u.type = DestroyNotify;
 	event.u.destroyNotify.window = pWin->drawable.id;
 	DeliverEvents(pWin, &event, 1, NullWindow);		
@@ -2306,6 +2309,7 @@ ConfigureWindow(register WindowPtr pWin, register Mask mask, XID *vlist, ClientP
 #endif
 	))
     {
+	memset(&event, 0, sizeof(xEvent));
 	event.u.u.type = ConfigureRequest;
 	event.u.configureRequest.window = pWin->drawable.id;
 	if (mask & CWSibling)
@@ -2350,6 +2354,7 @@ ConfigureWindow(register WindowPtr pWin, register Mask mask, XID *vlist, ClientP
 	if (size_change && ((pWin->eventMask|wOtherEventMasks(pWin)) & ResizeRedirectMask))
 	{
 	    xEvent eventT;
+	    memset(&eventT, 0, sizeof(xEvent));
 	    eventT.u.u.type = ResizeRequest;
 	    eventT.u.resizeRequest.window = pWin->drawable.id;
 	    eventT.u.resizeRequest.width = w;
@@ -2396,6 +2401,7 @@ ConfigureWindow(register WindowPtr pWin, register Mask mask, XID *vlist, ClientP
 ActuallyDoSomething:
     if (SubStrSend(pWin, pParent))
     {
+	memset(&event, 0, sizeof(xEvent));
 	event.u.u.type = ConfigureNotify;
 	event.u.configureNotify.window = pWin->drawable.id;
 	if (pSib)
@@ -2552,6 +2558,7 @@ ReparentWindow(register WindowPtr pWin, register WindowPtr pParent,
     if (WasMapped)
        UnmapWindow(pWin, FALSE);
 
+    memset(&event, 0, sizeof(xEvent));
     event.u.u.type = ReparentNotify;
     event.u.reparent.window = pWin->drawable.id;
     event.u.reparent.parent = pParent->drawable.id;
@@ -2708,6 +2715,7 @@ MapWindow(register WindowPtr pWin, ClientPtr client)
 #endif
 	))
 	{
+	    memset(&event, 0, sizeof(xEvent));
 	    event.u.u.type = MapRequest;
 	    event.u.mapRequest.window = pWin->drawable.id;
 #ifdef XAPPGROUP
@@ -2730,6 +2738,7 @@ MapWindow(register WindowPtr pWin, ClientPtr client)
 	pWin->mapped = TRUE;
 	if (SubStrSend(pWin, pParent))
 	{
+	    memset(&event, 0, sizeof(xEvent));
 	    event.u.u.type = MapNotify;
 	    event.u.mapNotify.window = pWin->drawable.id;
 	    event.u.mapNotify.override = pWin->overrideRedirect;
@@ -2820,6 +2829,7 @@ MapSubwindows(register WindowPtr pParent, ClientPtr client)
 	{
 	    if (parentRedirect && !pWin->overrideRedirect)
 	    {
+		memset(&event, 0, sizeof(xEvent));
 		event.u.u.type = MapRequest;
 		event.u.mapRequest.window = pWin->drawable.id;
 		event.u.mapRequest.parent = pParent->drawable.id;
@@ -2832,6 +2842,7 @@ MapSubwindows(register WindowPtr pParent, ClientPtr client)
 	    pWin->mapped = TRUE;
 	    if (parentNotify || StrSend(pWin))
 	    {
+		memset(&event, 0, sizeof(xEvent));
 		event.u.u.type = MapNotify;
 		event.u.mapNotify.window = pWin->drawable.id;
 		event.u.mapNotify.override = pWin->overrideRedirect;
@@ -2985,6 +2996,7 @@ UnmapWindow(register WindowPtr pWin, Bool fromConfigure)
 	return(Success);
     if (SubStrSend(pWin, pParent))
     {
+	memset(&event, 0, sizeof(xEvent));
 	event.u.u.type = UnmapNotify;
 	event.u.unmapNotify.window = pWin->drawable.id;
 	event.u.unmapNotify.fromConfigure = fromConfigure;
@@ -3279,6 +3291,7 @@ SendVisibilityNotify(WindowPtr pWin)
     }
 #endif
 
+    memset(&event, 0, sizeof(xEvent));
     event.u.u.type = VisibilityNotify;
     event.u.visibility.window = pWin->drawable.id;
     event.u.visibility.state = visibility;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c b/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c
index a51d19e81..9c89b555f 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c
@@ -1214,6 +1214,7 @@ void nxagentNotifyKeyboardChanges(int oldMinKeycode, int oldMaxKeycode)
     dev = inputInfo.keyboard;
     xkb = dev -> key -> xkbInfo -> desc;
 
+    memset(&nkn, 0, sizeof(xkbNewKeyboardNotify));
     nkn.deviceID = nkn.oldDeviceID = dev -> id;
     nkn.minKeyCode = 8;
     nkn.maxKeyCode = 255;
@@ -1233,6 +1234,7 @@ void nxagentNotifyKeyboardChanges(int oldMinKeycode, int oldMaxKeycode)
     int i;
     xEvent event;
 
+    memset(&event, 0, sizeof(xEvent));
     event.u.u.type = MappingNotify;
     event.u.mappingNotify.request = MappingKeyboard;
     event.u.mappingNotify.firstKeyCode = inputInfo.keyboard -> key -> curKeySyms.minKeyCode;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c b/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c
index 0ed7277a1..ea4f59d19 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c
@@ -931,6 +931,7 @@ ProcGetWindowAttributes(register ClientPtr client)
 					   SecurityReadAccess);
     if (!pWin)
         return(BadWindow);
+    memset(&wa, 0, sizeof(xGetWindowAttributesReply));
     GetWindowAttributes(pWin, client, &wa);
     WriteReplyToClient(client, sizeof(xGetWindowAttributesReply), &wa);
     return(client->noClientException);
@@ -1155,6 +1156,7 @@ GetGeometry(register ClientPtr client, xGetGeometryReply *rep)
 
     REQUEST_SIZE_MATCH(xResourceReq);
     SECURITY_VERIFY_GEOMETRABLE (pDraw, stuff->id, client, SecurityReadAccess);
+    memset(rep, 0, sizeof(xGetGeometryReply));
     rep->type = X_Reply;
     rep->length = 0;
     rep->sequenceNumber = client->sequence;
@@ -1216,6 +1218,7 @@ ProcQueryTree(register ClientPtr client)
 					   SecurityReadAccess);
     if (!pWin)
         return(BadWindow);
+    memset(&reply, 0, sizeof(xQueryTreeReply));
     reply.type = X_Reply;
     reply.root = WindowTable[pWin->drawable.pScreen->myNum]->drawable.id;
     reply.sequenceNumber = client->sequence;
@@ -1279,6 +1282,7 @@ ProcInternAtom(register ClientPtr client)
     if (atom != BAD_RESOURCE)
     {
 	xInternAtomReply reply;
+	memset(&reply, 0, sizeof(xInternAtomReply));
 	reply.type = X_Reply;
 	reply.length = 0;
 	reply.sequenceNumber = client->sequence;
@@ -1302,6 +1306,7 @@ ProcGetAtomName(register ClientPtr client)
     if ( (str = NameForAtom(stuff->id)) )
     {
 	len = strlen(str);
+	memset(&reply, 0, sizeof(xGetAtomNameReply));
 	reply.type = X_Reply;
 	reply.length = (len + 3) >> 2;
 	reply.sequenceNumber = client->sequence;
@@ -1441,6 +1446,7 @@ ProcGetSelectionOwner(register ClientPtr client)
 	i = 0;
         while ((i < NumCurrentSelections) && 
 	       CurrentSelections[i].selection != stuff->id) i++;
+	memset(&reply, 0, sizeof(xGetSelectionOwnerReply));
         reply.type = X_Reply;
 	reply.length = 0;
 	reply.sequenceNumber = client->sequence;
@@ -1512,7 +1518,9 @@ ProcConvertSelection(register ClientPtr client)
 					CurrentSelections[i].pWin))
 #endif
 	    )
+
 	{        
+	    memset(&event, 0, sizeof(xEvent));
 	    event.u.u.type = SelectionRequest;
 	    event.u.selectionRequest.time = stuff->time;
 	    event.u.selectionRequest.owner = 
@@ -1526,6 +1534,7 @@ ProcConvertSelection(register ClientPtr client)
 		NoEventMask /* CantBeFiltered */, NullGrab))
 		return (client->noClientException);
 	}
+	memset(&event, 0, sizeof(xEvent));
 	event.u.u.type = SelectionNotify;
 	event.u.selectionNotify.time = stuff->time;
 	event.u.selectionNotify.requestor = stuff->requestor;
@@ -1622,6 +1631,7 @@ ProcTranslateCoords(register ClientPtr client)
 					   SecurityReadAccess);
     if (!pDst)
         return(BadWindow);
+    memset(&rep, 0, sizeof(xTranslateCoordsReply));
     rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
@@ -1850,6 +1860,7 @@ ProcQueryFont(register ClientPtr client)
 	{
 	    return(BadAlloc);
 	}
+	memset(reply, 0, rlength);
 
 	reply->type = X_Reply;
 	reply->length = (rlength - sizeof(xGenericReply)) >> 2;
@@ -2659,6 +2670,7 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
         return(BadValue);
     }
     SECURITY_VERIFY_DRAWABLE(pDraw, drawable, client, SecurityReadAccess);
+    memset(&xgi, 0, sizeof(xGetImageReply));
     if(pDraw->type == DRAWABLE_WINDOW)
     {
       if( /* check for being viewable */
@@ -2712,9 +2724,10 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
     xgi.length = length;
 
     if (im_return) {
-	pBuf = (char *)xalloc(sz_xGetImageReply + length);
+	pBuf = (char *)xcalloc(1, sz_xGetImageReply + length);
 	if (!pBuf)
 	    return (BadAlloc);
+
 	if (widthBytesLine == 0)
 	    linesPerBuf = 0;
 	else
@@ -2752,6 +2765,7 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
 	}
 	if(!(pBuf = (char *) ALLOCATE_LOCAL(length)))
 	    return (BadAlloc);
+	memset(pBuf, 0, length);
 	WriteReplyToClient(client, sizeof (xGetImageReply), &xgi);
     }
 
@@ -3520,6 +3534,7 @@ ProcQueryColors(register ClientPtr client)
 	prgbs = (xrgb *)ALLOCATE_LOCAL(count * sizeof(xrgb));
 	if(!prgbs && count)
             return(BadAlloc);
+	memset(prgbs, 0, count * sizeof(xrgb));
 	if( (retval = QueryColors(pcmp, count, (Pixel *)&stuff[1], prgbs)) )
 	{
    	    if (prgbs) DEALLOCATE_LOCAL(prgbs);
@@ -3531,6 +3546,7 @@ ProcQueryColors(register ClientPtr client)
 	        return (retval);
 	    }
 	}
+	memset(&qcr, 0, sizeof(xQueryColorsReply));
 	qcr.type = X_Reply;
 	qcr.length = (count * sizeof(xrgb)) >> 2;
 	qcr.sequenceNumber = client->sequence;
@@ -3755,6 +3771,7 @@ ProcQueryBestSize (register ClientPtr client)
     pScreen = pDraw->pScreen;
     (* pScreen->QueryBestSize)(stuff->class, &stuff->width,
 			       &stuff->height, pScreen);
+    memset(&reply, 0, sizeof(xQueryBestSizeReply));
     reply.type = X_Reply;
     reply.length = 0;
     reply.sequenceNumber = client->sequence;
@@ -4623,6 +4640,7 @@ SendErrorToClient(ClientPtr client, unsigned majorCode, unsigned minorCode,
 {
     xError rep;
 
+    memset(&rep, 0, sizeof(xError));
     rep.type = X_Error;
     rep.sequenceNumber = client->sequence;
     rep.errorCode = errorCode;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c b/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c
index 5622f8cee..828b9bf4c 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c
@@ -929,6 +929,7 @@ finish:
     for (i = 0; i < nnames; i++)
 	stringLens += (names->length[i] <= 255) ? names->length[i] : 0;
 
+    memset(&reply, 0, sizeof(xListFontsReply));
     reply.type = X_Reply;
     reply.length = (stringLens + nnames + 3) >> 2;
     reply.nFonts = nnames;
@@ -1227,6 +1228,7 @@ doListFontsWithInfo(ClientPtr client, LFWIclosurePtr c)
 		    err = AllocError;
 		    break;
 		}
+		memset(reply + c->length, 0, length - c->length);
 		c->reply = reply;
 		c->length = length;
 	    }
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXevents.c b/nx-X11/programs/Xserver/hw/nxagent/NXevents.c
index c5593adbb..872a02ce5 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXevents.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXevents.c
@@ -3606,6 +3606,7 @@ EnterLeaveEvent(
     }
     if (mask & filters[type])
     {
+	memset(&event, 0, sizeof(xEvent));
 	event.u.u.type = type;
 	event.u.u.detail = detail;
 	event.u.enterLeave.time = currentTime.milliseconds;
@@ -4024,6 +4025,7 @@ ProcGetInputFocus(ClientPtr client)
     FocusClassPtr focus = inputInfo.keyboard->focus;
 
     REQUEST_SIZE_MATCH(xReq);
+    memset(&rep, 0, sizeof(xGetInputFocusReply));
     rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
@@ -4104,6 +4106,7 @@ ProcGrabPointer(ClientPtr client)
     }
 	/* at this point, some sort of reply is guaranteed. */
     time = ClientTimeToServerTime(stuff->time);
+    memset(&rep, 0, sizeof(xGrabPointerReply));
     rep.type = X_Reply;
     rep.sequenceNumber = client->sequence;
     rep.length = 0;
@@ -4321,6 +4324,8 @@ ProcGrabKeyboard(ClientPtr client)
     }
     #endif
     REQUEST_SIZE_MATCH(xGrabKeyboardReq);
+    memset(&rep, 0, sizeof(xGrabKeyboardReply));
+
 #ifdef XCSECURITY
     if (!SecurityCheckDeviceAccess(client, inputInfo.keyboard, TRUE))
     {
@@ -4399,6 +4404,7 @@ ProcQueryPointer(ClientPtr client)
 	return BadWindow;
     if (mouse->valuator->motionHintWindow)
 	MaybeStopHint(mouse, client);
+    memset(&rep, 0, sizeof(xQueryPointerReply));
     rep.type = X_Reply;
     rep.sequenceNumber = client->sequence;
     rep.mask = mouse->button->state | inputInfo.keyboard->key->state;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXextension.c b/nx-X11/programs/Xserver/hw/nxagent/NXextension.c
index ead9b9d28..f964e2fd8 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXextension.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXextension.c
@@ -332,6 +332,7 @@ ProcQueryExtension(ClientPtr client)
 
     REQUEST_FIXED_SIZE(xQueryExtensionReq, stuff->nbytes);
     
+    memset(&reply, 0, sizeof(xQueryExtensionReply));
     reply.type = X_Reply;
     reply.length = 0;
     reply.major_opcode = 0;
@@ -378,6 +379,7 @@ ProcListExtensions(ClientPtr client)
 
     REQUEST_SIZE_MATCH(xReq);
 
+    memset(&reply, 0, sizeof(xListExtensionsReply));
     reply.type = X_Reply;
     reply.nExtensions = 0;
     reply.length = 0;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXmiexpose.c b/nx-X11/programs/Xserver/hw/nxagent/NXmiexpose.c
index 3fc73cf3b..125f1b1c4 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXmiexpose.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXmiexpose.c
@@ -457,6 +457,7 @@ miSendGraphicsExpose (client, pRgn, drawable, major, minor)
     else
     {
         xEvent event;
+	memset(&event, 0, sizeof(xEvent));
 	event.u.u.type = NoExpose;
 	event.u.noExposure.drawable = drawable;
 	event.u.noExposure.majorEvent = major;
@@ -482,7 +483,7 @@ miSendExposures(pWin, pRgn, dx, dy)
     numRects = REGION_NUM_RECTS(pRgn);
     if(!(pEvent = (xEvent *) ALLOCATE_LOCAL(numRects * sizeof(xEvent))))
 	return;
-
+    memset(pEvent, 0, numRects * sizeof(xEvent));
     for (i=numRects, pe = pEvent; --i >= 0; pe++, pBox++)
     {
 	pe->u.u.type = Expose;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXproperty.c b/nx-X11/programs/Xserver/hw/nxagent/NXproperty.c
index cd1ec6ddd..ee2d6da94 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXproperty.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXproperty.c
@@ -620,6 +620,7 @@ ProcGetProperty(ClientPtr client)
 	pProp = pProp->next;
     }
 
+    memset(&reply, 0, sizeof(xGetPropertyReply));
     reply.type = X_Reply;
     reply.sequenceNumber = client->sequence;
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXrender.c b/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
index c2f6527a6..e34689399 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
@@ -392,6 +392,7 @@ ProcRenderQueryVersion (ClientPtr client)
     pRenderClient->major_version = stuff->majorVersion;
     pRenderClient->minor_version = stuff->minorVersion;
 
+    memset(&rep, 0, sizeof(xRenderQueryVersionReply));
     rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
@@ -516,6 +517,7 @@ ProcRenderQueryPictFormats (ClientPtr client)
     reply = (xRenderQueryPictFormatsReply *) xalloc (rlength);
     if (!reply)
 	return BadAlloc;
+    memset(reply, 0, rlength);
     reply->type = X_Reply;
     reply->sequenceNumber = client->sequence;
     reply->length = (rlength - sizeof(xGenericReply)) >> 2;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXshm.c b/nx-X11/programs/Xserver/hw/nxagent/NXshm.c
index eaaa92041..468dd480d 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXshm.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXshm.c
@@ -401,6 +401,7 @@ ProcShmQueryVersion(client)
     register int n;
 
     REQUEST_SIZE_MATCH(xShmQueryVersionReq);
+    memset(&rep, 0, sizeof(xShmQueryVersionReply));
     rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c b/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c
index 76e86fd2a..bb28961d1 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c
@@ -960,6 +960,7 @@ CreateWindow(Window wid, register WindowPtr pParent, int x, int y, unsigned w,
 
     if (SubSend(pParent))
     {
+	memset(&event, 0, sizeof(xEvent));
 	event.u.u.type = CreateNotify;
 	event.u.createNotify.window = wid;
 	event.u.createNotify.parent = pParent->drawable.id;
@@ -1027,6 +1028,7 @@ CrushTree(WindowPtr pWin)
 	    pParent = pChild->parent;
 	    if (SubStrSend(pChild, pParent))
 	    {
+		memset(&event, 0, sizeof(xEvent));
 		event.u.u.type = DestroyNotify;
 		event.u.destroyNotify.window = pChild->drawable.id;
 		DeliverEvents(pChild, &event, 1, NullWindow);		
@@ -1076,6 +1078,7 @@ DeleteWindow(pointer value, XID wid)
     pParent = pWin->parent;
     if (wid && pParent && SubStrSend(pWin, pParent))
     {
+	memset(&event, 0, sizeof(xEvent));
 	event.u.u.type = DestroyNotify;
 	event.u.destroyNotify.window = pWin->drawable.id;
 	DeliverEvents(pWin, &event, 1, NullWindow);		
@@ -2562,6 +2565,7 @@ ConfigureWindow(register WindowPtr pWin, register Mask mask, XID *vlist, ClientP
 #endif
 	))
     {
+	memset(&event, 0, sizeof(xEvent));
 	event.u.u.type = ConfigureRequest;
 	event.u.configureRequest.window = pWin->drawable.id;
 	if (mask & CWSibling)
@@ -2606,6 +2610,7 @@ ConfigureWindow(register WindowPtr pWin, register Mask mask, XID *vlist, ClientP
 	if (size_change && ((pWin->eventMask|wOtherEventMasks(pWin)) & ResizeRedirectMask))
 	{
 	    xEvent eventT;
+	    memset(&eventT, 0, sizeof(xEvent));
 	    eventT.u.u.type = ResizeRequest;
 	    eventT.u.resizeRequest.window = pWin->drawable.id;
 	    eventT.u.resizeRequest.width = w;
@@ -2652,6 +2657,7 @@ ConfigureWindow(register WindowPtr pWin, register Mask mask, XID *vlist, ClientP
 ActuallyDoSomething:
     if (SubStrSend(pWin, pParent))
     {
+	memset(&event, 0, sizeof(xEvent));
 	event.u.u.type = ConfigureNotify;
 	event.u.configureNotify.window = pWin->drawable.id;
 	if (pSib)
@@ -2825,6 +2831,7 @@ ReparentWindow(register WindowPtr pWin, register WindowPtr pParent,
     if (WasMapped)
        UnmapWindow(pWin, FALSE);
 
+    memset(&event, 0, sizeof(xEvent));
     event.u.u.type = ReparentNotify;
     event.u.reparent.window = pWin->drawable.id;
     event.u.reparent.parent = pParent->drawable.id;
@@ -2996,6 +3003,7 @@ MapWindow(register WindowPtr pWin, ClientPtr client)
 #endif
 	))
 	{
+	    memset(&event, 0, sizeof(xEvent));
 	    event.u.u.type = MapRequest;
 	    event.u.mapRequest.window = pWin->drawable.id;
 #ifdef XAPPGROUP
@@ -3018,6 +3026,7 @@ MapWindow(register WindowPtr pWin, ClientPtr client)
 	pWin->mapped = TRUE;
 	if (SubStrSend(pWin, pParent))
 	{
+	    memset(&event, 0, sizeof(xEvent));
 	    event.u.u.type = MapNotify;
 	    event.u.mapNotify.window = pWin->drawable.id;
 	    event.u.mapNotify.override = pWin->overrideRedirect;
@@ -3110,6 +3119,7 @@ MapSubwindows(register WindowPtr pParent, ClientPtr client)
 	{
 	    if (parentRedirect && !pWin->overrideRedirect)
 	    {
+		memset(&event, 0, sizeof(xEvent));
 		event.u.u.type = MapRequest;
 		event.u.mapRequest.window = pWin->drawable.id;
 		event.u.mapRequest.parent = pParent->drawable.id;
@@ -3122,6 +3132,7 @@ MapSubwindows(register WindowPtr pParent, ClientPtr client)
 	    pWin->mapped = TRUE;
 	    if (parentNotify || StrSend(pWin))
 	    {
+		memset(&event, 0, sizeof(xEvent));
 		event.u.u.type = MapNotify;
 		event.u.mapNotify.window = pWin->drawable.id;
 		event.u.mapNotify.override = pWin->overrideRedirect;
@@ -3283,6 +3294,7 @@ UnmapWindow(register WindowPtr pWin, Bool fromConfigure)
 	return(Success);
     if (SubStrSend(pWin, pParent))
     {
+	memset(&event, 0, sizeof(xEvent));
 	event.u.u.type = UnmapNotify;
 	event.u.unmapNotify.window = pWin->drawable.id;
 	event.u.unmapNotify.fromConfigure = fromConfigure;
@@ -3577,6 +3589,7 @@ SendVisibilityNotify(WindowPtr pWin)
     }
 #endif
 
+    memset(&event, 0, sizeof(xEvent));
     event.u.u.type = VisibilityNotify;
     event.u.visibility.window = pWin->drawable.id;
     event.u.visibility.state = visibility;
diff --git a/nx-X11/programs/Xserver/mi/miexpose.c b/nx-X11/programs/Xserver/mi/miexpose.c
index 9a0bd06b5..2be6b2264 100644
--- a/nx-X11/programs/Xserver/mi/miexpose.c
+++ b/nx-X11/programs/Xserver/mi/miexpose.c
@@ -420,6 +420,7 @@ miSendGraphicsExpose (client, pRgn, drawable, major, minor)
     else
     {
         xEvent event;
+	memset(&event, 0, sizeof(xEvent));
 	event.u.u.type = NoExpose;
 	event.u.noExposure.drawable = drawable;
 	event.u.noExposure.majorEvent = major;
@@ -445,6 +446,7 @@ miSendExposures(pWin, pRgn, dx, dy)
     numRects = REGION_NUM_RECTS(pRgn);
     if(!(pEvent = (xEvent *) ALLOCATE_LOCAL(numRects * sizeof(xEvent))))
 	return;
+    memset(pEvent, 0, numRects * sizeof(xEvent));
 
     for (i=numRects, pe = pEvent; --i >= 0; pe++, pBox++)
     {
diff --git a/nx-X11/programs/Xserver/randr/rrxinerama.c b/nx-X11/programs/Xserver/randr/rrxinerama.c
index 9f11279db..5441f8abc 100644
--- a/nx-X11/programs/Xserver/randr/rrxinerama.c
+++ b/nx-X11/programs/Xserver/randr/rrxinerama.c
@@ -281,7 +281,8 @@ ProcRRXineramaIsActive(ClientPtr client)
     xXineramaIsActiveReply	rep;
 
     REQUEST_SIZE_MATCH(xXineramaIsActiveReq);
-	
+
+    memset(&rep, 0, sizeof(xXineramaIsActiveReply));
     rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
diff --git a/nx-X11/programs/Xserver/render/render.c b/nx-X11/programs/Xserver/render/render.c
index eee21db84..6a65631ea 100644
--- a/nx-X11/programs/Xserver/render/render.c
+++ b/nx-X11/programs/Xserver/render/render.c
@@ -288,6 +288,7 @@ ProcRenderQueryVersion (ClientPtr client)
     pRenderClient->major_version = stuff->majorVersion;
     pRenderClient->minor_version = stuff->minorVersion;
 
+    memset(&rep, 0, sizeof(xRenderQueryVersionReply));
     rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
@@ -410,6 +411,8 @@ ProcRenderQueryPictFormats (ClientPtr client)
     reply = (xRenderQueryPictFormatsReply *) xalloc (rlength);
     if (!reply)
 	return BadAlloc;
+    memset(reply, 0, rlength);
+
     reply->type = X_Reply;
     reply->sequenceNumber = client->sequence;
     reply->length = (rlength - sizeof(xGenericReply)) >> 2;
diff --git a/nx-X11/programs/Xserver/xfixes/select.c b/nx-X11/programs/Xserver/xfixes/select.c
index 4b8bd01ed..ddc776ef7 100755
--- a/nx-X11/programs/Xserver/xfixes/select.c
+++ b/nx-X11/programs/Xserver/xfixes/select.c
@@ -84,6 +84,8 @@ XFixesSelectionCallback (CallbackListPtr *callbacks, pointer data, pointer args)
 	{
 	    xXFixesSelectionNotifyEvent	ev;
 
+	    memset(&ev, 0, sizeof(xXFixesSelectionNotifyEvent));
+
 	    ev.type = XFixesEventBase + XFixesSelectionNotify;
 	    ev.subtype = subtype;
 	    ev.sequenceNumber = e->pClient->sequence;
diff --git a/nx-X11/programs/Xserver/xfixes/xfixes.c b/nx-X11/programs/Xserver/xfixes/xfixes.c
index 1569b311e..1465931cb 100755
--- a/nx-X11/programs/Xserver/xfixes/xfixes.c
+++ b/nx-X11/programs/Xserver/xfixes/xfixes.c
@@ -42,6 +42,7 @@ ProcXFixesQueryVersion(ClientPtr client)
     REQUEST(xXFixesQueryVersionReq);
 
     REQUEST_SIZE_MATCH(xXFixesQueryVersionReq);
+    memset(&rep, 0, sizeof(xXFixesQueryVersionReply));
     rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
diff --git a/nx-X11/programs/Xserver/xkb/xkb.c b/nx-X11/programs/Xserver/xkb/xkb.c
index 778269f7c..1e4052914 100644
--- a/nx-X11/programs/Xserver/xkb/xkb.c
+++ b/nx-X11/programs/Xserver/xkb/xkb.c
@@ -192,6 +192,7 @@ ProcXkbUseExtension(ClientPtr client)
 					stuff->wantedMajor,stuff->wantedMinor,
 					XkbMajorVersion,XkbMinorVersion);
     }
+    memset(&rep, 0, sizeof(xkbUseExtensionReply));
     rep.type = X_Reply;
     rep.supported = supported;
     rep.length = 0;
@@ -1313,6 +1314,8 @@ char		*desc,*start;
     start= desc= (char *)ALLOCATE_LOCAL(len);
     if (!start)
 	return BadAlloc;
+    memset(start, 0, len);
+
     if ( rep->nTypes>0 )
 	desc = XkbWriteKeyTypes(xkb,rep,desc,client);
     if ( rep->nKeySyms>0 )
@@ -2381,6 +2384,8 @@ ProcXkbSetMap(ClientPtr client)
     				(xkb->max_key_code!=stuff->maxKeyCode)) {
 	Status			status;
 	xkbNewKeyboardNotify	nkn;
+
+	memset(&nkn, 0, sizeof(xkbNewKeyboardNotify));
 	nkn.deviceID= nkn.oldDeviceID= dev->id;
 	nkn.oldMinKeyCode= xkb->min_key_code;
 	nkn.oldMaxKeyCode= xkb->max_key_code;
@@ -3480,6 +3485,7 @@ ProcXkbGetNames(ClientPtr client)
     CHK_MASK_LEGAL(0x01,stuff->which,XkbAllNamesMask);
 
     xkb = dev->key->xkbInfo->desc;
+    memset(&rep, 0, sizeof(xkbGetNamesReply));
     rep.type= X_Reply;
     rep.sequenceNumber= client->sequence;
     rep.length = 0;
@@ -4939,6 +4945,7 @@ ProcXkbSetGeometry(ClientPtr client)
 	nn.changed= XkbGeometryNameMask;
 	XkbSendNamesNotify(dev,&nn);
     }
+    memset(&nkn, 0, sizeof(xkbNewKeyboardNotify));
     nkn.deviceID= nkn.oldDeviceID= dev->id;
     nkn.minKeyCode= nkn.oldMinKeyCode= xkb->min_key_code;
     nkn.maxKeyCode= nkn.oldMaxKeyCode= xkb->max_key_code;
@@ -4969,6 +4976,7 @@ ProcXkbPerClientFlags(ClientPtr client)
     CHK_MASK_MATCH(0x02,stuff->change,stuff->value);
 
     interest = XkbFindClientResource((DevicePtr)dev,client);
+    memset(&rep, 0, sizeof(xkbPerClientFlagsReply));
     rep.type= X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
@@ -5463,6 +5471,7 @@ ProcXkbGetKbdByName(ClientPtr client)
 	    XkbFreeSrvLedInfo(old_sli);
 	}
 
+	memset(&nkn, 0, sizeof(xkbNewKeyboardNotify));
 	nkn.deviceID= nkn.oldDeviceID= dev->id;
 	nkn.minKeyCode= finfo.xkb->min_key_code;
 	nkn.maxKeyCode= finfo.xkb->max_key_code;
diff --git a/nx-X11/programs/Xserver/xkb/xkbEvents.c b/nx-X11/programs/Xserver/xkb/xkbEvents.c
index 8305208a0..914e3e782 100644
--- a/nx-X11/programs/Xserver/xkb/xkbEvents.c
+++ b/nx-X11/programs/Xserver/xkb/xkbEvents.c
@@ -730,6 +730,7 @@ XkbSrvLedInfoPtr	sli;
     }
     if (pChanges->map.changed) {
 	xkbMapNotify mn;
+	memset(&mn, 0, sizeof(xkbMapNotify));
 	mn.changed= pChanges->map.changed;
 	mn.firstType= pChanges->map.first_type;
 	mn.nTypes= pChanges->map.num_types;
@@ -751,6 +752,7 @@ XkbSrvLedInfoPtr	sli;
     if ((pChanges->ctrls.changed_ctrls)||
 	(pChanges->ctrls.enabled_ctrls_changes)) {
 	xkbControlsNotify cn;
+	memset(&cn, 0, sizeof(xkbControlsNotify));
 	cn.changedControls= pChanges->ctrls.changed_ctrls;
 	cn.enabledControlChanges= pChanges->ctrls.enabled_ctrls_changes;
 	cn.keycode= cause->kc;
@@ -763,6 +765,7 @@ XkbSrvLedInfoPtr	sli;
 	xkbIndicatorNotify in;
 	if (sli==NULL)
 	    sli= XkbFindSrvLedInfo(kbd,XkbDfltXIClass,XkbDfltXIId,0);
+	memset(&in, 0, sizeof(xkbIndicatorNotify));
 	in.state= sli->effectiveState;
 	in.changed= pChanges->indicators.map_changes;
 	XkbSendIndicatorNotify(kbd,XkbIndicatorMapNotify,&in);
@@ -771,12 +774,14 @@ XkbSrvLedInfoPtr	sli;
 	xkbIndicatorNotify in;
 	if (sli==NULL)
 	    sli= XkbFindSrvLedInfo(kbd,XkbDfltXIClass,XkbDfltXIId,0);
+	memset(&in, 0, sizeof(xkbIndicatorNotify));
 	in.state= sli->effectiveState;
 	in.changed= pChanges->indicators.state_changes;
 	XkbSendIndicatorNotify(kbd,XkbIndicatorStateNotify,&in);
     }
     if (pChanges->names.changed) {
 	xkbNamesNotify nn;
+	memset(&nn, 0, sizeof(xkbNamesNotify));
 	nn.changed= pChanges->names.changed;
 	nn.firstType= pChanges->names.first_type;
 	nn.nTypes= pChanges->names.num_types;
@@ -789,6 +794,7 @@ XkbSrvLedInfoPtr	sli;
     }
     if ((pChanges->compat.changed_groups)||(pChanges->compat.num_si>0)) {
 	xkbCompatMapNotify cmn;
+	memset(&cmn, 0, sizeof(xkbCompatMapNotify));
 	cmn.changedGroups= pChanges->compat.changed_groups;
 	cmn.firstSI= pChanges->compat.first_si;
 	cmn.nSI= pChanges->compat.num_si;
-- 
cgit v1.2.3


From 68dd0b52e13c844d662192654fb10cb993257a59 Mon Sep 17 00:00:00 2001
From: Keith Packard <keithp@keithp.com>
Date: Mon, 22 Jun 2015 09:36:08 +0200
Subject: Replace 'pointer' type with 'void *'

 This lets us stop using the 'pointer' typedef in Xdefs.h as 'pointer'
 is used throughout the X server for other things, and having duplicate
 names generates compiler warnings.

 Signed-off-by: Keith Packard <keithp@keithp.com>
 Reviewed-by: Eric Anholt <eric@anholt.net>
 Rebased against NX: Mike Gabriel <mike.gabriel@das-netzwerkteam.de>
---
 nx-X11/extras/Mesa/src/mesa/drivers/x11/xm_span.c  |  6 +-
 nx-X11/include/Xdefs.h                             |  4 +-
 nx-X11/include/extensions/XKBsrv.h                 |  6 +-
 nx-X11/include/extensions/lbxopts.h                |  4 +-
 nx-X11/include/extensions/syncstr.h                | 12 +--
 nx-X11/include/extensions/xtrapproto.h             |  2 +-
 nx-X11/programs/Xserver/GL/glx/glxcmds.c           |  4 +-
 nx-X11/programs/Xserver/GL/glx/glxext.c            |  4 +-
 nx-X11/programs/Xserver/GL/glxmodule.c             |  6 +-
 .../programs/Xserver/GL/mesa/GLcore/GLcoremodule.c |  6 +-
 nx-X11/programs/Xserver/XTrap/xf86XTrapModule.c    |  6 +-
 nx-X11/programs/Xserver/XTrap/xtrapdi.c            |  6 +-
 nx-X11/programs/Xserver/Xext/appgroup.c            | 14 ++--
 nx-X11/programs/Xserver/Xext/appgroup.h            |  4 +-
 nx-X11/programs/Xserver/Xext/extmod/modinit.c      |  8 +-
 nx-X11/programs/Xserver/Xext/mbuf.c                | 58 +++++++-------
 nx-X11/programs/Xserver/Xext/mbufbf.c              |  6 +-
 nx-X11/programs/Xserver/Xext/mbufpx.c              |  6 +-
 nx-X11/programs/Xserver/Xext/panoramiX.c           | 18 ++---
 nx-X11/programs/Xserver/Xext/panoramiXsrv.h        |  2 +-
 nx-X11/programs/Xserver/Xext/saver.c               | 14 ++--
 nx-X11/programs/Xserver/Xext/security.c            | 22 +++---
 nx-X11/programs/Xserver/Xext/shape.c               | 18 ++---
 nx-X11/programs/Xserver/Xext/shm.c                 | 22 +++---
 nx-X11/programs/Xserver/Xext/sleepuntil.c          | 38 ++++-----
 nx-X11/programs/Xserver/Xext/sleepuntil.h          |  4 +-
 nx-X11/programs/Xserver/Xext/sync.c                | 68 ++++++++--------
 nx-X11/programs/Xserver/Xext/vidmodeproc.h         | 32 ++++----
 nx-X11/programs/Xserver/Xext/xevie.c               | 26 +++---
 nx-X11/programs/Xserver/Xext/xf86dga2.c            |  8 +-
 nx-X11/programs/Xserver/Xext/xf86misc.c            | 12 +--
 nx-X11/programs/Xserver/Xext/xf86miscproc.h        | 20 ++---
 nx-X11/programs/Xserver/Xext/xf86vmode.c           | 20 ++---
 nx-X11/programs/Xserver/Xext/xres.c                |  6 +-
 nx-X11/programs/Xserver/Xext/xtest1dd.c            |  2 +-
 nx-X11/programs/Xserver/Xext/xtest1di.c            |  4 +-
 nx-X11/programs/Xserver/Xext/xvmain.c              | 28 +++----
 nx-X11/programs/Xserver/Xext/xvmc.c                | 12 +--
 nx-X11/programs/Xserver/Xext/xvmcext.h             |  8 +-
 nx-X11/programs/Xserver/Xi/devbell.c               |  6 +-
 nx-X11/programs/Xserver/Xi/exevents.c              |  6 +-
 nx-X11/programs/Xserver/Xi/stubs.c                 |  2 +-
 nx-X11/programs/Xserver/composite/compext.c        | 12 +--
 nx-X11/programs/Xserver/composite/compinit.c       |  8 +-
 nx-X11/programs/Xserver/composite/compwindow.c     | 10 +--
 nx-X11/programs/Xserver/damageext/damageext.c      | 10 +--
 nx-X11/programs/Xserver/dbe/dbe.c                  | 32 ++++----
 nx-X11/programs/Xserver/dbe/dbemodule.c            |  6 +-
 nx-X11/programs/Xserver/dbe/midbe.c                |  8 +-
 nx-X11/programs/Xserver/dix/colormap.c             | 18 ++---
 nx-X11/programs/Xserver/dix/cursor.c               |  4 +-
 nx-X11/programs/Xserver/dix/devices.c              |  2 +-
 nx-X11/programs/Xserver/dix/dispatch.c             | 46 +++++------
 nx-X11/programs/Xserver/dix/dixfonts.c             | 56 ++++++-------
 nx-X11/programs/Xserver/dix/dixutils.c             | 56 ++++++-------
 nx-X11/programs/Xserver/dix/events.c               | 14 ++--
 nx-X11/programs/Xserver/dix/gc.c                   | 14 ++--
 nx-X11/programs/Xserver/dix/glyphcurs.c            |  2 +-
 nx-X11/programs/Xserver/dix/grabs.c                |  6 +-
 nx-X11/programs/Xserver/dix/main.c                 |  2 +-
 nx-X11/programs/Xserver/dix/pixmap.c               |  6 +-
 nx-X11/programs/Xserver/dix/property.c             | 16 ++--
 nx-X11/programs/Xserver/dix/resource.c             | 34 ++++----
 nx-X11/programs/Xserver/dix/window.c               | 22 +++---
 nx-X11/programs/Xserver/fb/fb.h                    | 12 +--
 nx-X11/programs/Xserver/fb/fb24_32.c               |  4 +-
 nx-X11/programs/Xserver/fb/fb24_32.h               |  4 +-
 nx-X11/programs/Xserver/fb/fballpriv.c             |  2 +-
 nx-X11/programs/Xserver/fb/fbglyph.c               |  4 +-
 nx-X11/programs/Xserver/fb/fboverlay.c             | 16 ++--
 nx-X11/programs/Xserver/fb/fboverlay.h             | 10 +--
 nx-X11/programs/Xserver/fb/fbpixmap.c              |  2 +-
 nx-X11/programs/Xserver/fb/fbpseudocolor.c         | 60 +++++++-------
 nx-X11/programs/Xserver/fb/fbscreen.c              |  8 +-
 nx-X11/programs/Xserver/fb/fbwindow.c              |  2 +-
 nx-X11/programs/Xserver/hw/nxagent/Colormap.c      | 16 ++--
 nx-X11/programs/Xserver/hw/nxagent/Cursor.c        |  6 +-
 nx-X11/programs/Xserver/hw/nxagent/Cursor.h        |  4 +-
 nx-X11/programs/Xserver/hw/nxagent/Drawable.c      | 16 ++--
 nx-X11/programs/Xserver/hw/nxagent/Drawable.h      |  6 +-
 nx-X11/programs/Xserver/hw/nxagent/Events.c        |  8 +-
 nx-X11/programs/Xserver/hw/nxagent/Font.c          | 14 ++--
 nx-X11/programs/Xserver/hw/nxagent/Font.h          |  2 +-
 nx-X11/programs/Xserver/hw/nxagent/GC.c            | 22 +++---
 nx-X11/programs/Xserver/hw/nxagent/GCOps.c         |  4 +-
 nx-X11/programs/Xserver/hw/nxagent/GCOps.h         |  4 +-
 nx-X11/programs/Xserver/hw/nxagent/GCs.h           |  6 +-
 nx-X11/programs/Xserver/hw/nxagent/Handlers.c      |  8 +-
 nx-X11/programs/Xserver/hw/nxagent/Handlers.h      |  8 +-
 nx-X11/programs/Xserver/hw/nxagent/Init.c          | 10 +--
 nx-X11/programs/Xserver/hw/nxagent/Keyboard.c      | 10 +--
 nx-X11/programs/Xserver/hw/nxagent/Keyboard.h      |  2 +-
 nx-X11/programs/Xserver/hw/nxagent/NXdamage.c      | 10 +--
 nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c    | 48 +++++------
 nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c    | 76 +++++++++---------
 nx-X11/programs/Xserver/hw/nxagent/NXevents.c      | 14 ++--
 nx-X11/programs/Xserver/hw/nxagent/NXglxext.c      |  4 +-
 nx-X11/programs/Xserver/hw/nxagent/NXglyph.c       | 24 +++---
 nx-X11/programs/Xserver/hw/nxagent/NXglyphstr.h    |  8 +-
 nx-X11/programs/Xserver/hw/nxagent/NXmiexpose.c    |  8 +-
 nx-X11/programs/Xserver/hw/nxagent/NXmiglyph.c     |  8 +-
 nx-X11/programs/Xserver/hw/nxagent/NXmiwindow.c    |  4 +-
 nx-X11/programs/Xserver/hw/nxagent/NXpicture.c     | 26 +++---
 nx-X11/programs/Xserver/hw/nxagent/NXpicturestr.h  | 12 +--
 nx-X11/programs/Xserver/hw/nxagent/NXproperty.c    | 18 ++---
 nx-X11/programs/Xserver/hw/nxagent/NXrender.c      | 30 +++----
 nx-X11/programs/Xserver/hw/nxagent/NXresource.c    | 38 ++++-----
 nx-X11/programs/Xserver/hw/nxagent/NXshm.c         | 22 +++---
 nx-X11/programs/Xserver/hw/nxagent/NXwindow.c      | 22 +++---
 nx-X11/programs/Xserver/hw/nxagent/Pixmap.c        |  4 +-
 nx-X11/programs/Xserver/hw/nxagent/Pixmaps.h       |  4 +-
 nx-X11/programs/Xserver/hw/nxagent/Render.c        | 12 +--
 nx-X11/programs/Xserver/hw/nxagent/Render.h        |  4 +-
 nx-X11/programs/Xserver/hw/nxagent/Rootless.c      |  2 +-
 nx-X11/programs/Xserver/hw/nxagent/Rootless.h      |  2 +-
 nx-X11/programs/Xserver/hw/nxagent/Screen.c        | 22 +++---
 nx-X11/programs/Xserver/hw/nxagent/Window.c        | 38 ++++-----
 .../Xserver/hw/xfree86/os-support/xf86_ansic.h     |  4 +-
 nx-X11/programs/Xserver/include/closestr.h         |  2 +-
 nx-X11/programs/Xserver/include/colormap.h         |  8 +-
 nx-X11/programs/Xserver/include/colormapst.h       |  2 +-
 nx-X11/programs/Xserver/include/cursor.h           |  2 +-
 nx-X11/programs/Xserver/include/cursorstr.h        |  4 +-
 nx-X11/programs/Xserver/include/dix.h              | 50 ++++++------
 nx-X11/programs/Xserver/include/dixfont.h          |  6 +-
 nx-X11/programs/Xserver/include/dixgrabs.h         |  2 +-
 nx-X11/programs/Xserver/include/dixstruct.h        | 16 ++--
 nx-X11/programs/Xserver/include/extnsionst.h       |  2 +-
 nx-X11/programs/Xserver/include/gc.h               | 10 ++-
 nx-X11/programs/Xserver/include/gcstruct.h         |  8 +-
 nx-X11/programs/Xserver/include/input.h            |  4 +-
 nx-X11/programs/Xserver/include/misc.h             |  5 ++
 nx-X11/programs/Xserver/include/miscstruct.h       |  2 +-
 nx-X11/programs/Xserver/include/os.h               | 56 ++++++-------
 nx-X11/programs/Xserver/include/pixmap.h           |  2 +-
 nx-X11/programs/Xserver/include/property.h         |  2 +-
 nx-X11/programs/Xserver/include/propertyst.h       |  2 +-
 nx-X11/programs/Xserver/include/resource.h         | 34 ++++----
 nx-X11/programs/Xserver/include/scrnintstr.h       | 22 +++---
 nx-X11/programs/Xserver/include/window.h           |  8 +-
 nx-X11/programs/Xserver/include/windowstr.h        |  2 +-
 nx-X11/programs/Xserver/mfb/maskbits.h             |  2 +-
 nx-X11/programs/Xserver/mi/mi.h                    | 10 +--
 nx-X11/programs/Xserver/mi/miarc.c                 |  4 +-
 nx-X11/programs/Xserver/mi/mibank.c                | 24 +++---
 nx-X11/programs/Xserver/mi/mibank.h                |  4 +-
 nx-X11/programs/Xserver/mi/mibstore.c              | 62 +++++++--------
 nx-X11/programs/Xserver/mi/midispcur.c             | 28 +++----
 nx-X11/programs/Xserver/mi/miexpose.c              |  8 +-
 nx-X11/programs/Xserver/mi/mifillarc.h             |  2 +-
 nx-X11/programs/Xserver/mi/migc.c                  |  8 +-
 nx-X11/programs/Xserver/mi/migc.h                  |  2 +-
 nx-X11/programs/Xserver/mi/miglblt.c               |  4 +-
 nx-X11/programs/Xserver/mi/mioverlay.c             |  6 +-
 nx-X11/programs/Xserver/mi/mipointer.c             | 10 +--
 nx-X11/programs/Xserver/mi/mipolyrect.c            |  2 +-
 nx-X11/programs/Xserver/mi/miscrinit.c             | 20 ++---
 nx-X11/programs/Xserver/mi/misprite.c              | 20 ++---
 nx-X11/programs/Xserver/mi/miwindow.c              |  4 +-
 nx-X11/programs/Xserver/miext/cw/cw.c              | 12 +--
 nx-X11/programs/Xserver/miext/cw/cw.h              |  6 +-
 nx-X11/programs/Xserver/miext/cw/cw_ops.c          |  8 +-
 nx-X11/programs/Xserver/miext/damage/damage.c      | 10 +--
 nx-X11/programs/Xserver/miext/damage/damagestr.h   |  2 +-
 nx-X11/programs/Xserver/os/WaitFor.c               | 18 ++---
 nx-X11/programs/Xserver/os/access.c                | 92 +++++++++++-----------
 nx-X11/programs/Xserver/os/connection.c            |  8 +-
 nx-X11/programs/Xserver/os/io.c                    |  6 +-
 nx-X11/programs/Xserver/os/k5auth.c                | 10 +--
 nx-X11/programs/Xserver/os/log.c                   |  2 +-
 nx-X11/programs/Xserver/os/osdep.h                 |  8 +-
 nx-X11/programs/Xserver/os/rpcauth.c               |  4 +-
 nx-X11/programs/Xserver/os/utils.c                 | 32 ++++----
 nx-X11/programs/Xserver/os/xalloc.c                | 18 ++---
 nx-X11/programs/Xserver/os/xdmcp.c                 | 20 ++---
 nx-X11/programs/Xserver/randr/randr.c              | 18 ++---
 nx-X11/programs/Xserver/randr/randrstr.h           |  6 +-
 nx-X11/programs/Xserver/randr/rrcrtc.c             |  4 +-
 nx-X11/programs/Xserver/randr/rrdispatch.c         |  4 +-
 nx-X11/programs/Xserver/randr/rrmode.c             |  4 +-
 nx-X11/programs/Xserver/randr/rroutput.c           |  4 +-
 nx-X11/programs/Xserver/randr/rrproperty.c         | 12 +--
 nx-X11/programs/Xserver/record/record.c            | 66 ++++++++--------
 nx-X11/programs/Xserver/record/recordmod.c         |  6 +-
 nx-X11/programs/Xserver/render/animcur.c           |  8 +-
 nx-X11/programs/Xserver/render/glyph.c             | 24 +++---
 nx-X11/programs/Xserver/render/glyphstr.h          |  8 +-
 nx-X11/programs/Xserver/render/miglyph.c           |  8 +-
 nx-X11/programs/Xserver/render/mipict.c            |  8 +-
 nx-X11/programs/Xserver/render/mipict.h            |  2 +-
 nx-X11/programs/Xserver/render/mirect.c            |  2 +-
 nx-X11/programs/Xserver/render/picture.c           | 24 +++---
 nx-X11/programs/Xserver/render/picturestr.h        | 12 +--
 nx-X11/programs/Xserver/render/render.c            | 26 +++---
 nx-X11/programs/Xserver/xfixes/cursor.c            | 28 +++----
 nx-X11/programs/Xserver/xfixes/region.c            | 14 ++--
 nx-X11/programs/Xserver/xfixes/select.c            | 10 +--
 nx-X11/programs/Xserver/xfixes/xfixes.c            |  4 +-
 nx-X11/programs/Xserver/xkb/ddxBeep.c              | 10 +--
 nx-X11/programs/Xserver/xkb/xkb.c                  |  8 +-
 nx-X11/programs/Xserver/xkb/xkb.h                  |  2 +-
 nx-X11/programs/Xserver/xkb/xkbAccessX.c           | 28 +++----
 nx-X11/programs/Xserver/xkb/xkbActions.c           |  6 +-
 nx-X11/programs/Xserver/xkb/xkbEvents.c            |  8 +-
 nx-X11/programs/Xserver/xkb/xkbInit.c              |  6 +-
 nx-X11/programs/Xserver/xkb/xkbPrKeyEv.c           |  4 +-
 206 files changed, 1395 insertions(+), 1384 deletions(-)

(limited to 'nx-X11/programs/Xserver/xfixes/select.c')

diff --git a/nx-X11/extras/Mesa/src/mesa/drivers/x11/xm_span.c b/nx-X11/extras/Mesa/src/mesa/drivers/x11/xm_span.c
index 664f365df..6ec65faa9 100644
--- a/nx-X11/extras/Mesa/src/mesa/drivers/x11/xm_span.c
+++ b/nx-X11/extras/Mesa/src/mesa/drivers/x11/xm_span.c
@@ -115,7 +115,7 @@ static unsigned long read_pixel( XMesaDisplay *dpy,
       XMesaDestroyImage( pixel );
    }
 #else
-   (*dpy->GetImage)(d, x, y, 1, 1, ZPixmap, ~0L, (pointer)&p);
+   (*dpy->GetImage)(d, x, y, 1, 1, ZPixmap, ~0L, (void *)&p);
 #endif
    return p;
 }
@@ -3834,7 +3834,7 @@ get_row_ci(GLcontext *ctx, struct gl_renderbuffer *rb,
 #else
       (*xmesa->display->GetImage)(xrb->drawable,
 				  x, y, n, 1, ZPixmap,
-				  ~0L, (pointer)index);
+				  ~0L, (void *)index);
 #endif
    }
    else if (xrb->ximage) {
@@ -3869,7 +3869,7 @@ get_row_rgba(GLcontext *ctx, struct gl_renderbuffer *rb,
       error = (!span->data);
       (*xmesa->display->GetImage)(xrb->drawable,
 				  x, YFLIP(xrb, y), n, 1, ZPixmap,
-				  ~0L, (pointer)span->data);
+				  ~0L, (void *)span->data);
 #else
       int k;
       y = YFLIP(xrb, y);
diff --git a/nx-X11/include/Xdefs.h b/nx-X11/include/Xdefs.h
index 9e77e30b8..f32149db5 100644
--- a/nx-X11/include/Xdefs.h
+++ b/nx-X11/include/Xdefs.h
@@ -103,8 +103,8 @@ typedef FSID AccContext;
 typedef struct timeval **OSTimePtr;
 
 
-typedef void (* BlockHandlerProcPtr)(pointer /* blockData */,
+typedef void (* BlockHandlerProcPtr)(void * /* blockData */,
 				     OSTimePtr /* pTimeout */,
-				     pointer /* pReadmask */);
+				     void * /* pReadmask */);
 
 #endif
diff --git a/nx-X11/include/extensions/XKBsrv.h b/nx-X11/include/extensions/XKBsrv.h
index 4a9d8edcb..0d262e979 100644
--- a/nx-X11/include/extensions/XKBsrv.h
+++ b/nx-X11/include/extensions/XKBsrv.h
@@ -294,7 +294,7 @@ extern char *	XkbModelUsed,*XkbLayoutUsed,*XkbVariantUsed,*XkbOptionsUsed;
 extern Bool	noXkbExtension;
 extern Bool	XkbWantRulesProp;
 
-extern pointer	XkbLastRepeatEvent;
+extern void *	XkbLastRepeatEvent;
 
 extern CARD32	xkbDebugFlags;
 extern CARD32	xkbDebugCtrls;
@@ -336,7 +336,7 @@ extern	int	DeviceButtonPress,DeviceButtonRelease;
 #define	IsKeypadKey(s)		XkbKSIsKeypad(s)
 
 #define	Status		int
-#define	XPointer	pointer
+#define	XPointer	void *
 #define	Display		struct _XDisplay
 
 #ifndef True
@@ -715,7 +715,7 @@ extern	void XkbHandleBell(
        BOOL		/* eventOnly */,
        DeviceIntPtr	/* kbd */,
        CARD8		/* percent */,
-       pointer 		/* ctrl */,
+       void * 		/* ctrl */,
        CARD8		/* class */,
        Atom		/* name */,
        WindowPtr	/* pWin */,
diff --git a/nx-X11/include/extensions/lbxopts.h b/nx-X11/include/extensions/lbxopts.h
index ac1e12121..3ec81fcb2 100644
--- a/nx-X11/include/extensions/lbxopts.h
+++ b/nx-X11/include/extensions/lbxopts.h
@@ -96,8 +96,8 @@ struct iovec {
 typedef void *LbxStreamCompHandle;
 
 typedef struct _LbxStreamOpts {
-    LbxStreamCompHandle	(*streamCompInit)(int fd, pointer arg);
-    pointer		streamCompArg;
+    LbxStreamCompHandle	(*streamCompInit)(int fd, void * arg);
+    void *		streamCompArg;
     int			(*streamCompStuffInput)(
 			    int fd,
 			    unsigned char *buf,
diff --git a/nx-X11/include/extensions/syncstr.h b/nx-X11/include/extensions/syncstr.h
index 4e384f22e..10ca9188a 100644
--- a/nx-X11/include/extensions/syncstr.h
+++ b/nx-X11/include/extensions/syncstr.h
@@ -396,11 +396,11 @@ typedef struct _SysCounterInfo {
     CARD64	bracket_less;
     SyncCounterType counterType;  /* how can this counter change */
     void        (*QueryValue)(
-			      pointer /*pCounter*/,
+			      void * /*pCounter*/,
 			      CARD64 * /*freshvalue*/
 );
     void	(*BracketValues)(
-				 pointer /*pCounter*/,
+				 void * /*pCounter*/,
 				 CARD64 * /*lessthan*/,
 				 CARD64 * /*greaterthan*/
 );
@@ -465,16 +465,16 @@ typedef union {
 } SyncAwaitUnion;
 
 
-extern pointer SyncCreateSystemCounter(
+extern void * SyncCreateSystemCounter(
     char *	/* name */,
     CARD64  	/* inital_value */,
     CARD64  	/* resolution */,
     SyncCounterType /* change characterization */,
     void        (* /*QueryValue*/ ) (
-        pointer /* pCounter */,
+        void * /* pCounter */,
         CARD64 * /* pValue_return */), /* XXX prototype */
     void        (* /*BracketValues*/) (
-        pointer /* pCounter */, 
+        void * /* pCounter */,
         CARD64 * /* pbracket_less */,
         CARD64 * /* pbracket_greater */)
 );
@@ -485,7 +485,7 @@ extern void SyncChangeCounter(
 );
 
 extern void SyncDestroySystemCounter(
-    pointer pCounter
+    void * pCounter
 );
 extern void InitServertime(void);
 
diff --git a/nx-X11/include/extensions/xtrapproto.h b/nx-X11/include/extensions/xtrapproto.h
index b3e29cfaa..7eb8f9d47 100644
--- a/nx-X11/include/extensions/xtrapproto.h
+++ b/nx-X11/include/extensions/xtrapproto.h
@@ -44,7 +44,7 @@ SOFTWARE.
 # define Bool int
 #endif
 /* xtrapdi.c */
-int XETrapDestroyEnv (pointer value , XID id );
+int XETrapDestroyEnv (void * value , XID id );
 void XETrapCloseDown ( ExtensionEntry *extEntry );
 Bool XETrapRedirectDevices (void );
 void DEC_XTRAPInit (void );
diff --git a/nx-X11/programs/Xserver/GL/glx/glxcmds.c b/nx-X11/programs/Xserver/GL/glx/glxcmds.c
index a1bb25975..c62585507 100644
--- a/nx-X11/programs/Xserver/GL/glx/glxcmds.c
+++ b/nx-X11/programs/Xserver/GL/glx/glxcmds.c
@@ -229,7 +229,7 @@ int DoCreateContext(__GLXclientState *cl, GLXContextID gcId,
     /*
     ** Register this context as a resource.
     */
-    if (!AddResource(gcId, __glXContextRes, (pointer)glxc)) {
+    if (!AddResource(gcId, __glXContextRes, (void *)glxc)) {
 	if (!isDirect) {
 	    (*glxc->gc->exports.destroyContext)((__GLcontext *)glxc->gc);
         }
@@ -1760,7 +1760,7 @@ static int __glXBindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc)
             if (ret == Success) {
                 if (barrier)
                     /* add source for cleanup when drawable is gone */
-                    AddResource(drawable, __glXSwapBarrierRes, (pointer)screen);
+                    AddResource(drawable, __glXSwapBarrierRes, (void *)screen);
                 else
                     /* delete source */
                     FreeResourceByType(drawable, __glXSwapBarrierRes, FALSE);
diff --git a/nx-X11/programs/Xserver/GL/glx/glxext.c b/nx-X11/programs/Xserver/GL/glx/glxext.c
index fa1382983..e7ed3975c 100644
--- a/nx-X11/programs/Xserver/GL/glx/glxext.c
+++ b/nx-X11/programs/Xserver/GL/glx/glxext.c
@@ -417,7 +417,7 @@ static int __glXDispatch(ClientPtr client)
 	** with the client so we will be notified when the client dies.
 	*/
 	XID xid = FakeClientID(client->index);
-	if (!AddResource( xid, __glXClientRes, (pointer)(long)client->index)) {
+	if (!AddResource( xid, __glXClientRes, (void *)(long)client->index)) {
 	    return BadAlloc;
 	}
 	ResetClientState(client->index);
@@ -471,7 +471,7 @@ static int __glXSwapDispatch(ClientPtr client)
 	** with the client so we will be notified when the client dies.
 	*/
 	XID xid = FakeClientID(client->index);
-	if (!AddResource( xid, __glXClientRes, (pointer)(long)client->index)) {
+	if (!AddResource( xid, __glXClientRes, (void *)(long)client->index)) {
 	    return BadAlloc;
 	}
 	ResetClientState(client->index);
diff --git a/nx-X11/programs/Xserver/GL/glxmodule.c b/nx-X11/programs/Xserver/GL/glxmodule.c
index f8c03913e..b97b7ef8a 100644
--- a/nx-X11/programs/Xserver/GL/glxmodule.c
+++ b/nx-X11/programs/Xserver/GL/glxmodule.c
@@ -1236,11 +1236,11 @@ static XF86ModuleVersionInfo VersRec =
 
 XF86ModuleData glxModuleData = { &VersRec, glxSetup, NULL };
 
-static pointer
-glxSetup(pointer module, pointer opts, int *errmaj, int *errmin)
+static void *
+glxSetup(void * module, void * opts, int *errmaj, int *errmin)
 {
     static Bool setupDone = FALSE;
-    pointer GLcore  = NULL;
+    void * GLcore  = NULL;
 #ifdef GLX_USE_SGI_SI
     char GLcoreName[] = "GL";
 #else
diff --git a/nx-X11/programs/Xserver/GL/mesa/GLcore/GLcoremodule.c b/nx-X11/programs/Xserver/GL/mesa/GLcore/GLcoremodule.c
index 4e03b59fe..e0bbd193d 100644
--- a/nx-X11/programs/Xserver/GL/mesa/GLcore/GLcoremodule.c
+++ b/nx-X11/programs/Xserver/GL/mesa/GLcore/GLcoremodule.c
@@ -56,9 +56,9 @@ static XF86ModuleVersionInfo VersRec =
 
 XF86ModuleData GLcoreModuleData = { &VersRec, GLcoreSetup, NULL };
 
-static pointer
-GLcoreSetup(pointer module, pointer opts, int *errmaj, int *errmin)
+static void *
+GLcoreSetup(void * module, void * opts, int *errmaj, int *errmin)
 {
     /* Need a non-NULL return value to indicate success */
-    return (pointer)1;
+    return (void *)1;
 }
diff --git a/nx-X11/programs/Xserver/XTrap/xf86XTrapModule.c b/nx-X11/programs/Xserver/XTrap/xf86XTrapModule.c
index 1783d577a..3b9955eba 100644
--- a/nx-X11/programs/Xserver/XTrap/xf86XTrapModule.c
+++ b/nx-X11/programs/Xserver/XTrap/xf86XTrapModule.c
@@ -41,11 +41,11 @@ static XF86ModuleVersionInfo xtrapVersRec =
 
 XF86ModuleData xtrapModuleData = { &xtrapVersRec, xtrapSetup, NULL };
 
-static pointer
-xtrapSetup(pointer module, pointer opts, int *errmaj, int *errmin) {
+static void *
+xtrapSetup(void * module, void * opts, int *errmaj, int *errmin) {
     LoadExtension(&xtrapExt, FALSE);
     /* Need a non-NULL return value to indicate success */
-    return (pointer)1;
+    return (void *)1;
 }
 
 #endif /* XFree86LOADER */
diff --git a/nx-X11/programs/Xserver/XTrap/xtrapdi.c b/nx-X11/programs/Xserver/XTrap/xtrapdi.c
index 1055429d4..bdddb6310 100644
--- a/nx-X11/programs/Xserver/XTrap/xtrapdi.c
+++ b/nx-X11/programs/Xserver/XTrap/xtrapdi.c
@@ -195,7 +195,7 @@ static void GetSendColorPlanesRep (ClientPtr client , xResourceReq *req );
  *      client would be reset here.
  *
  */
-int XETrapDestroyEnv(pointer value, XID id)
+int XETrapDestroyEnv(void * value, XID id)
 {
     xXTrapReq request;
     XETrapEnv *penv = XETenv[(long)value];
@@ -251,7 +251,7 @@ void XETrapCloseDown(ExtensionEntry *extEntry)
     {
         if (XETenv[i] != NULL)
         {
-            XETrapDestroyEnv((pointer)i,0L);
+            XETrapDestroyEnv((void *)i,0L);
         }
     }
     ignore_grabs = False;
@@ -508,7 +508,7 @@ int XETrapCreateEnv(ClientPtr client)
         penv->protocol = 31;    /* default to backwards compatibility */
         /* prep for client's departure (for memory dealloc, cleanup) */
         AddResource(FakeClientID(client->index),XETrapType,
-            (pointer)(long)(client->index));
+            (void *)(long)(client->index));
         if (XETrapRedirectDevices() == False)
         {
             status = XETrapErrorBase + BadDevices;
diff --git a/nx-X11/programs/Xserver/Xext/appgroup.c b/nx-X11/programs/Xserver/Xext/appgroup.c
index ad4afa9e4..e23ceca59 100644
--- a/nx-X11/programs/Xserver/Xext/appgroup.c
+++ b/nx-X11/programs/Xserver/Xext/appgroup.c
@@ -92,7 +92,7 @@ extern int connBlockScreenStart;
 
 static 
 int XagAppGroupFree(
-    pointer what,
+    void * what,
     XID id) /* unused */
 {
     int i;
@@ -126,8 +126,8 @@ int XagAppGroupFree(
 /* static */
 void XagClientStateChange(
     CallbackListPtr* pcbl,
-    pointer nulldata,
-    pointer calldata)
+    void * nulldata,
+    void * calldata)
 {
     SecurityAuthorizationPtr pAuth;
     NewClientInfoRec* pci = (NewClientInfoRec*) calldata;
@@ -262,7 +262,7 @@ void XagResetProc(
 {
     DeleteCallback (&ClientStateCallback, XagClientStateChange, NULL);
     XagCallbackRefCount = 0;
-    while (appGrpList) XagAppGroupFree ((pointer) appGrpList, 0);
+    while (appGrpList) XagAppGroupFree ((void *) appGrpList, 0);
 }
 
 static 
@@ -476,7 +476,7 @@ int ProcXagCreate (
 	return BadAlloc;
     ret = AttrValidate (client, stuff->attrib_mask, pAppGrp);
     if (ret != Success) {
-	XagAppGroupFree ((pointer)pAppGrp, (XID)0);
+	XagAppGroupFree ((void *)pAppGrp, (XID)0);
 	return ret;
     }
     if (pAppGrp->single_screen) {
@@ -484,7 +484,7 @@ int ProcXagCreate (
 	if (!pAppGrp->ConnectionInfo)
 	    return BadAlloc;
     }
-    if (!AddResource (stuff->app_group, RT_APPGROUP, (pointer)pAppGrp))
+    if (!AddResource (stuff->app_group, RT_APPGROUP, (void *)pAppGrp))
 	return BadAlloc;
     if (XagCallbackRefCount++ == 0)
 	(void) AddCallback (&ClientStateCallback, XagClientStateChange, NULL);
@@ -824,6 +824,6 @@ void XagCallClientStateChange(
 	NewClientInfoRec clientinfo;
 
 	clientinfo.client = client;
-	XagClientStateChange (NULL, NULL, (pointer)&clientinfo);
+	XagClientStateChange (NULL, NULL, (void *)&clientinfo);
     }
 }
diff --git a/nx-X11/programs/Xserver/Xext/appgroup.h b/nx-X11/programs/Xserver/Xext/appgroup.h
index 05c9ef124..2a8feb585 100644
--- a/nx-X11/programs/Xserver/Xext/appgroup.h
+++ b/nx-X11/programs/Xserver/Xext/appgroup.h
@@ -2,8 +2,8 @@
 
 void XagClientStateChange(
     CallbackListPtr* pcbl,
-    pointer nulldata,
-    pointer calldata);
+    void * nulldata,
+    void * calldata);
 int ProcXagCreate (
     register ClientPtr client);
 int ProcXagDestroy(
diff --git a/nx-X11/programs/Xserver/Xext/extmod/modinit.c b/nx-X11/programs/Xserver/Xext/extmod/modinit.c
index 3c2044f78..f79204281 100644
--- a/nx-X11/programs/Xserver/Xext/extmod/modinit.c
+++ b/nx-X11/programs/Xserver/Xext/extmod/modinit.c
@@ -232,8 +232,8 @@ static XF86ModuleVersionInfo VersRec =
  */
 XF86ModuleData extmodModuleData = { &VersRec, extmodSetup, NULL };
 
-static pointer
-extmodSetup(pointer module, pointer opts, int *errmaj, int *errmin)
+static void *
+extmodSetup(void * module, void * opts, int *errmaj, int *errmin)
 {
     int i;
 
@@ -244,7 +244,7 @@ extmodSetup(pointer module, pointer opts, int *errmaj, int *errmin)
 	    char *s;
 	    s = (char *)xalloc(strlen(extensionModules[i].name) + 5);
 	    if (s) {
-		pointer o;
+		void * o;
 		strcpy(s, "omit");
 		strcat(s, extensionModules[i].name);
 		o = xf86FindOption(opts, s);
@@ -258,7 +258,7 @@ extmodSetup(pointer module, pointer opts, int *errmaj, int *errmin)
 	LoadExtension(&extensionModules[i], FALSE);
     }
     /* Need a non-NULL return */
-    return (pointer)1;
+    return (void *)1;
 }
 
 #endif /* XFree86LOADER */
diff --git a/nx-X11/programs/Xserver/Xext/mbuf.c b/nx-X11/programs/Xserver/Xext/mbuf.c
index 3129edd87..37024da19 100644
--- a/nx-X11/programs/Xserver/Xext/mbuf.c
+++ b/nx-X11/programs/Xserver/Xext/mbuf.c
@@ -107,7 +107,7 @@ static int		EventSelectForMultibuffer(
  */
 RESTYPE			MultibufferDrawableResType;
 static int		MultibufferDrawableDelete (
-				pointer /* value */,
+				void * /* value */,
 				XID /* id */
 				);
 /*
@@ -117,7 +117,7 @@ static int		MultibufferDrawableDelete (
  */
 static RESTYPE		MultibufferResType;
 static int		MultibufferDelete (
-				pointer /* value */,
+				void * /* value */,
 				XID /* id */
 				);
 
@@ -127,7 +127,7 @@ static int		MultibufferDelete (
  */
 static RESTYPE		MultibuffersResType;
 static int		MultibuffersDelete (
-				pointer /* value */,
+				void * /* value */,
 				XID /* id */
 				);
 
@@ -137,7 +137,7 @@ static int		MultibuffersDelete (
  */
 static RESTYPE		OtherClientResType;
 static int		OtherClientDelete (
-				pointer /* value */,
+				void * /* value */,
 				XID /* id */
 				);
 
@@ -229,7 +229,7 @@ MultibufferExtensionInit()
 		xfree (screenInfo.screens[j]->devPrivates[MultibufferScreenIndex].ptr);
 	    return;
 	}
-	pScreen->devPrivates[MultibufferScreenIndex].ptr = (pointer) pMultibufferScreen;
+	pScreen->devPrivates[MultibufferScreenIndex].ptr = (void *) pMultibufferScreen;
 	/*
  	 * wrap PositionWindow to resize the pixmap when the window
 	 * changes size
@@ -312,7 +312,7 @@ SetupBackgroundPainter (pWin, pGC)
     WindowPtr	pWin;
     GCPtr	pGC;
 {
-    pointer	    gcvalues[4];
+    void	    *gcvalues[4];
     int		    ts_x_origin, ts_y_origin;
     PixUnion	    background;
     int		    backgroundState;
@@ -337,21 +337,21 @@ SetupBackgroundPainter (pWin, pGC)
     switch (backgroundState)
     {
     case BackgroundPixel:
-	gcvalues[0] = (pointer) background.pixel;
-	gcvalues[1] = (pointer) FillSolid;
+	gcvalues[0] = (void *) background.pixel;
+	gcvalues[1] = (void *) FillSolid;
 	gcmask = GCForeground|GCFillStyle;
 	break;
 
     case BackgroundPixmap:
-	gcvalues[0] = (pointer) FillTiled;
-	gcvalues[1] = (pointer) background.pixmap;
-	gcvalues[2] = (pointer)(long) ts_x_origin;
-	gcvalues[3] = (pointer)(long) ts_y_origin;
+	gcvalues[0] = (void *) FillTiled;
+	gcvalues[1] = (void *) background.pixmap;
+	gcvalues[2] = (void *)(long) ts_x_origin;
+	gcvalues[3] = (void *)(long) ts_y_origin;
 	gcmask = GCFillStyle|GCTile|GCTileStipXOrigin|GCTileStipYOrigin;
 	break;
 
     default:
-	gcvalues[0] = (pointer) GXnoop;
+	gcvalues[0] = (void *) GXnoop;
 	gcmask = GCFunction;
     }
     DoChangeGC(pGC, gcmask, (XID *)gcvalues, TRUE);
@@ -381,7 +381,7 @@ CreateImageBuffers (pWin, nbuf, ids, action, hint)
     pMultibuffers->pWindow = pWin;
     pMultibuffers->buffers = (MultibufferPtr) (pMultibuffers + 1);
     pMultibuffers->refcnt = pMultibuffers->numMultibuffer = 0;
-    if (!AddResource (pWin->drawable.id, MultibuffersResType, (pointer) pMultibuffers))
+    if (!AddResource (pWin->drawable.id, MultibuffersResType, (void *) pMultibuffers))
 	return BadAlloc;
     width = pWin->drawable.width;
     height = pWin->drawable.height;
@@ -407,12 +407,12 @@ CreateImageBuffers (pWin, nbuf, ids, action, hint)
 	pMultibuffer->side = MultibufferSideMono;
 	pMultibuffer->clobber = MultibufferUnclobbered;
 	pMultibuffer->pMultibuffers = pMultibuffers;
-	if (!AddResource (ids[i], MultibufferResType, (pointer) pMultibuffer))
+	if (!AddResource (ids[i], MultibufferResType, (void *) pMultibuffer))
 	    break;
 	pMultibuffer->pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height, depth);
 	if (!pMultibuffer->pPixmap)
 	    break;
-	if (!AddResource (ids[i], MultibufferDrawableResType, (pointer) pMultibuffer->pPixmap))
+	if (!AddResource (ids[i], MultibufferDrawableResType, (void *) pMultibuffer->pPixmap))
 	{
 	    FreeResource (ids[i], MultibufferResType);
 	    (*pScreen->DestroyPixmap) (pMultibuffer->pPixmap);
@@ -439,7 +439,7 @@ CreateImageBuffers (pWin, nbuf, ids, action, hint)
     pMultibuffers->lastUpdate.milliseconds = 0;
     pMultibuffers->width = width;
     pMultibuffers->height = height;
-    pWin->devPrivates[MultibufferWindowIndex].ptr = (pointer) pMultibuffers;
+    pWin->devPrivates[MultibufferWindowIndex].ptr = (void *) pMultibuffers;
     if (pClearGC) FreeScratchGC(pClearGC);
     return Success;
 }
@@ -693,7 +693,7 @@ ProcGetMBufferAttributes (client)
 		   (char *)&rep);
     WriteToClient (client, (int)(pMultibuffers->numMultibuffer * sizeof (XID)),
 		   (char *)ids);
-    DEALLOCATE_LOCAL((pointer) ids);
+    DEALLOCATE_LOCAL((void *) ids);
     return client->noClientException;
 }
 
@@ -842,9 +842,9 @@ ProcGetBufferInfo (client)
 	    k++;
 	}
     }
-    WriteToClient (client, sizeof (xMbufGetBufferInfoReply), (pointer) &rep);
-    WriteToClient (client, (int) nInfo * sizeof (xMbufBufferInfo), (pointer) pInfo);
-    DEALLOCATE_LOCAL ((pointer) pInfo);
+    WriteToClient (client, sizeof (xMbufGetBufferInfoReply), (void *) &rep);
+    WriteToClient (client, (int) nInfo * sizeof (xMbufBufferInfo), (void *) pInfo);
+    DEALLOCATE_LOCAL ((void *) pInfo);
     return client->noClientException;
 }
 
@@ -1463,7 +1463,7 @@ AliasMultibuffer (pMultibuffers, i)
 	pMultibuffer = &pMultibuffers->buffers[pMultibuffers->displayedMultibuffer];
 	ChangeResourceValue (pMultibuffer->pPixmap->drawable.id,
 			     MultibufferDrawableResType,
- 			     (pointer) pMultibuffer->pPixmap);
+			     (void *) pMultibuffer->pPixmap);
     }
     /*
      * make the new association
@@ -1471,7 +1471,7 @@ AliasMultibuffer (pMultibuffers, i)
     pMultibuffer = &pMultibuffers->buffers[i];
     ChangeResourceValue (pMultibuffer->pPixmap->drawable.id,
 			 MultibufferDrawableResType,
-			 (pointer) pMultibuffers->pWindow);
+			 (void *) pMultibuffers->pWindow);
     pMultibuffers->displayedMultibuffer = i;
 }
 
@@ -1608,7 +1608,7 @@ MultibufferPositionWindow (pWin, x, y)
 	{
 	    ChangeResourceValue (pPixmap->drawable.id,
 				 MultibufferDrawableResType,
-				 (pointer) pPixmap);
+				 (void *) pPixmap);
 	}
     }
     FreeScratchGC (pGC);
@@ -1619,7 +1619,7 @@ MultibufferPositionWindow (pWin, x, y)
 /*ARGSUSED*/
 static int
 MultibufferDrawableDelete (value, id)
-    pointer	value;
+    void	*value;
     XID		id;
 {
     DrawablePtr	pDrawable = (DrawablePtr)value;
@@ -1645,7 +1645,7 @@ MultibufferDrawableDelete (value, id)
 /*ARGSUSED*/
 static int
 MultibufferDelete (value, id)
-    pointer	value;
+    void	*value;
     XID		id;
 {
     MultibufferPtr	pMultibuffer = (MultibufferPtr)value;
@@ -1665,7 +1665,7 @@ MultibufferDelete (value, id)
 /*ARGSUSED*/
 static int
 MultibuffersDelete (value, id)
-    pointer	value;
+    void	*value;
     XID		id;
 {
     MultibuffersPtr	pMultibuffers = (MultibuffersPtr)value;
@@ -1682,7 +1682,7 @@ MultibuffersDelete (value, id)
 /* Resource delete func for OtherClientResType */
 static int
 OtherClientDelete (value, id)
-    pointer	value;
+    void	*value;
     XID		id;
 {
     MultibufferPtr	pMultibuffer = (MultibufferPtr)value;
@@ -1745,7 +1745,7 @@ EventSelectForMultibuffer (pMultibuffer, client, mask)
 		return BadAlloc;
 	    other->mask = mask;
 	    other->resource = FakeClientID (client->index);
-	    if (!AddResource (other->resource, OtherClientResType, (pointer) pMultibuffer))
+	    if (!AddResource (other->resource, OtherClientResType, (void *) pMultibuffer))
 	    {
 		xfree (other);
 		return BadAlloc;
diff --git a/nx-X11/programs/Xserver/Xext/mbufbf.c b/nx-X11/programs/Xserver/Xext/mbufbf.c
index 8585c52d2..84e7ee839 100644
--- a/nx-X11/programs/Xserver/Xext/mbufbf.c
+++ b/nx-X11/programs/Xserver/Xext/mbufbf.c
@@ -230,7 +230,7 @@ bufMultibufferInit(pScreen, pMBScreen)
     if (!pMBPriv)
 	return (FALSE);
 
-    pMBScreen->devPrivate.ptr = (pointer) pMBPriv;
+    pMBScreen->devPrivate.ptr = (void *) pMBPriv;
     pMBPriv->frameBuffer  = bufFrameBuffer[pScreen->myNum];
     pMBPriv->selectPlane = bufselectPlane[pScreen->myNum];
 
@@ -374,7 +374,7 @@ bufCreateImageBuffers (pWin, nbuf, ids, action, hint)
     pMBScreen = MB_SCREEN_PRIV(pScreen);
     pMBWindow = MB_WINDOW_PRIV(pWin);
 
-    pMBWindow->devPrivate.ptr = (pointer) REGION_CREATE(pScreen, 0,0);
+    pMBWindow->devPrivate.ptr = (void *) REGION_CREATE(pScreen, 0,0);
     if (!pMBWindow->devPrivate.ptr)
 	return(0);
     REGION_COPY(pScreen, (RegionPtr) pMBWindow->devPrivate.ptr,
@@ -389,7 +389,7 @@ bufCreateImageBuffers (pWin, nbuf, ids, action, hint)
 	    break;
 
 	if (!AddResource (ids[i], MultibufferDrawableResType,
-			  (pointer) pMBBuffer->pDrawable))
+			  (void *) pMBBuffer->pDrawable))
 	{
 	    bufDestroyBuffer((BufferPtr) pMBBuffer->pDrawable);
 	    break;
diff --git a/nx-X11/programs/Xserver/Xext/mbufpx.c b/nx-X11/programs/Xserver/Xext/mbufpx.c
index c986217ee..0973fc324 100644
--- a/nx-X11/programs/Xserver/Xext/mbufpx.c
+++ b/nx-X11/programs/Xserver/Xext/mbufpx.c
@@ -124,7 +124,7 @@ pixMultibufferInit(pScreen, pMBScreen)
 	xfree(pInfo);
 	return (FALSE);
     }
-    pMBScreen->devPrivate.ptr = (pointer) pMBPriv;
+    pMBScreen->devPrivate.ptr = (void *) pMBPriv;
     pMBPriv->PositionWindow = NULL;
     pMBPriv->funcsWrapped = 0;
 
@@ -162,7 +162,7 @@ pixCreateImageBuffers (pWin, nbuf, ids, action, hint)
 	    break;
 
 	if (!AddResource (ids[i], MultibufferDrawableResType,
-			  (pointer) pMBBuffer->pDrawable))
+			  (void *) pMBBuffer->pDrawable))
 	{
 	    (*pScreen->DestroyPixmap) ((PixmapPtr) pMBBuffer->pDrawable);
 	    break;
@@ -570,7 +570,7 @@ pixPositionWindow (pWin, x, y)
 	{
 	    ChangeResourceValue (pPixmap->drawable.id,
 				 MultibufferDrawableResType,
-				 (pointer) pPixmap);
+				 (void *) pPixmap);
 	}
     }
     FreeScratchGC (pGC);
diff --git a/nx-X11/programs/Xserver/Xext/panoramiX.c b/nx-X11/programs/Xserver/Xext/panoramiX.c
index a1a5b9f1f..2dc011e70 100644
--- a/nx-X11/programs/Xserver/Xext/panoramiX.c
+++ b/nx-X11/programs/Xserver/Xext/panoramiX.c
@@ -133,7 +133,7 @@ static void XineramaValidateGC(GCPtr, unsigned long, DrawablePtr);
 static void XineramaChangeGC(GCPtr, unsigned long);
 static void XineramaCopyGC(GCPtr, unsigned long, GCPtr);
 static void XineramaDestroyGC(GCPtr);
-static void XineramaChangeClip(GCPtr, int, pointer, int);
+static void XineramaChangeClip(GCPtr, int, void *, int);
 static void XineramaDestroyClip(GCPtr);
 static void XineramaCopyClip(GCPtr, GCPtr);
 
@@ -165,7 +165,7 @@ XineramaCloseScreen (int i, ScreenPtr pScreen)
     if (pScreen->myNum == 0)
 	REGION_UNINIT(pScreen, &PanoramiXScreenRegion);
 
-    xfree ((pointer) pScreenPriv);
+    xfree ((void *) pScreenPriv);
 
     return (*pScreen->CloseScreen) (i, pScreen);
 }
@@ -308,7 +308,7 @@ static void
 XineramaChangeClip (
     GCPtr   pGC,
     int		type,
-    pointer	pvalue,
+    void	*pvalue,
     int		nrects 
 ){
     Xinerama_GC_FUNC_PROLOGUE (pGC);
@@ -335,7 +335,7 @@ XineramaDestroyClip(GCPtr pGC)
 
 
 int
-XineramaDeleteResource(pointer data, XID id)
+XineramaDeleteResource(void * data, XID id)
 {
     xfree(data);
     return 1;
@@ -343,7 +343,7 @@ XineramaDeleteResource(pointer data, XID id)
 
 
 static Bool 
-XineramaFindIDOnAnyScreen(pointer resource, XID id, pointer privdata)
+XineramaFindIDOnAnyScreen(void * resource, XID id, void * privdata)
 {
     PanoramiXRes *res = (PanoramiXRes*)resource;
     int j;
@@ -368,7 +368,7 @@ typedef struct {
 
 
 static Bool 
-XineramaFindIDByScrnum(pointer resource, XID id, pointer privdata)
+XineramaFindIDByScrnum(void * resource, XID id, void * privdata)
 {
     PanoramiXRes *res = (PanoramiXRes*)resource;
     PanoramiXSearchData *data = (PanoramiXSearchData*)privdata;
@@ -541,7 +541,7 @@ void PanoramiXExtensionInit(int argc, char *argv[])
 
 	   pScreenPriv = xalloc(sizeof(PanoramiXScreenRec));
 	   pScreen->devPrivates[PanoramiXScreenIndex].ptr = 
-						(pointer)pScreenPriv;
+						(void *)pScreenPriv;
 	   if(!pScreenPriv) {
 		noPanoramiXExtension = TRUE;
 		return;
@@ -747,9 +747,9 @@ Bool PanoramiXCreateConnectionBlock(void)
     root->mmHeight *= height_mult;
 
     while(ConnectionCallbackList) {
-	pointer tmp;
+	void *tmp;
 
-	tmp = (pointer)ConnectionCallbackList;
+	tmp = (void *)ConnectionCallbackList;
 	(*ConnectionCallbackList->func)();
 	ConnectionCallbackList = ConnectionCallbackList->next;
 	xfree(tmp);
diff --git a/nx-X11/programs/Xserver/Xext/panoramiXsrv.h b/nx-X11/programs/Xserver/Xext/panoramiXsrv.h
index dc3b3d805..8fa2d3d05 100644
--- a/nx-X11/programs/Xserver/Xext/panoramiXsrv.h
+++ b/nx-X11/programs/Xserver/Xext/panoramiXsrv.h
@@ -22,7 +22,7 @@ extern PanoramiXRes * PanoramiXFindIDByScrnum(RESTYPE, XID, int);
 extern PanoramiXRes * PanoramiXFindIDOnAnyScreen(RESTYPE, XID);
 extern WindowPtr PanoramiXChangeWindow(int, WindowPtr);
 extern Bool XineramaRegisterConnectionBlockCallback(void (*func)(void));
-extern int XineramaDeleteResource(pointer, XID);
+extern int XineramaDeleteResource(void *, XID);
 
 extern void XineramaReinitData(ScreenPtr);
 
diff --git a/nx-X11/programs/Xserver/Xext/saver.c b/nx-X11/programs/Xserver/Xext/saver.c
index 14b0d2751..4a7fc054c 100644
--- a/nx-X11/programs/Xserver/Xext/saver.c
+++ b/nx-X11/programs/Xserver/Xext/saver.c
@@ -139,7 +139,7 @@ typedef struct _ScreenSaverEvent {
 } ScreenSaverEventRec;
 
 static int ScreenSaverFreeEvents(
-    pointer /* value */,
+    void * /* value */,
     XID /* id */
 );
 
@@ -179,7 +179,7 @@ typedef struct _ScreenSaverAttr {
 } ScreenSaverAttrRec, *ScreenSaverAttrPtr;
 
 static int ScreenSaverFreeAttr (
-    pointer /* value */,
+    void * /* value */,
     XID /* id */
 );
 
@@ -213,7 +213,7 @@ MakeScreenPrivate (
 static int ScreenPrivateIndex;
 
 #define GetScreenPrivate(s) ((ScreenSaverScreenPrivatePtr)(s)->devPrivates[ScreenPrivateIndex].ptr)
-#define SetScreenPrivate(s,v) ((s)->devPrivates[ScreenPrivateIndex].ptr = (pointer) v);
+#define SetScreenPrivate(s,v) ((s)->devPrivates[ScreenPrivateIndex].ptr = (void *) v);
 #define SetupScreen(s)	ScreenSaverScreenPrivatePtr pPriv = (s ? GetScreenPrivate(s) : NULL)
 
 #define New(t)	((t *) xalloc (sizeof (t)))
@@ -356,7 +356,7 @@ setEventMask (pScreen, client, mask)
     	    pEv->client = client;
     	    pEv->screen = pScreen;
     	    pEv->resource = FakeClientID (client->index);
-	    if (!AddResource (pEv->resource, EventType, (pointer) pEv))
+	    if (!AddResource (pEv->resource, EventType, (void *) pEv))
 		return FALSE;
     	}
 	pEv->mask = mask;
@@ -390,7 +390,7 @@ FreeScreenAttr (pAttr)
 
 static int
 ScreenSaverFreeEvents (value, id)
-    pointer value;
+    void * value;
     XID id;
 {
     ScreenSaverEventPtr	pOld = (ScreenSaverEventPtr)value;
@@ -413,7 +413,7 @@ ScreenSaverFreeEvents (value, id)
 
 static int
 ScreenSaverFreeAttr (value, id)
-    pointer value;
+    void * value;
     XID id;
 {
     ScreenSaverAttrPtr	pOldAttr = (ScreenSaverAttrPtr)value;
@@ -1163,7 +1163,7 @@ ScreenSaverSetAttributes (ClientPtr client)
 	FreeScreenAttr (pPriv->attr);
     pPriv->attr = pAttr;
     pAttr->resource = FakeClientID (client->index);
-    if (!AddResource (pAttr->resource, AttrType, (pointer) pAttr))
+    if (!AddResource (pAttr->resource, AttrType, (void *) pAttr))
 	return BadAlloc;
     return Success;
 PatchUp:
diff --git a/nx-X11/programs/Xserver/Xext/security.c b/nx-X11/programs/Xserver/Xext/security.c
index 8e97a7e54..4bc49f408 100644
--- a/nx-X11/programs/Xserver/Xext/security.c
+++ b/nx-X11/programs/Xserver/Xext/security.c
@@ -288,7 +288,7 @@ SecurityAudit(char *format, ...)
 
 static int
 SecurityDeleteAuthorization(
-    pointer value,
+    void * value,
     XID id)
 {
     SecurityAuthorizationPtr pAuth = (SecurityAuthorizationPtr)value;
@@ -347,7 +347,7 @@ SecurityDeleteAuthorization(
 /* resource delete function for RTEventClient */
 static int
 SecurityDeleteAuthorizationEventClient(
-    pointer value,
+    void * value,
     XID id)
 {
     OtherClientsPtr pEventClient, prev = NULL;
@@ -432,7 +432,7 @@ static CARD32
 SecurityAuthorizationExpired(
     OsTimerPtr timer,
     CARD32 time,
-    pointer pval)
+    void * pval)
 {
     SecurityAuthorizationPtr pAuth = (SecurityAuthorizationPtr)pval;
 
@@ -538,7 +538,7 @@ SecurityEventSelectForAuthorization(
     pEventClient->resource = FakeClientID(client->index);
     pEventClient->next = pAuth->eventClients;
     if (!AddResource(pEventClient->resource, RTEventClient,
-		     (pointer)pAuth))
+		     (void *)pAuth))
     {
 	xfree(pEventClient);
 	return BadAlloc;
@@ -624,7 +624,7 @@ ProcSecurityGenerateAuthorization(
 	    SecurityValidateGroupInfoRec vgi;
 	    vgi.group = group;
 	    vgi.valid = FALSE;
-	    CallCallbacks(&SecurityValidateGroupCallback, (pointer)&vgi);
+	    CallCallbacks(&SecurityValidateGroupCallback, (void *)&vgi);
 
 	    /* if nobody said they recognized it, it's an error */
 
@@ -1065,7 +1065,7 @@ SecurityCheckDeviceAccess(client, dev, fromRequest)
  *	resource access.
  */
 
-static pointer
+static void *
 SecurityAuditResourceIDAccess(
     ClientPtr client,
     XID id)
@@ -1119,13 +1119,13 @@ SecurityAuditResourceIDAccess(
  *	Disallowed resource accesses are audited.
  */
 
-static pointer
+static void *
 SecurityCheckResourceIDAccess(
     ClientPtr client,
     XID id,
     RESTYPE rtype,
     Mask access_mode,
-    pointer rval)
+    void * rval)
 {
     int cid = CLIENT_ID(id);
     int reqtype = ((xReq *)client->requestBuffer)->reqType;
@@ -1288,8 +1288,8 @@ SecurityCheckResourceIDAccess(
 static void
 SecurityClientStateCallback(
     CallbackListPtr *pcbl,
-    pointer nulldata,
-    pointer calldata)
+    void * nulldata,
+    void * calldata)
 {
     NewClientInfoRec *pci = (NewClientInfoRec *)calldata;
     ClientPtr client = pci->client;
@@ -1445,7 +1445,7 @@ SecurityCensorImage(client, pVisibleRegion, widthBytesLine, pDraw, x, y, w, h,
 
 	pPix = GetScratchPixmapHeader(pDraw->pScreen, w, h,
 		    depth, bitsPerPixel,
-		    widthBytesLine, (pointer)pBuf);
+		    widthBytesLine, (void *)pBuf);
 	if (!pPix)
 	{
 	    failed = TRUE;
diff --git a/nx-X11/programs/Xserver/Xext/shape.c b/nx-X11/programs/Xserver/Xext/shape.c
index 86b4b5603..02182398a 100644
--- a/nx-X11/programs/Xserver/Xext/shape.c
+++ b/nx-X11/programs/Xserver/Xext/shape.c
@@ -58,11 +58,11 @@ typedef	RegionPtr (*CreateDftPtr)(
 	);
 
 static int ShapeFreeClient(
-	pointer /* data */,
+	void * /* data */,
 	XID /* id */
 	);
 static int ShapeFreeEvents(
-	pointer /* data */,
+	void * /* data */,
 	XID /* id */
 	);
 static void ShapeResetProc(
@@ -774,7 +774,7 @@ ProcShapeQueryExtents (client)
 /*ARGSUSED*/
 static int
 ShapeFreeClient (data, id)
-    pointer	    data;
+    void	    *data;
     XID		    id;
 {
     ShapeEventPtr   pShapeEvent;
@@ -796,14 +796,14 @@ ShapeFreeClient (data, id)
 	    	*pHead = pShapeEvent->next;
 	}
     }
-    xfree ((pointer) pShapeEvent);
+    xfree ((void *) pShapeEvent);
     return 1;
 }
 
 /*ARGSUSED*/
 static int
 ShapeFreeEvents (data, id)
-    pointer	    data;
+    void	    *data;
     XID		    id;
 {
     ShapeEventPtr   *pHead, pCur, pNext;
@@ -812,9 +812,9 @@ ShapeFreeEvents (data, id)
     for (pCur = *pHead; pCur; pCur = pNext) {
 	pNext = pCur->next;
 	FreeResource (pCur->clientResource, ClientType);
-	xfree ((pointer) pCur);
+	xfree ((void *) pCur);
     }
-    xfree ((pointer) pHead);
+    xfree ((void *) pHead);
     return 1;
 }
 
@@ -861,7 +861,7 @@ ProcShapeSelectInput (client)
      	 */
    	clientResource = FakeClientID (client->index);
     	pNewShapeEvent->clientResource = clientResource;
-    	if (!AddResource (clientResource, ClientType, (pointer)pNewShapeEvent))
+	if (!AddResource (clientResource, ClientType, (void *)pNewShapeEvent))
 	    return BadAlloc;
     	/*
      	 * create a resource to contain a pointer to the list
@@ -873,7 +873,7 @@ ProcShapeSelectInput (client)
     	{
 	    pHead = (ShapeEventPtr *) xalloc (sizeof (ShapeEventPtr));
 	    if (!pHead ||
-	    	!AddResource (pWin->drawable.id, EventType, (pointer)pHead))
+		!AddResource (pWin->drawable.id, EventType, (void *)pHead))
 	    {
 	    	FreeResource (clientResource, RT_NONE);
 	    	return BadAlloc;
diff --git a/nx-X11/programs/Xserver/Xext/shm.c b/nx-X11/programs/Xserver/Xext/shm.c
index dfb85c3ec..d500e551c 100644
--- a/nx-X11/programs/Xserver/Xext/shm.c
+++ b/nx-X11/programs/Xserver/Xext/shm.c
@@ -86,7 +86,7 @@ static void miShmPutImage(XSHM_PUT_IMAGE_ARGS);
 static void fbShmPutImage(XSHM_PUT_IMAGE_ARGS);
 static PixmapPtr fbShmCreatePixmap(XSHM_CREATE_PIXMAP_ARGS);
 static int ShmDetachSegment(
-    pointer		/* value */,
+    void *		/* value */,
     XID			/* shmseg */
     );
 static void ShmResetProc(
@@ -309,7 +309,7 @@ ShmDestroyPixmap (PixmapPtr pPixmap)
 #else
 	char	*base = (char *) pPixmap->devPrivate.ptr;
 	
-	if (base != (pointer) (pPixmap + 1))
+	if (base != (void *) (pPixmap + 1))
 	{
 	    for (shmdesc = Shmsegs; shmdesc; shmdesc = shmdesc->next)
 	    {
@@ -321,7 +321,7 @@ ShmDestroyPixmap (PixmapPtr pPixmap)
 	    shmdesc = 0;
 #endif
 	if (shmdesc)
-	    ShmDetachSegment ((pointer) shmdesc, pPixmap->drawable.id);
+	    ShmDetachSegment ((void *) shmdesc, pPixmap->drawable.id);
     }
     
     pScreen->DestroyPixmap = destroyPixmap[pScreen->myNum];
@@ -465,7 +465,7 @@ ProcShmAttach(client)
 	shmdesc->next = Shmsegs;
 	Shmsegs = shmdesc;
     }
-    if (!AddResource(stuff->shmseg, ShmSegType, (pointer)shmdesc))
+    if (!AddResource(stuff->shmseg, ShmSegType, (void *)shmdesc))
 	return BadAlloc;
     return(client->noClientException);
 }
@@ -473,7 +473,7 @@ ProcShmAttach(client)
 /*ARGSUSED*/
 static int
 ShmDetachSegment(value, shmseg)
-    pointer value; /* must conform to DeleteType */
+    void * value; /* must conform to DeleteType */
     XID shmseg;
 {
     ShmDescPtr shmdesc = (ShmDescPtr)value;
@@ -548,7 +548,7 @@ fbShmPutImage(dst, pGC, depth, format, w, h, sx, sy, sw, sh, dx, dy, data)
 	PixmapPtr pPixmap;
 
 	pPixmap = GetScratchPixmapHeader(dst->pScreen, w, h, depth,
-		BitsPerPixel(depth), PixmapBytePad(w, depth), (pointer)data);
+		BitsPerPixel(depth), PixmapBytePad(w, depth), (void *)data);
 	if (!pPixmap)
 	    return;
 	if (format == XYBitmap)
@@ -794,12 +794,12 @@ CreatePmap:
 
 	if (pMap) {
 #ifdef PIXPRIV
-            pMap->devPrivates[shmPixmapPrivate].ptr = (pointer) shmdesc;
+            pMap->devPrivates[shmPixmapPrivate].ptr = (void *) shmdesc;
 #endif
             shmdesc->refcnt++;
 	    pMap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
 	    pMap->drawable.id = newPix->info[j].id;
-	    if (!AddResource(newPix->info[j].id, RT_PIXMAP, (pointer)pMap)) {
+	    if (!AddResource(newPix->info[j].id, RT_PIXMAP, (void *)pMap)) {
 		(*pScreen->DestroyPixmap)(pMap);
 		result = BadAlloc;
 		break;
@@ -1062,7 +1062,7 @@ fbShmCreatePixmap (pScreen, width, height, depth, addr)
 	return NullPixmap;
 
     if (!(*pScreen->ModifyPixmapHeader)(pPixmap, width, height, depth,
-	    BitsPerPixel(depth), PixmapBytePad(width, depth), (pointer)addr)) {
+	    BitsPerPixel(depth), PixmapBytePad(width, depth), (void *)addr)) {
 	(*pScreen->DestroyPixmap)(pPixmap);
 	return NullPixmap;
     }
@@ -1129,12 +1129,12 @@ CreatePmap:
     if (pMap)
     {
 #ifdef PIXPRIV
-	pMap->devPrivates[shmPixmapPrivate].ptr = (pointer) shmdesc;
+	pMap->devPrivates[shmPixmapPrivate].ptr = (void *) shmdesc;
 #endif
 	shmdesc->refcnt++;
 	pMap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
 	pMap->drawable.id = stuff->pid;
-	if (AddResource(stuff->pid, RT_PIXMAP, (pointer)pMap))
+	if (AddResource(stuff->pid, RT_PIXMAP, (void *)pMap))
 	{
 	    return(client->noClientException);
 	}
diff --git a/nx-X11/programs/Xserver/Xext/sleepuntil.c b/nx-X11/programs/Xserver/Xext/sleepuntil.c
index 8e0008cab..da93806f5 100644
--- a/nx-X11/programs/Xserver/Xext/sleepuntil.c
+++ b/nx-X11/programs/Xserver/Xext/sleepuntil.c
@@ -49,10 +49,10 @@ typedef struct _Sertafied {
     XID			id;
     void		(*notifyFunc)(
 			ClientPtr /* client */,
-			pointer /* closure */
+			void * /* closure */
 			);
 
-    pointer		closure;
+    void		*closure;
 } SertafiedRec, *SertafiedPtr;
 
 static SertafiedPtr pPending;
@@ -62,21 +62,21 @@ static int	    SertafiedGeneration;
 
 static void	    ClientAwaken(
     ClientPtr /* client */,
-    pointer /* closure */
+    void * /* closure */
 );
 static int	    SertafiedDelete(
-    pointer /* value */,
+    void * /* value */,
     XID /* id */
 );
 static void	    SertafiedBlockHandler(
-    pointer /* data */,
+    void * /* data */,
     OSTimePtr /* wt */,
-    pointer /* LastSelectMask */
+    void * /* LastSelectMask */
 );
 static void	    SertafiedWakeupHandler(
-    pointer /* data */,
+    void * /* data */,
     int /* i */,
-    pointer /* LastSelectMask */
+    void * /* LastSelectMask */
 );
 
 int
@@ -85,8 +85,8 @@ ClientSleepUntil (client, revive, notifyFunc, closure)
     TimeStamp	*revive;
     void	(*notifyFunc)(
         ClientPtr /* client */,
-        pointer   /* closure */);
-    pointer	closure;
+        void *   /* closure */);
+    void	*closure;
 {
     SertafiedPtr	pRequest, pReq, pPrev;
 
@@ -109,7 +109,7 @@ ClientSleepUntil (client, revive, notifyFunc, closure)
     {
 	if (!RegisterBlockAndWakeupHandlers (SertafiedBlockHandler,
 					     SertafiedWakeupHandler,
-					     (pointer) 0))
+					     (void *) 0))
 	{
 	    xfree (pRequest);
 	    return FALSE;
@@ -117,7 +117,7 @@ ClientSleepUntil (client, revive, notifyFunc, closure)
 	BlockHandlerRegistered = TRUE;
     }
     pRequest->notifyFunc = 0;
-    if (!AddResource (pRequest->id, SertafiedResType, (pointer) pRequest))
+    if (!AddResource (pRequest->id, SertafiedResType, (void *) pRequest))
 	return FALSE;
     if (!notifyFunc)
 	notifyFunc = ClientAwaken;
@@ -142,7 +142,7 @@ ClientSleepUntil (client, revive, notifyFunc, closure)
 static void
 ClientAwaken (client, closure)
     ClientPtr	client;
-    pointer	closure;
+    void	*closure;
 {
     if (!client->clientGone)
 	AttendClient (client);
@@ -151,7 +151,7 @@ ClientAwaken (client, closure)
 
 static int
 SertafiedDelete (value, id)
-    pointer value;
+    void * value;
     XID id;
 {
     SertafiedPtr	pRequest = (SertafiedPtr)value;
@@ -175,9 +175,9 @@ SertafiedDelete (value, id)
 
 static void
 SertafiedBlockHandler (data, wt, LastSelectMask)
-    pointer	    data;		/* unused */
+    void	    *data;		/* unused */
     OSTimePtr	    wt;			/* wait time */
-    pointer	    LastSelectMask;
+    void	    *LastSelectMask;
 {
     SertafiedPtr	    pReq, pNext;
     unsigned long	    delay;
@@ -211,9 +211,9 @@ SertafiedBlockHandler (data, wt, LastSelectMask)
 
 static void
 SertafiedWakeupHandler (data, i, LastSelectMask)
-    pointer	    data;
+    void *	    data;
     int		    i;
-    pointer	    LastSelectMask;
+    void *	    LastSelectMask;
 {
     SertafiedPtr	pReq, pNext;
     TimeStamp		now;
@@ -233,7 +233,7 @@ SertafiedWakeupHandler (data, i, LastSelectMask)
     {
 	RemoveBlockAndWakeupHandlers (SertafiedBlockHandler,
 				      SertafiedWakeupHandler,
-				      (pointer) 0);
+				      (void *) 0);
 	BlockHandlerRegistered = FALSE;
     }
 }
diff --git a/nx-X11/programs/Xserver/Xext/sleepuntil.h b/nx-X11/programs/Xserver/Xext/sleepuntil.h
index 0b99148a4..e828a7c8f 100644
--- a/nx-X11/programs/Xserver/Xext/sleepuntil.h
+++ b/nx-X11/programs/Xserver/Xext/sleepuntil.h
@@ -39,9 +39,9 @@ extern int ClientSleepUntil(
     TimeStamp *revive,
     void (*notifyFunc)(
 	ClientPtr /* client */,
-	pointer   /* closure */
+	void *   /* closure */
 	),
-    pointer Closure
+    void * Closure
 );
 
 #endif
diff --git a/nx-X11/programs/Xserver/Xext/sync.c b/nx-X11/programs/Xserver/Xext/sync.c
index e5b8ef946..006cefa86 100644
--- a/nx-X11/programs/Xserver/Xext/sync.c
+++ b/nx-X11/programs/Xserver/Xext/sync.c
@@ -103,40 +103,40 @@ static SyncCounter **SysCounterList = NULL;
 
 static int
 FreeAlarm(
-    pointer /* addr */,
+    void * /* addr */,
     XID /* id */
 );
 
 static int
 FreeAlarmClient(
-    pointer /* value */,
+    void * /* value */,
     XID /* id */
 );
 
 static int
 FreeAwait(
-    pointer /* addr */,
+    void * /* addr */,
     XID /* id */
 );
 
 static void
 ServertimeBracketValues(
-    pointer /* pCounter */,
+    void * /* pCounter */,
     CARD64 * /* pbracket_less */,
     CARD64 * /* pbracket_greater */
 );
 
 static void
 ServertimeQueryValue(
-    pointer /* pCounter */,
+    void * /* pCounter */,
     CARD64 * /* pValue_return */
 );
 
 static void
 ServertimeWakeupHandler(
-    pointer /* env */,
+    void * /* env */,
     int /* rc */,
-    pointer /* LastSelectMask */
+    void * /* LastSelectMask */
 );
 
 static int 
@@ -161,9 +161,9 @@ SCounterNotifyEvent(
 
 static void
 ServertimeBlockHandler(
-    pointer  /* env */,
+    void *  /* env */,
     struct timeval ** /* wt */,
-    pointer  /* LastSelectMask */
+    void *  /* LastSelectMask */
 );
 
 static int
@@ -449,7 +449,7 @@ SyncInitTrigger(client, pTrigger, counter, changes)
 
     if (IsSystemCounter(pCounter))
     {
-	(*pCounter->pSysCounterInfo->QueryValue) ((pointer) pCounter,
+	(*pCounter->pSysCounterInfo->QueryValue) ((void *) pCounter,
 						  &pCounter->value);
     }
 
@@ -1016,9 +1016,9 @@ SyncCreateCounter(client, id, initialvalue)
     if (!(pCounter = (SyncCounter *) xalloc(sizeof(SyncCounter))))
 	return (SyncCounter *)NULL;
 
-    if (!AddResource(id, RTCounter, (pointer) pCounter))
+    if (!AddResource(id, RTCounter, (void *) pCounter))
     {
-	xfree((pointer) pCounter);
+	xfree((void *) pCounter);
 	return (SyncCounter *)NULL;
     }
 
@@ -1032,7 +1032,7 @@ SyncCreateCounter(client, id, initialvalue)
 }
 
 static int FreeCounter(
-    pointer /*env*/,
+    void * /*env*/,
     XID     /*id*/
 );
 
@@ -1040,7 +1040,7 @@ static int FreeCounter(
  * ***** System Counter utilities
  */
 
-pointer 
+void *
 SyncCreateSystemCounter(name, initial, resolution, counterType,
 			QueryValue, BracketValues)
     char           *name;
@@ -1048,10 +1048,10 @@ SyncCreateSystemCounter(name, initial, resolution, counterType,
     CARD64          resolution;
     SyncCounterType counterType;
     void            (*QueryValue) (
-        pointer /* pCounter */, 
+        void * /* pCounter */, 
         CARD64 * /* pValue_return */);
     void            (*BracketValues) (
-        pointer /* pCounter */,
+        void * /* pCounter */,
         CARD64 * /* pbracket_less */,
         CARD64 * /* pbracket_greater */);
 {
@@ -1060,7 +1060,7 @@ SyncCreateSystemCounter(name, initial, resolution, counterType,
     SysCounterList = (SyncCounter **)xrealloc(SysCounterList,
 			    (SyncNumSystemCounters+1)*sizeof(SyncCounter *));
     if (!SysCounterList)
-	return (pointer)NULL;
+	return (void *)NULL;
 
     /* this function may be called before SYNC has been initialized, so we
      * have to make sure RTCounter is created.
@@ -1070,7 +1070,7 @@ SyncCreateSystemCounter(name, initial, resolution, counterType,
 	RTCounter = CreateNewResourceType(FreeCounter);
 	if (RTCounter == 0)
 	{
-	    return (pointer)NULL;
+	    return (void *)NULL;
 	}
     }
 
@@ -1084,7 +1084,7 @@ SyncCreateSystemCounter(name, initial, resolution, counterType,
 	if (!psci)
 	{
 	    FreeResource(pCounter->id, RT_NONE);
-	    return (pointer) pCounter;
+	    return (void *) pCounter;
 	}
 	pCounter->pSysCounterInfo = psci;
 	psci->name = name;
@@ -1096,12 +1096,12 @@ SyncCreateSystemCounter(name, initial, resolution, counterType,
 	XSyncMinValue(&psci->bracket_less);
 	SysCounterList[SyncNumSystemCounters++] = pCounter;
     }
-    return (pointer) pCounter;
+    return (void *) pCounter;
 }
 
 void
 SyncDestroySystemCounter(pSysCounter)
-    pointer pSysCounter;
+    void * pSysCounter;
 {
     SyncCounter *pCounter = (SyncCounter *)pSysCounter;
     FreeResource(pCounter->id, RT_NONE);
@@ -1186,7 +1186,7 @@ SyncComputeBracketValues(pCounter, startOver)
 
     if (pnewgtval || pnewltval)
     {
-	(*psci->BracketValues)((pointer)pCounter, pnewltval, pnewgtval);
+	(*psci->BracketValues)((void *)pCounter, pnewltval, pnewgtval);
     }
 }
 
@@ -1197,7 +1197,7 @@ SyncComputeBracketValues(pCounter, startOver)
 /* ARGSUSED */
 static int
 FreeAlarm(addr, id)
-    pointer         addr;
+    void            *addr;
     XID             id;
 {
     SyncAlarm      *pAlarm = (SyncAlarm *) addr;
@@ -1224,7 +1224,7 @@ FreeAlarm(addr, id)
 /* ARGSUSED */
 static int
 FreeCounter(env, id)
-    pointer         env;
+    void            *env;
     XID             id;
 {
     SyncCounter     *pCounter = (SyncCounter *) env;
@@ -1276,7 +1276,7 @@ FreeCounter(env, id)
 /* ARGSUSED */
 static int
 FreeAwait(addr, id)
-    pointer         addr;
+    void            *addr;
     XID             id;
 {
     SyncAwaitUnion *pAwaitUnion = (SyncAwaitUnion *) addr;
@@ -1304,7 +1304,7 @@ FreeAwait(addr, id)
 /* loosely based on dix/events.c/OtherClientGone */
 static int
 FreeAlarmClient(value, id)
-    pointer value; /* must conform to DeleteType */
+    void * value; /* must conform to DeleteType */
     XID   id;
 {
     SyncAlarm *pAlarm = (SyncAlarm *)value;
@@ -1778,7 +1778,7 @@ ProcSyncQueryCounter(client)
 
     if (IsSystemCounter(pCounter))
     {
-	(*pCounter->pSysCounterInfo->QueryValue) ((pointer) pCounter,
+	(*pCounter->pSysCounterInfo->QueryValue) ((void *) pCounter,
 						  &pCounter->value);
     }
 
@@ -2406,7 +2406,7 @@ SyncExtensionInit(INITARGS)
 
 
 
-static pointer ServertimeCounter;
+static void * ServertimeCounter;
 static XSyncValue Now;
 static XSyncValue *pnext_time;
 
@@ -2424,9 +2424,9 @@ static XSyncValue *pnext_time;
  */
 /*ARGSUSED*/
 static void ServertimeBlockHandler(env, wt, LastSelectMask)
-pointer env;
+void * env;
 struct timeval **wt;
-pointer LastSelectMask;
+void * LastSelectMask;
 {
     XSyncValue delay;
     unsigned long timeout;
@@ -2455,9 +2455,9 @@ pointer LastSelectMask;
  */
 /*ARGSUSED*/
 static void ServertimeWakeupHandler(env, rc, LastSelectMask)
-pointer env;
+void * env;
 int rc;
-pointer LastSelectMask;
+void * LastSelectMask;
 {
     if (pnext_time)
     {
@@ -2472,7 +2472,7 @@ pointer LastSelectMask;
 
 static void
 ServertimeQueryValue(pCounter, pValue_return)
-    pointer pCounter;
+    void * pCounter;
     CARD64 *pValue_return;
 {
     GetTime();
@@ -2481,7 +2481,7 @@ ServertimeQueryValue(pCounter, pValue_return)
 
 static void
 ServertimeBracketValues(pCounter, pbracket_less, pbracket_greater)
-    pointer pCounter;
+    void * pCounter;
     CARD64 *pbracket_less;
     CARD64 *pbracket_greater;
 {
diff --git a/nx-X11/programs/Xserver/Xext/vidmodeproc.h b/nx-X11/programs/Xserver/Xext/vidmodeproc.h
index 918d1e4df..1f7c6cd04 100644
--- a/nx-X11/programs/Xserver/Xext/vidmodeproc.h
+++ b/nx-X11/programs/Xserver/Xext/vidmodeproc.h
@@ -36,7 +36,7 @@ typedef enum {
 } VidModeSelectMonitor;
 
 typedef union {
-  pointer ptr;
+  void * ptr;
   int i;
   float f;
 } vidMonitorValue;
@@ -44,31 +44,31 @@ typedef union {
 void XFree86VidModeExtensionInit(void);
 
 Bool VidModeAvailable(int scrnIndex);
-Bool VidModeGetCurrentModeline(int scrnIndex, pointer *mode, int *dotClock);
-Bool VidModeGetFirstModeline(int scrnIndex, pointer *mode, int *dotClock);
-Bool VidModeGetNextModeline(int scrnIndex, pointer *mode, int *dotClock);
-Bool VidModeDeleteModeline(int scrnIndex, pointer mode);
+Bool VidModeGetCurrentModeline(int scrnIndex, void **mode, int *dotClock);
+Bool VidModeGetFirstModeline(int scrnIndex, void **mode, int *dotClock);
+Bool VidModeGetNextModeline(int scrnIndex, void **mode, int *dotClock);
+Bool VidModeDeleteModeline(int scrnIndex, void * mode);
 Bool VidModeZoomViewport(int scrnIndex, int zoom);
 Bool VidModeGetViewPort(int scrnIndex, int *x, int *y);
 Bool VidModeSetViewPort(int scrnIndex, int x, int y);
-Bool VidModeSwitchMode(int scrnIndex, pointer mode);
+Bool VidModeSwitchMode(int scrnIndex, void * mode);
 Bool VidModeLockZoom(int scrnIndex, Bool lock);
-Bool VidModeGetMonitor(int scrnIndex, pointer *monitor);
+Bool VidModeGetMonitor(int scrnIndex, void **monitor);
 int VidModeGetNumOfClocks(int scrnIndex, Bool *progClock);
 Bool VidModeGetClocks(int scrnIndex, int *Clocks);
-ModeStatus VidModeCheckModeForMonitor(int scrnIndex, pointer mode);
-ModeStatus VidModeCheckModeForDriver(int scrnIndex, pointer mode);
-void VidModeSetCrtcForMode(int scrnIndex, pointer mode);
-Bool VidModeAddModeline(int scrnIndex, pointer mode);
+ModeStatus VidModeCheckModeForMonitor(int scrnIndex, void * mode);
+ModeStatus VidModeCheckModeForDriver(int scrnIndex, void * mode);
+void VidModeSetCrtcForMode(int scrnIndex, void * mode);
+Bool VidModeAddModeline(int scrnIndex, void * mode);
 int VidModeGetDotClock(int scrnIndex, int Clock);
 int VidModeGetNumOfModes(int scrnIndex);
 Bool VidModeSetGamma(int scrnIndex, float red, float green, float blue);
 Bool VidModeGetGamma(int scrnIndex, float *red, float *green, float *blue);
-pointer VidModeCreateMode(void);
-void VidModeCopyMode(pointer modefrom, pointer modeto);
-int VidModeGetModeValue(pointer mode, int valtyp);
-void VidModeSetModeValue(pointer mode, int valtyp, int val);
-vidMonitorValue VidModeGetMonitorValue(pointer monitor, int valtyp, int indx);
+void * VidModeCreateMode(void);
+void VidModeCopyMode(void * modefrom, void * modeto);
+int VidModeGetModeValue(void * mode, int valtyp);
+void VidModeSetModeValue(void * mode, int valtyp, int val);
+vidMonitorValue VidModeGetMonitorValue(void * monitor, int valtyp, int indx);
 Bool VidModeSetGammaRamp(int, int, CARD16 *, CARD16 *, CARD16 *);
 Bool VidModeGetGammaRamp(int, int, CARD16 *, CARD16 *, CARD16 *);
 int VidModeGetGammaRampSize(int scrnIndex);
diff --git a/nx-X11/programs/Xserver/Xext/xevie.c b/nx-X11/programs/Xserver/Xext/xevie.c
index 3ec6cc4f0..354be121f 100644
--- a/nx-X11/programs/Xserver/Xext/xevie.c
+++ b/nx-X11/programs/Xserver/Xext/xevie.c
@@ -114,15 +114,15 @@ static int              ErrorBase;
 
 static Bool XevieStart(void);
 static void XevieEnd(int clientIndex);
-static void XevieClientStateCallback(CallbackListPtr *pcbl, pointer nulldata,
-                                    pointer calldata);
+static void XevieClientStateCallback(CallbackListPtr *pcbl, void * nulldata,
+                                    void * calldata);
 static void XevieServerGrabStateCallback(CallbackListPtr *pcbl,
-                                         pointer nulldata,
-                                         pointer calldata);
+                                         void * nulldata,
+                                         void * calldata);
 
-static Bool XevieAdd(DeviceIntPtr device, pointer data);
+static Bool XevieAdd(DeviceIntPtr device, void * data);
 static void XevieWrap(DeviceIntPtr device, ProcessInputProc proc);
-static Bool XevieRemove(DeviceIntPtr device, pointer data);
+static Bool XevieRemove(DeviceIntPtr device, void * data);
 static void doSendEvent(xEvent *xE, DeviceIntPtr device);
 static void XeviePointerProcessInputProc(xEvent *xE, DeviceIntPtr dev,
                                          int count);
@@ -570,8 +570,8 @@ XevieEnd(int clientIndex)
 }
 
 static void
-XevieClientStateCallback(CallbackListPtr *pcbl, pointer nulldata,
-                        pointer calldata)
+XevieClientStateCallback(CallbackListPtr *pcbl, void * nulldata,
+                        void * calldata)
 {
     NewClientInfoRec *pci = (NewClientInfoRec *)calldata;
     ClientPtr client = pci->client;
@@ -581,8 +581,8 @@ XevieClientStateCallback(CallbackListPtr *pcbl, pointer nulldata,
 }
 
 static void
-XevieServerGrabStateCallback(CallbackListPtr *pcbl, pointer nulldata,
-                            pointer calldata)
+XevieServerGrabStateCallback(CallbackListPtr *pcbl, void * nulldata,
+                            void * calldata)
 {
     ServerGrabInfoRec *grbinfo = (ServerGrabInfoRec *)calldata;
     if (grbinfo->grabstate == SERVER_GRABBED)
@@ -599,7 +599,7 @@ XevieServerGrabStateCallback(CallbackListPtr *pcbl, pointer nulldata,
     device->unwrapProc = proc;
 
 static void
-xevieUnwrapProc(DeviceIntPtr device, DeviceHandleProc proc, pointer data)
+xevieUnwrapProc(DeviceIntPtr device, DeviceHandleProc proc, void * data)
 {
     xevieDeviceInfoPtr xeviep = XEVIEINFO(device);
     ProcessInputProc tmp = device->public.processInputProc;
@@ -643,7 +643,7 @@ XevieAdd(DeviceIntPtr device, void* data)
 }
 
 static Bool
-XevieRemove(DeviceIntPtr device,pointer data)
+XevieRemove(DeviceIntPtr device,void * data)
 {
     xevieDeviceInfoPtr xeviep = XEVIEINFO(device);
 
@@ -697,7 +697,7 @@ doSendEvent(xEvent *xE, DeviceIntPtr dev)
         dev->key->modifierMap[xE->u.u.detail] = 0;  
 
 	if(dev->key->xkbInfo->repeatKey != 0 && xE->u.u.type != KeyPress)
-            XkbLastRepeatEvent=     (pointer)xE;
+            XkbLastRepeatEvent=     (void *)xE;
         UNWRAP_INPUTPROC(dev,xeviep);
         dev->public.processInputProc(xE,dev,1);
         COND_WRAP_INPUTPROC(dev,xeviep,tmp);
diff --git a/nx-X11/programs/Xserver/Xext/xf86dga2.c b/nx-X11/programs/Xserver/Xext/xf86dga2.c
index a5cab0f11..490554d9a 100644
--- a/nx-X11/programs/Xserver/Xext/xf86dga2.c
+++ b/nx-X11/programs/Xserver/Xext/xf86dga2.c
@@ -59,7 +59,7 @@ static DISPATCH_PROC(ProcXDGACreateColormap);
 
 static void XDGAResetProc(ExtensionEntry *extEntry);
 
-static void DGAClientStateChange (CallbackListPtr*, pointer, pointer);
+static void DGAClientStateChange (CallbackListPtr*, void *, void *);
 
 static ClientPtr DGAClients[MAXSCREENS];
 
@@ -291,8 +291,8 @@ ProcXDGAQueryModes(ClientPtr client)
 static void 
 DGAClientStateChange (
     CallbackListPtr* pcbl,
-    pointer nulldata,
-    pointer calldata
+    void * nulldata,
+    void * calldata
 ){
     NewClientInfoRec* pci = (NewClientInfoRec*) calldata;
     ClientPtr client = NULL;
@@ -370,7 +370,7 @@ ProcXDGASetMode(ClientPtr client)
     DGAClients[stuff->screen] = client;
 
     if(pPix) {
-	if(AddResource(stuff->pid, RT_PIXMAP, (pointer)(pPix))) {
+	if(AddResource(stuff->pid, RT_PIXMAP, (void *)(pPix))) {
 	    pPix->drawable.id = (int)stuff->pid;
 	    rep.flags = DGA_PIXMAP_AVAILABLE;
 	}
diff --git a/nx-X11/programs/Xserver/Xext/xf86misc.c b/nx-X11/programs/Xserver/Xext/xf86misc.c
index a5dc2e212..6de794e1f 100644
--- a/nx-X11/programs/Xserver/Xext/xf86misc.c
+++ b/nx-X11/programs/Xserver/Xext/xf86misc.c
@@ -265,7 +265,7 @@ ProcXF86MiscGetMouseSettings(client)
 {
     xXF86MiscGetMouseSettingsReply rep;
     char *devname;
-    pointer mouse;
+    void * mouse;
     register int n;
 
     DEBUG_P("XF86MiscGetMouseSettings");
@@ -316,7 +316,7 @@ ProcXF86MiscGetKbdSettings(client)
     register ClientPtr client;
 {
     xXF86MiscGetKbdSettingsReply rep;
-    pointer kbd;
+    void * kbd;
     register int n;
 
     DEBUG_P("XF86MiscGetKbdSettings");
@@ -348,7 +348,7 @@ ProcXF86MiscSetMouseSettings(client)
     register ClientPtr client;
 {
     MiscExtReturn ret;
-    pointer mouse;
+    void * mouse;
     char *devname = NULL;
     int major, minor;
     
@@ -369,7 +369,7 @@ ProcXF86MiscSetMouseSettings(client)
 		(int)stuff->resolution, (unsigned long)stuff->flags);
     }
 
-    if ((mouse = MiscExtCreateStruct(MISC_POINTER)) == (pointer) 0)
+    if ((mouse = MiscExtCreateStruct(MISC_POINTER)) == (void *) 0)
 	return BadAlloc;
 
     MiscExtSetMouseValue(mouse, MISC_MSE_PROTO,		stuff->mousetype);
@@ -425,7 +425,7 @@ ProcXF86MiscSetKbdSettings(client)
     register ClientPtr client;
 {
     MiscExtReturn ret;
-    pointer kbd;
+    void * kbd;
     REQUEST(xXF86MiscSetKbdSettingsReq);
 
     DEBUG_P("XF86MiscSetKbdSettings");
@@ -437,7 +437,7 @@ ProcXF86MiscSetKbdSettings(client)
 		(int)stuff->kbdtype, (int)stuff->rate,
 		(int)stuff->delay, stuff->servnumlock);
 
-    if ((kbd = MiscExtCreateStruct(MISC_KEYBOARD)) == (pointer) 0)
+    if ((kbd = MiscExtCreateStruct(MISC_KEYBOARD)) == (void *) 0)
 	return BadAlloc;
 
     MiscExtSetKbdValue(kbd, MISC_KBD_TYPE,		stuff->kbdtype);
diff --git a/nx-X11/programs/Xserver/Xext/xf86miscproc.h b/nx-X11/programs/Xserver/Xext/xf86miscproc.h
index 87a251767..5eefa02a3 100644
--- a/nx-X11/programs/Xserver/Xext/xf86miscproc.h
+++ b/nx-X11/programs/Xserver/Xext/xf86miscproc.h
@@ -50,17 +50,17 @@ typedef enum {
 
 void XFree86MiscExtensionInit(void);
 
-Bool MiscExtGetMouseSettings(pointer *mouse, char **devname);
-int  MiscExtGetMouseValue(pointer mouse, MiscExtMseValType valtype);
-Bool MiscExtSetMouseValue(pointer mouse, MiscExtMseValType valtype, int value);
-Bool MiscExtGetKbdSettings(pointer *kbd);
-int  MiscExtGetKbdValue(pointer kbd, MiscExtKbdValType valtype);
-Bool MiscExtSetKbdValue(pointer kbd, MiscExtKbdValType valtype, int value);
+Bool MiscExtGetMouseSettings(void **mouse, char **devname);
+int  MiscExtGetMouseValue(void * mouse, MiscExtMseValType valtype);
+Bool MiscExtSetMouseValue(void * mouse, MiscExtMseValType valtype, int value);
+Bool MiscExtGetKbdSettings(void **kbd);
+int  MiscExtGetKbdValue(void * kbd, MiscExtKbdValType valtype);
+Bool MiscExtSetKbdValue(void * kbd, MiscExtKbdValType valtype, int value);
 int MiscExtSetGrabKeysState(ClientPtr client, int enable);
-pointer MiscExtCreateStruct(MiscExtStructType mse_or_kbd);
-void    MiscExtDestroyStruct(pointer structure, MiscExtStructType mse_or_kbd);
-MiscExtReturn MiscExtApply(pointer structure, MiscExtStructType mse_or_kbd);
-Bool MiscExtSetMouseDevice(pointer mouse, char* device);
+void * MiscExtCreateStruct(MiscExtStructType mse_or_kbd);
+void    MiscExtDestroyStruct(void * structure, MiscExtStructType mse_or_kbd);
+MiscExtReturn MiscExtApply(void * structure, MiscExtStructType mse_or_kbd);
+Bool MiscExtSetMouseDevice(void * mouse, char* device);
 Bool MiscExtGetFilePaths(const char **configfile, const char **modulepath,
 			 const char **logfile);
 int  MiscExtPassMessage(int scrn, const char *msgtype, const char *msgval,
diff --git a/nx-X11/programs/Xserver/Xext/xf86vmode.c b/nx-X11/programs/Xserver/Xext/xf86vmode.c
index fa49fcd75..979f55c00 100644
--- a/nx-X11/programs/Xserver/Xext/xf86vmode.c
+++ b/nx-X11/programs/Xserver/Xext/xf86vmode.c
@@ -155,7 +155,7 @@ typedef struct _XF86VidModeScreenPrivate {
 static int ScreenPrivateIndex;
 
 #define GetScreenPrivate(s) ((ScreenSaverScreenPrivatePtr)(s)->devPrivates[ScreenPrivateIndex].ptr)
-#define SetScreenPrivate(s,v) ((s)->devPrivates[ScreenPrivateIndex].ptr = (pointer) v);
+#define SetScreenPrivate(s,v) ((s)->devPrivates[ScreenPrivateIndex].ptr = (void *) v);
 #define SetupScreen(s)  ScreenSaverScreenPrivatePtr pPriv = GetScreenPrivate(s)
 
 #define New(t)  (xalloc (sizeof (t)))
@@ -338,7 +338,7 @@ setEventMask (ScreenPtr pScreen, ClientPtr client, unsigned long mask)
 }
 
 static int
-XF86VidModeFreeEvents(pointer value, XID id)
+XF86VidModeFreeEvents(void * value, XID id)
 {
     XF86VidModeEventPtr	pOld = (XF86VidModeEventPtr)value;
     ScreenPtr pScreen = pOld->screen;
@@ -437,7 +437,7 @@ ProcXF86VidModeGetModeLine(ClientPtr client)
     REQUEST(xXF86VidModeGetModeLineReq);
     xXF86VidModeGetModeLineReply rep;
     xXF86OldVidModeGetModeLineReply oldrep;
-    pointer mode;
+    void * mode;
     register int n;
     int dotClock;
     int ver;
@@ -539,7 +539,7 @@ ProcXF86VidModeGetAllModeLines(ClientPtr client)
     xXF86VidModeGetAllModeLinesReply rep;
     xXF86VidModeModeInfo mdinf;
     xXF86OldVidModeModeInfo oldmdinf;
-    pointer mode;
+    void * mode;
     int modecount, dotClock;
     register int n;
     int ver;
@@ -645,7 +645,7 @@ ProcXF86VidModeAddModeLine(ClientPtr client)
     xXF86OldVidModeAddModeLineReq *oldstuff =
 			(xXF86OldVidModeAddModeLineReq *)client->requestBuffer;
     xXF86VidModeAddModeLineReq newstuff;
-    pointer mode;
+    void * mode;
     int len;
     int dotClock;
     int ver;
@@ -805,7 +805,7 @@ ProcXF86VidModeDeleteModeLine(ClientPtr client)
     xXF86OldVidModeDeleteModeLineReq *oldstuff =
 		(xXF86OldVidModeDeleteModeLineReq *)client->requestBuffer;
     xXF86VidModeDeleteModeLineReq newstuff;
-    pointer mode;
+    void * mode;
     int len, dotClock;
     int ver;
 
@@ -922,7 +922,7 @@ ProcXF86VidModeModModeLine(ClientPtr client)
     xXF86OldVidModeModModeLineReq *oldstuff =
 			(xXF86OldVidModeModModeLineReq *)client->requestBuffer;
     xXF86VidModeModModeLineReq newstuff;
-    pointer mode, modetmp;
+    void * mode, modetmp;
     int len, dotClock;
     int ver;
 
@@ -1047,7 +1047,7 @@ ProcXF86VidModeValidateModeLine(ClientPtr client)
 		(xXF86OldVidModeValidateModeLineReq *)client->requestBuffer;
     xXF86VidModeValidateModeLineReq newstuff;
     xXF86VidModeValidateModeLineReply rep;
-    pointer mode, modetmp = NULL;
+    void * mode, modetmp = NULL;
     int len, status, dotClock;
     int ver;
 
@@ -1181,7 +1181,7 @@ ProcXF86VidModeSwitchToMode(ClientPtr client)
     xXF86OldVidModeSwitchToModeReq *oldstuff =
 		(xXF86OldVidModeSwitchToModeReq *)client->requestBuffer;
     xXF86VidModeSwitchToModeReq newstuff;
-    pointer mode;
+    void * mode;
     int len, dotClock;
     int ver;
 
@@ -1297,7 +1297,7 @@ ProcXF86VidModeGetMonitor(ClientPtr client)
     register int n;
     CARD32 *hsyncdata, *vsyncdata;
     int i, nHsync, nVrefresh;
-    pointer monitor;
+    void * monitor;
     
     DEBUG_P("XF86VidModeGetMonitor");
 
diff --git a/nx-X11/programs/Xserver/Xext/xres.c b/nx-X11/programs/Xserver/Xext/xres.c
index d13d3368b..dc4018dd7 100644
--- a/nx-X11/programs/Xserver/Xext/xres.c
+++ b/nx-X11/programs/Xserver/Xext/xres.c
@@ -106,7 +106,7 @@ ProcXResQueryClients (ClientPtr client)
 
 
 static void
-ResFindAllRes (pointer value, XID id, RESTYPE type, pointer cdata)
+ResFindAllRes (void * value, XID id, RESTYPE type, void * cdata)
 {
     int *counts = (int *)cdata;
 
@@ -186,7 +186,7 @@ ProcXResQueryClientResources (ClientPtr client)
 }
 
 static void 
-ResFindPixmaps (pointer value, XID id, pointer cdata)
+ResFindPixmaps (void * value, XID id, void * cdata)
 {
    unsigned long *bytes = (unsigned long *)cdata;
    PixmapPtr pix = (PixmapPtr)value;
@@ -216,7 +216,7 @@ ProcXResQueryClientPixmapBytes (ClientPtr client)
     bytes = 0;
 
     FindClientResourcesByType(clients[clientID], RT_PIXMAP, ResFindPixmaps, 
-                              (pointer)(&bytes));
+                              (void *)(&bytes));
 
     rep.type = X_Reply;
     rep.sequenceNumber = client->sequence;
diff --git a/nx-X11/programs/Xserver/Xext/xtest1dd.c b/nx-X11/programs/Xserver/Xext/xtest1dd.c
index 81d283c36..c78cceed0 100644
--- a/nx-X11/programs/Xserver/Xext/xtest1dd.c
+++ b/nx-X11/programs/Xserver/Xext/xtest1dd.c
@@ -1613,5 +1613,5 @@ ClientPtr	client;
 	rep.size_return = ACTION_ARRAY_SIZE;
 	WriteReplyToClient(client,
 			   sizeof(xTestQueryInputSizeReply),
-			   (pointer) &rep);		
+			   (void *) &rep);
 }		
diff --git a/nx-X11/programs/Xserver/Xext/xtest1di.c b/nx-X11/programs/Xserver/Xext/xtest1di.c
index d95b30612..985193a89 100644
--- a/nx-X11/programs/Xserver/Xext/xtest1di.c
+++ b/nx-X11/programs/Xserver/Xext/xtest1di.c
@@ -152,7 +152,7 @@ static void	SEventXTestDispatch(
 	);
 
 static int	XTestCurrentClientGone(
-	pointer			/* value */,
+	void *			/* value */,
 	XID			/* id */
 	);
 
@@ -752,7 +752,7 @@ XTestResetProc(unused)
 /*ARGSUSED*/
 static int
 XTestCurrentClientGone(value, id)
-	pointer	value;
+	void *	value;
 	XID	id;
 {
 	/*
diff --git a/nx-X11/programs/Xserver/Xext/xvmain.c b/nx-X11/programs/Xserver/Xext/xvmain.c
index 8934f77f2..bbbb34dcf 100644
--- a/nx-X11/programs/Xserver/Xext/xvmain.c
+++ b/nx-X11/programs/Xserver/Xext/xvmain.c
@@ -139,12 +139,12 @@ static Bool XvCloseScreen(int, ScreenPtr);
 static Bool XvDestroyPixmap(PixmapPtr);
 static Bool XvDestroyWindow(WindowPtr);
 static void XvResetProc(ExtensionEntry*);
-static int XvdiDestroyGrab(pointer, XID);
-static int XvdiDestroyEncoding(pointer, XID);
-static int XvdiDestroyVideoNotify(pointer, XID);
-static int XvdiDestroyPortNotify(pointer, XID);
-static int XvdiDestroyVideoNotifyList(pointer, XID);
-static int XvdiDestroyPort(pointer, XID);
+static int XvdiDestroyGrab(void *, XID);
+static int XvdiDestroyEncoding(void *, XID);
+static int XvdiDestroyVideoNotify(void *, XID);
+static int XvdiDestroyPortNotify(void *, XID);
+static int XvdiDestroyVideoNotifyList(void *, XID);
+static int XvdiDestroyPort(void *, XID);
 static int XvdiSendVideoNotify(XvPortPtr, DrawablePtr, int);
 
 
@@ -295,7 +295,7 @@ XvScreenInit(ScreenPtr pScreen)
       return BadAlloc;
     }
 
-  pScreen->devPrivates[XvScreenIndex].ptr = (pointer)pxvs;
+  pScreen->devPrivates[XvScreenIndex].ptr = (void *)pxvs;
 
   
   pxvs->DestroyPixmap = pScreen->DestroyPixmap;
@@ -327,7 +327,7 @@ XvCloseScreen(
 
   xfree(pxvs);
 
-  pScreen->devPrivates[XvScreenIndex].ptr = (pointer)NULL;
+  pScreen->devPrivates[XvScreenIndex].ptr = (void *)NULL;
 
   return (*pScreen->CloseScreen)(ii, pScreen);
 
@@ -479,20 +479,20 @@ XvdiVideoStopped(XvPortPtr pPort, int reason)
 }
 
 static int 
-XvdiDestroyPort(pointer pPort, XID id)
+XvdiDestroyPort(void * pPort, XID id)
 {
   return (* ((XvPortPtr)pPort)->pAdaptor->ddFreePort)(pPort);
 }
 
 static int
-XvdiDestroyGrab(pointer pGrab, XID id)
+XvdiDestroyGrab(void * pGrab, XID id)
 {
   ((XvGrabPtr)pGrab)->client = (ClientPtr)NULL;
   return Success;
 }
 
 static int
-XvdiDestroyVideoNotify(pointer pn, XID id)
+XvdiDestroyVideoNotify(void * pn, XID id)
 {
   /* JUST CLEAR OUT THE client POINTER FIELD */
 
@@ -501,7 +501,7 @@ XvdiDestroyVideoNotify(pointer pn, XID id)
 }
 
 static int
-XvdiDestroyPortNotify(pointer pn, XID id)
+XvdiDestroyPortNotify(void * pn, XID id)
 {
   /* JUST CLEAR OUT THE client POINTER FIELD */
 
@@ -510,7 +510,7 @@ XvdiDestroyPortNotify(pointer pn, XID id)
 }
 
 static int
-XvdiDestroyVideoNotifyList(pointer pn, XID id)
+XvdiDestroyVideoNotifyList(void * pn, XID id)
 {
   XvVideoNotifyPtr npn,cpn;
 
@@ -529,7 +529,7 @@ XvdiDestroyVideoNotifyList(pointer pn, XID id)
 }
 
 static int
-XvdiDestroyEncoding(pointer value, XID id)
+XvdiDestroyEncoding(void * value, XID id)
 {
   return Success;
 }
diff --git a/nx-X11/programs/Xserver/Xext/xvmc.c b/nx-X11/programs/Xserver/Xext/xvmc.c
index 37fb153ab..30de35a2b 100644
--- a/nx-X11/programs/Xserver/Xext/xvmc.c
+++ b/nx-X11/programs/Xserver/Xext/xvmc.c
@@ -66,7 +66,7 @@ typedef struct {
 
 
 static int
-XvMCDestroyContextRes(pointer data, XID id)
+XvMCDestroyContextRes(void * data, XID id)
 {
    XvMCContextPtr pContext = (XvMCContextPtr)data;
    
@@ -82,7 +82,7 @@ XvMCDestroyContextRes(pointer data, XID id)
 }
 
 static int
-XvMCDestroySurfaceRes(pointer data, XID id)
+XvMCDestroySurfaceRes(void * data, XID id)
 {
    XvMCSurfacePtr pSurface = (XvMCSurfacePtr)data;
    XvMCContextPtr pContext = pSurface->context;
@@ -91,14 +91,14 @@ XvMCDestroySurfaceRes(pointer data, XID id)
    (*pScreenPriv->adaptors[pContext->adapt_num].DestroySurface)(pSurface); 
    xfree(pSurface);
 
-   XvMCDestroyContextRes((pointer)pContext, pContext->context_id);
+   XvMCDestroyContextRes((void *)pContext, pContext->context_id);
 
    return Success;
 }
 
 
 static int
-XvMCDestroySubpictureRes(pointer data, XID id)
+XvMCDestroySubpictureRes(void * data, XID id)
 {
    XvMCSubpicturePtr pSubpict = (XvMCSubpicturePtr)data;
    XvMCContextPtr pContext = pSubpict->context;
@@ -107,7 +107,7 @@ XvMCDestroySubpictureRes(pointer data, XID id)
    (*pScreenPriv->adaptors[pContext->adapt_num].DestroySubpicture)(pSubpict); 
    xfree(pSubpict);
 
-   XvMCDestroyContextRes((pointer)pContext, pContext->context_id);
+   XvMCDestroyContextRes((void *)pContext, pContext->context_id);
 
    return Success;
 }
@@ -729,7 +729,7 @@ XvMCScreenInit(ScreenPtr pScreen, int num, XvMCAdaptorPtr pAdapt)
    if(!(pScreenPriv = (XvMCScreenPtr)xalloc(sizeof(XvMCScreenRec))))
 	return BadAlloc;
 
-   pScreen->devPrivates[XvMCScreenIndex].ptr = (pointer)pScreenPriv;
+   pScreen->devPrivates[XvMCScreenIndex].ptr = (void *)pScreenPriv;
 
    pScreenPriv->CloseScreen = pScreen->CloseScreen;
    pScreen->CloseScreen = XvMCCloseScreen;
diff --git a/nx-X11/programs/Xserver/Xext/xvmcext.h b/nx-X11/programs/Xserver/Xext/xvmcext.h
index c7eba30ad..7cb8af24d 100644
--- a/nx-X11/programs/Xserver/Xext/xvmcext.h
+++ b/nx-X11/programs/Xserver/Xext/xvmcext.h
@@ -32,15 +32,15 @@ typedef struct {
   unsigned short height;
   CARD32 flags;
   int refcnt;
-  pointer port_priv;
-  pointer driver_priv;
+  void * port_priv;
+  void * driver_priv;
 } XvMCContextRec, *XvMCContextPtr;
 
 typedef struct {
   XID surface_id;
   int surface_type_id;
   XvMCContextPtr context;
-  pointer driver_priv;
+  void * driver_priv;
 } XvMCSurfaceRec, *XvMCSurfacePtr;
 
 
@@ -53,7 +53,7 @@ typedef struct {
   int entry_bytes;
   char component_order[4];
   XvMCContextPtr context;
-  pointer driver_priv;
+  void * driver_priv;
 } XvMCSubpictureRec, *XvMCSubpicturePtr;
 
 typedef int (*XvMCCreateContextProcPtr) (
diff --git a/nx-X11/programs/Xserver/Xi/devbell.c b/nx-X11/programs/Xserver/Xi/devbell.c
index bdc941c1c..190e32086 100644
--- a/nx-X11/programs/Xserver/Xi/devbell.c
+++ b/nx-X11/programs/Xserver/Xi/devbell.c
@@ -104,7 +104,7 @@ ProcXDeviceBell (client)
     int base;
     int newpercent;
     CARD8 class;
-    pointer ctrl;
+    void * ctrl;
     BellProcPtr proc;
 
     REQUEST(xDeviceBellReq);
@@ -137,7 +137,7 @@ ProcXDeviceBell (client)
 	    }
 	base = k->ctrl.bell;
 	proc = k->BellProc;
-	ctrl = (pointer) &(k->ctrl);
+	ctrl = (void *) &(k->ctrl);
 	class = KbdFeedbackClass;
 	}
     else if (stuff->feedbackclass == BellFeedbackClass)
@@ -153,7 +153,7 @@ ProcXDeviceBell (client)
 	    }
 	base = b->ctrl.percent;
 	proc = b->BellProc;
-	ctrl = (pointer) &(b->ctrl);
+	ctrl = (void *) &(b->ctrl);
 	class = BellFeedbackClass;
 	}
     else
diff --git a/nx-X11/programs/Xserver/Xi/exevents.c b/nx-X11/programs/Xserver/Xi/exevents.c
index 99fbb129a..f0c9aea3d 100644
--- a/nx-X11/programs/Xserver/Xi/exevents.c
+++ b/nx-X11/programs/Xserver/Xi/exevents.c
@@ -143,7 +143,7 @@ ProcessOtherEvent (xE, other, count)
 	DeviceEventInfoRec eventinfo;
 	eventinfo.events = (xEventPtr) xE;
 	eventinfo.count = count;
-	CallCallbacks(&DeviceEventCallback, (pointer)&eventinfo);
+	CallCallbacks(&DeviceEventCallback, (void *)&eventinfo);
     }
     for (i=1; i<count; i++)
 	if ((++xV)->type == DeviceValuator)
@@ -751,7 +751,7 @@ AddExtensionClient (pWin, client, mask, mskidx)
     others->resource = FakeClientID(client->index);
     others->next = pWin->optional->inputMasks->inputClients;
     pWin->optional->inputMasks->inputClients = others;
-    if (!AddResource(others->resource, RT_INPUTCLIENT, (pointer)pWin))
+    if (!AddResource(others->resource, RT_INPUTCLIENT, (void *)pWin))
 	return BadAlloc;
     return Success;
     }
@@ -846,7 +846,7 @@ InputClientGone(pWin, id)
 		    {
 		    other->resource = FakeClientID(0);
 		    if (!AddResource(other->resource, RT_INPUTCLIENT, 
-			(pointer)pWin))
+			(void *)pWin))
 			return BadAlloc;
 		    }
 		}
diff --git a/nx-X11/programs/Xserver/Xi/stubs.c b/nx-X11/programs/Xserver/Xi/stubs.c
index 7ad6d903e..2d9aad08b 100644
--- a/nx-X11/programs/Xserver/Xi/stubs.c
+++ b/nx-X11/programs/Xserver/Xi/stubs.c
@@ -209,7 +209,7 @@ AddOtherInputDevices ()
 
     DeviceIntPtr dev;
     DeviceProc deviceProc;
-    pointer private;
+    void * private;
 
     dev = (DeviceIntPtr) AddInputDevice(deviceProc, TRUE);
     dev->public.devicePrivate = private;
diff --git a/nx-X11/programs/Xserver/composite/compext.c b/nx-X11/programs/Xserver/composite/compext.c
index 657ed9bdc..d182da1fd 100644
--- a/nx-X11/programs/Xserver/composite/compext.c
+++ b/nx-X11/programs/Xserver/composite/compext.c
@@ -42,8 +42,8 @@ typedef struct _CompositeClient {
 
 static void
 CompositeClientCallback (CallbackListPtr	*list,
-		      pointer		closure,
-		      pointer		data)
+			 void		*closure,
+			 void		*data)
 {
     NewClientInfoRec	*clientinfo = (NewClientInfoRec *) data;
     ClientPtr		pClient = clientinfo->client;
@@ -59,7 +59,7 @@ CompositeResetProc (ExtensionEntry *extEntry)
 }
     
 static int
-FreeCompositeClientWindow (pointer value, XID ccwid)
+FreeCompositeClientWindow (void * value, XID ccwid)
 {
     WindowPtr	pWin = value;
 
@@ -68,7 +68,7 @@ FreeCompositeClientWindow (pointer value, XID ccwid)
 }
 
 static int
-FreeCompositeClientSubwindows (pointer value, XID ccwid)
+FreeCompositeClientSubwindows (void * value, XID ccwid)
 {
     WindowPtr	pWin = value;
 
@@ -203,7 +203,7 @@ ProcCompositeCreateRegionFromBorderClip (ClientPtr client)
 	return BadAlloc;
     REGION_TRANSLATE (pScreen, pRegion, -pWin->drawable.x, -pWin->drawable.y);
     
-    if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
+    if (!AddResource (stuff->region, RegionResType, (void *) pRegion))
 	return BadAlloc;
 
     return(client->noClientException);
@@ -237,7 +237,7 @@ ProcCompositeNameWindowPixmap (ClientPtr client)
 
     ++pPixmap->refcnt;
     
-    if (!AddResource (stuff->pixmap, RT_PIXMAP, (pointer) pPixmap))
+    if (!AddResource (stuff->pixmap, RT_PIXMAP, (void *) pPixmap))
 	return BadAlloc;
 
     return(client->noClientException);
diff --git a/nx-X11/programs/Xserver/composite/compinit.c b/nx-X11/programs/Xserver/composite/compinit.c
index d76885c43..13a6d6c01 100644
--- a/nx-X11/programs/Xserver/composite/compinit.c
+++ b/nx-X11/programs/Xserver/composite/compinit.c
@@ -93,9 +93,9 @@ compScreenUpdate (ScreenPtr pScreen)
 
 static void
 compBlockHandler (int	    i,
-		  pointer   blockData,
-		  pointer   pTimeout,
-		  pointer   pReadmask)
+		  void      *blockData,
+		  void      *pTimeout,
+		  void      *pReadmask)
 {
     ScreenPtr	    pScreen = screenInfo.screens[i];
     CompScreenPtr   cs = GetCompScreen (pScreen);
@@ -385,6 +385,6 @@ compScreenInit (ScreenPtr pScreen)
     cs->CloseScreen = pScreen->CloseScreen;
     pScreen->CloseScreen = compCloseScreen;
 
-    pScreen->devPrivates[CompScreenPrivateIndex].ptr = (pointer) cs;
+    pScreen->devPrivates[CompScreenPrivateIndex].ptr = (void *) cs;
     return TRUE;
 }
diff --git a/nx-X11/programs/Xserver/composite/compwindow.c b/nx-X11/programs/Xserver/composite/compwindow.c
index 2093095f0..2bb581329 100644
--- a/nx-X11/programs/Xserver/composite/compwindow.c
+++ b/nx-X11/programs/Xserver/composite/compwindow.c
@@ -30,7 +30,7 @@
 
 #ifdef COMPOSITE_DEBUG
 static int
-compCheckWindow (WindowPtr pWin, pointer data)
+compCheckWindow (WindowPtr pWin, void * data)
 {
     ScreenPtr	pScreen = pWin->drawable.pScreen;
     PixmapPtr	pWinPixmap = (*pScreen->GetWindowPixmap) (pWin);
@@ -71,7 +71,7 @@ typedef struct _compPixmapVisit {
 } CompPixmapVisitRec, *CompPixmapVisitPtr;
 
 static Bool
-compRepaintBorder (ClientPtr pClient, pointer closure)
+compRepaintBorder (ClientPtr pClient, void * closure)
 {
     WindowPtr	pWindow = LookupWindow ((XID) closure, pClient);
 
@@ -88,7 +88,7 @@ compRepaintBorder (ClientPtr pClient, pointer closure)
 }
 
 static int
-compSetPixmapVisitWindow (WindowPtr pWindow, pointer data)
+compSetPixmapVisitWindow (WindowPtr pWindow, void * data)
 {
     CompPixmapVisitPtr	pVisit = (CompPixmapVisitPtr) data;
     ScreenPtr		pScreen = pWindow->drawable.pScreen;
@@ -105,7 +105,7 @@ compSetPixmapVisitWindow (WindowPtr pWindow, pointer data)
     SetBorderSize (pWindow);
     if (HasBorder (pWindow))
 	QueueWorkProc (compRepaintBorder, serverClient, 
-		       (pointer) pWindow->drawable.id);
+		       (void *) pWindow->drawable.id);
     return WT_WALKCHILDREN;
 }
 
@@ -116,7 +116,7 @@ compSetPixmap (WindowPtr pWindow, PixmapPtr pPixmap)
 
     visitRec.pWindow = pWindow;
     visitRec.pPixmap = pPixmap;
-    TraverseTree (pWindow, compSetPixmapVisitWindow, (pointer) &visitRec);
+    TraverseTree (pWindow, compSetPixmapVisitWindow, (void *) &visitRec);
     compCheckTree (pWindow->drawable.pScreen);
 }
 
diff --git a/nx-X11/programs/Xserver/damageext/damageext.c b/nx-X11/programs/Xserver/damageext/damageext.c
index 24809347a..33cbb5f7b 100755
--- a/nx-X11/programs/Xserver/damageext/damageext.c
+++ b/nx-X11/programs/Xserver/damageext/damageext.c
@@ -216,7 +216,7 @@ ProcDamageCreate (ClientPtr client)
 	xfree (pDamageExt);
 	return BadAlloc;
     }
-    if (!AddResource (stuff->damage, DamageExtType, (pointer) pDamageExt))
+    if (!AddResource (stuff->damage, DamageExtType, (void *) pDamageExt))
 	return BadAlloc;
 
     DamageRegister (pDamageExt->pDrawable, pDamageExt->pDamage);
@@ -376,8 +376,8 @@ SProcDamageDispatch (ClientPtr client)
 
 static void
 DamageClientCallback (CallbackListPtr	*list,
-		      pointer		closure,
-		      pointer		data)
+		      void *		closure,
+		      void *		data)
 {
     NewClientInfoRec	*clientinfo = (NewClientInfoRec *) data;
     ClientPtr		pClient = clientinfo->client;
@@ -396,7 +396,7 @@ DamageResetProc (ExtensionEntry *extEntry)
 }
 
 static int
-FreeDamageExt (pointer value, XID did)
+FreeDamageExt (void * value, XID did)
 {
     DamageExtPtr    pDamageExt = (DamageExtPtr) value;
 
@@ -416,7 +416,7 @@ FreeDamageExt (pointer value, XID did)
 }
 
 static int
-FreeDamageExtWin (pointer value, XID wid)
+FreeDamageExtWin (void * value, XID wid)
 {
     DamageExtPtr    pDamageExt = (DamageExtPtr) value;
 
diff --git a/nx-X11/programs/Xserver/dbe/dbe.c b/nx-X11/programs/Xserver/dbe/dbe.c
index 5a1e9b00b..ad5294a4c 100644
--- a/nx-X11/programs/Xserver/dbe/dbe.c
+++ b/nx-X11/programs/Xserver/dbe/dbe.c
@@ -188,11 +188,11 @@ DbeAllocWinPriv(pScreen)
         {
             if ((size = *sizes))
             {
-                ppriv->ptr = (pointer)ptr;
+                ppriv->ptr = (void *)ptr;
                 ptr += size;
             }
             else
-                ppriv->ptr = (pointer)NULL;
+                ppriv->ptr = (void *)NULL;
         }
     }
 
@@ -497,7 +497,7 @@ ProcDbeAllocateBackBufferName(client)
 
         /* Make the window priv a DBE window priv resource. */
         if (!AddResource(stuff->buffer, dbeWindowPrivResType,
-            (pointer)pDbeWindowPriv))
+            (void *)pDbeWindowPriv))
         {
             xfree(pDbeWindowPriv);
             return(BadAlloc);
@@ -524,7 +524,7 @@ ProcDbeAllocateBackBufferName(client)
 
 
         /* Actually connect the window priv to the window. */
-        pWin->devPrivates[dbeWindowPrivIndex].ptr = (pointer)pDbeWindowPriv;
+        pWin->devPrivates[dbeWindowPrivIndex].ptr = (void *)pDbeWindowPriv;
 
     } /* if -- There is no buffer associated with the window. */
 
@@ -592,7 +592,7 @@ ProcDbeAllocateBackBufferName(client)
 
         /* Associate the new ID with an existing window priv. */
         if (!AddResource(stuff->buffer, dbeWindowPrivResType,
-                         (pointer)pDbeWindowPriv))
+                         (void *)pDbeWindowPriv))
         {
             pDbeWindowPriv->IDs[i] = DBE_FREE_ID_ELEMENT;
             return(BadAlloc);
@@ -1490,7 +1490,7 @@ DbeSetupBackgroundPainter(pWin, pGC)
     WindowPtr	pWin;
     GCPtr	pGC;
 {
-    pointer	gcvalues[4];
+    void	*gcvalues[4];
     int		ts_x_origin, ts_y_origin;
     PixUnion	background;
     int		backgroundState;
@@ -1516,16 +1516,16 @@ DbeSetupBackgroundPainter(pWin, pGC)
     switch (backgroundState)
     {
         case BackgroundPixel:
-            gcvalues[0] = (pointer)background.pixel;
-            gcvalues[1] = (pointer)FillSolid;
+            gcvalues[0] = (void *)background.pixel;
+            gcvalues[1] = (void *)FillSolid;
             gcmask = GCForeground|GCFillStyle;
             break;
 
         case BackgroundPixmap:
-            gcvalues[0] = (pointer)FillTiled;
-            gcvalues[1] = (pointer)background.pixmap;
-            gcvalues[2] = (pointer)(long)ts_x_origin;
-            gcvalues[3] = (pointer)(long)ts_y_origin;
+            gcvalues[0] = (void *)FillTiled;
+            gcvalues[1] = (void *)background.pixmap;
+            gcvalues[2] = (void *)(long)ts_x_origin;
+            gcvalues[3] = (void *)(long)ts_y_origin;
             gcmask = GCFillStyle|GCTile|GCTileStipXOrigin|GCTileStipYOrigin;
             break;
 
@@ -1562,7 +1562,7 @@ DbeSetupBackgroundPainter(pWin, pGC)
  *****************************************************************************/
 static int
 DbeDrawableDelete(pDrawable, id)
-    pointer	pDrawable;
+    void	*pDrawable;
     XID		id;
 {
     return(Success);
@@ -1583,7 +1583,7 @@ DbeDrawableDelete(pDrawable, id)
  *****************************************************************************/
 static int
 DbeWindowPrivDelete(pDbeWinPriv, id)
-    pointer	pDbeWinPriv;
+    void	*pDbeWinPriv;
     XID		id;
 {
     DbeScreenPrivPtr	pDbeScreenPriv;
@@ -1668,7 +1668,7 @@ DbeWindowPrivDelete(pDbeWinPriv, id)
     {
         /* Reset the DBE window priv pointer. */
         pDbeWindowPriv->pWindow->devPrivates[dbeWindowPrivIndex].ptr =
-            (pointer)NULL;
+            (void *)NULL;
 
         /* We are done with the window priv. */
         xfree(pDbeWindowPriv);
@@ -1888,7 +1888,7 @@ DbeExtensionInit()
 	    return;
 	}
 
-	pScreen->devPrivates[dbeScreenPrivIndex].ptr = (pointer)pDbeScreenPriv;
+	pScreen->devPrivates[dbeScreenPrivIndex].ptr = (void *)pDbeScreenPriv;
 
         /* Store the DBE priv priv size info for later use when allocating
          * priv privs at the driver level.
diff --git a/nx-X11/programs/Xserver/dbe/dbemodule.c b/nx-X11/programs/Xserver/dbe/dbemodule.c
index 62fbcfd21..9a05f4071 100644
--- a/nx-X11/programs/Xserver/dbe/dbemodule.c
+++ b/nx-X11/programs/Xserver/dbe/dbemodule.c
@@ -38,11 +38,11 @@ static XF86ModuleVersionInfo VersRec =
  */
 XF86ModuleData dbeModuleData = { &VersRec, dbeSetup, NULL };
 
-static pointer
-dbeSetup(pointer module, pointer opts, int *errmaj, int *errmin)
+static void *
+dbeSetup(void * module, void * opts, int *errmaj, int *errmin)
 {
     LoadExtension(&dbeExt, FALSE);
 
     /* Need a non-NULL return value to indicate success */
-    return (pointer)1;
+    return (void *)1;
 }
diff --git a/nx-X11/programs/Xserver/dbe/midbe.c b/nx-X11/programs/Xserver/dbe/midbe.c
index 235693bb2..042f95953 100644
--- a/nx-X11/programs/Xserver/dbe/midbe.c
+++ b/nx-X11/programs/Xserver/dbe/midbe.c
@@ -214,7 +214,7 @@ miDbeAllocBackBufferName(pWin, bufId, swapAction)
 
         /* Make the back pixmap a DBE drawable resource. */
         if (!AddResource(bufId, dbeDrawableResType,
-            (pointer)pDbeWindowPrivPriv->pBackBuffer))
+            (void *)pDbeWindowPrivPriv->pBackBuffer))
         {
             /* free the buffer and the drawable resource */
             FreeResource(bufId, RT_NONE);
@@ -224,7 +224,7 @@ miDbeAllocBackBufferName(pWin, bufId, swapAction)
 
         /* Attach the priv priv to the priv. */
 	pDbeWindowPriv->devPrivates[miDbeWindowPrivPrivIndex].ptr =
-            (pointer)pDbeWindowPrivPriv;
+            (void *)pDbeWindowPrivPriv;
 
 
         /* Clear the back buffer. */
@@ -252,7 +252,7 @@ miDbeAllocBackBufferName(pWin, bufId, swapAction)
         /* Associate the new ID with an existing pixmap. */
         pDbeWindowPrivPriv = MI_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv);
         if (!AddResource(bufId, dbeDrawableResType,
-                         (pointer)pDbeWindowPrivPriv->pBackBuffer))
+                         (void *)pDbeWindowPrivPriv->pBackBuffer))
         {
             return(BadAlloc);
         }
@@ -286,7 +286,7 @@ miDbeAliasBuffers(pDbeWindowPriv)
     for (i = 0; i < pDbeWindowPriv->nBufferIDs; i++)
     {
         ChangeResourceValue(pDbeWindowPriv->IDs[i], dbeDrawableResType,
-                            (pointer)pDbeWindowPrivPriv->pBackBuffer);
+                            (void *)pDbeWindowPrivPriv->pBackBuffer);
     }
 
 } /* miDbeAliasBuffers() */
diff --git a/nx-X11/programs/Xserver/dix/colormap.c b/nx-X11/programs/Xserver/dix/colormap.c
index 210bc2731..32d9bae89 100644
--- a/nx-X11/programs/Xserver/dix/colormap.c
+++ b/nx-X11/programs/Xserver/dix/colormap.c
@@ -382,7 +382,7 @@ CreateColormap (Colormap mid, ScreenPtr pScreen, VisualPtr pVisual,
 	    pmap->numPixelsBlue[client] = size;
 	}
     }
-    if (!AddResource(mid, RT_COLORMAP, (pointer)pmap))
+    if (!AddResource(mid, RT_COLORMAP, (void *)pmap))
 	return (BadAlloc);
     /* If the device wants a chance to initialize the colormap in any way,
      * this is it.  In specific, if this is a Static colormap, this is the
@@ -422,7 +422,7 @@ CreateColormap (Colormap mid, ScreenPtr pScreen, VisualPtr pVisual,
  * \param value  must conform to DeleteType
  */
 int
-FreeColormap (pointer value, XID mid)
+FreeColormap (void * value, XID mid)
 {
     int		i;
     register EntryPtr pent;
@@ -431,7 +431,7 @@ FreeColormap (pointer value, XID mid)
     if(CLIENT_ID(mid) != SERVER_ID)
     {
         (*pmap->pScreen->UninstallColormap) (pmap);
-        WalkTree(pmap->pScreen, (VisitWindowProcPtr)TellNoMap, (pointer) &mid);
+        WalkTree(pmap->pScreen, (VisitWindowProcPtr)TellNoMap, (void *) &mid);
     }
 
     /* This is the device's chance to undo anything it needs to, especially
@@ -506,7 +506,7 @@ TellNoMap (WindowPtr pwin, Colormap *pmid)
 
 /* Tell window that pmid got uninstalled */
 int
-TellLostMap (WindowPtr pwin, pointer value)
+TellLostMap (WindowPtr pwin, void * value)
 {
     Colormap 	*pmid = (Colormap *)value;
     xEvent 	xE;
@@ -531,7 +531,7 @@ TellLostMap (WindowPtr pwin, pointer value)
 
 /* Tell window that pmid got installed */
 int
-TellGainedMap (WindowPtr pwin, pointer value)
+TellGainedMap (WindowPtr pwin, void * value)
 {
     Colormap 	*pmid = (Colormap *)value;
     xEvent 	xE;
@@ -974,7 +974,7 @@ AllocColor (ColormapPtr pmap,
 	}
 	pcr->mid = pmap->mid;
 	pcr->client = client;
-	if (!AddResource(FakeClientID(client), RT_CMAPENTRY, (pointer)pcr))
+	if (!AddResource(FakeClientID(client), RT_CMAPENTRY, (void *)pcr))
 	    return (BadAlloc);
     }
     return (Success);
@@ -1599,7 +1599,7 @@ FreePixels(register ColormapPtr pmap, register int client)
  *  \unused fakeid
  */
 int
-FreeClientPixels (pointer value, XID fakeid)
+FreeClientPixels (void * value, XID fakeid)
 {
     ColormapPtr pmap;
     colorResource *pcr = (colorResource *)value;
@@ -1674,7 +1674,7 @@ AllocColorCells (int client, ColormapPtr pmap, int colors, int planes,
     {
 	pcr->mid = pmap->mid;
 	pcr->client = client;
-	if (!AddResource(FakeClientID(client), RT_CMAPENTRY, (pointer)pcr))
+	if (!AddResource(FakeClientID(client), RT_CMAPENTRY, (void *)pcr))
 	    ok = BadAlloc;
     } else if (pcr)
 	xfree(pcr);
@@ -1765,7 +1765,7 @@ AllocColorPlanes (int client, ColormapPtr pmap, int colors,
     {
 	pcr->mid = pmap->mid;
 	pcr->client = client;
-	if (!AddResource(FakeClientID(client), RT_CMAPENTRY, (pointer)pcr))
+	if (!AddResource(FakeClientID(client), RT_CMAPENTRY, (void *)pcr))
 	    ok = BadAlloc;
     } else if (pcr)
 	xfree(pcr);
diff --git a/nx-X11/programs/Xserver/dix/cursor.c b/nx-X11/programs/Xserver/dix/cursor.c
index f4d6c6419..187dd62c5 100644
--- a/nx-X11/programs/Xserver/dix/cursor.c
+++ b/nx-X11/programs/Xserver/dix/cursor.c
@@ -110,7 +110,7 @@ FreeCursorBits(CursorBitsPtr bits)
  *  \param value must conform to DeleteType
  */
 int
-FreeCursor(pointer value, XID cid)
+FreeCursor(void * value, XID cid)
 {
     int		nscr;
     CursorPtr 	pCurs = (CursorPtr)value;
@@ -452,7 +452,7 @@ CreateRootCursor(char *pfilename, unsigned glyph)
 			 0, 0, 0, ~0, ~0, ~0, &curs, serverClient) != Success)
 	return NullCursor;
 
-    if (!AddResource(FakeClientID(0), RT_CURSOR, (pointer)curs))
+    if (!AddResource(FakeClientID(0), RT_CURSOR, (void *)curs))
 	return NullCursor;
 
     return curs;
diff --git a/nx-X11/programs/Xserver/dix/devices.c b/nx-X11/programs/Xserver/dix/devices.c
index e29154cfc..917a3849a 100644
--- a/nx-X11/programs/Xserver/dix/devices.c
+++ b/nx-X11/programs/Xserver/dix/devices.c
@@ -1449,7 +1449,7 @@ ProcBell(ClientPtr client)
 	else
 #endif
     (*keybd->kbdfeed->BellProc)(newpercent, keybd,
-				(pointer) &keybd->kbdfeed->ctrl, 0);
+				(void *) &keybd->kbdfeed->ctrl, 0);
     return Success;
 } 
 
diff --git a/nx-X11/programs/Xserver/dix/dispatch.c b/nx-X11/programs/Xserver/dix/dispatch.c
index 3fd971101..71c22ae0e 100644
--- a/nx-X11/programs/Xserver/dix/dispatch.c
+++ b/nx-X11/programs/Xserver/dix/dispatch.c
@@ -531,7 +531,7 @@ ProcCreateWindow(ClientPtr client)
 	Mask mask = pWin->eventMask;
 
 	pWin->eventMask = 0; /* subterfuge in case AddResource fails */
-	if (!AddResource(stuff->wid, RT_WINDOW, (pointer)pWin))
+	if (!AddResource(stuff->wid, RT_WINDOW, (void *)pWin))
 	    return BadAlloc;
 	pWin->eventMask = mask;
     }
@@ -1171,7 +1171,7 @@ ProcGrabServer(register ClientPtr client)
 	ServerGrabInfoRec grabinfo;
 	grabinfo.client = client;
 	grabinfo.grabstate  = SERVER_GRABBED;
-	CallCallbacks(&ServerGrabCallback, (pointer)&grabinfo);
+	CallCallbacks(&ServerGrabCallback, (void *)&grabinfo);
     }
 
     return(client->noClientException);
@@ -1200,7 +1200,7 @@ UngrabServer(ClientPtr client)
 	ServerGrabInfoRec grabinfo;
 	grabinfo.client = client;
 	grabinfo.grabstate  = SERVER_UNGRABBED;
-	CallCallbacks(&ServerGrabCallback, (pointer)&grabinfo);
+	CallCallbacks(&ServerGrabCallback, (void *)&grabinfo);
     }
 }
 
@@ -1468,7 +1468,7 @@ ProcListFontsWithInfo(register ClientPtr client)
  *  \param value must conform to DeleteType
  */
 int
-dixDestroyPixmap(pointer value, XID pid)
+dixDestroyPixmap(void * value, XID pid)
 {
     PixmapPtr pPixmap = (PixmapPtr)value;
     return (*pPixmap->drawable.pScreen->DestroyPixmap)(pPixmap);
@@ -1527,7 +1527,7 @@ CreatePmap:
     {
 	pMap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
 	pMap->drawable.id = stuff->pid;
-	if (AddResource(stuff->pid, RT_PIXMAP, (pointer)pMap))
+	if (AddResource(stuff->pid, RT_PIXMAP, (void *)pMap))
 	    return(client->noClientException);
     }
     return (BadAlloc);
@@ -1576,7 +1576,7 @@ ProcCreateGC(register ClientPtr client)
 			 (XID *) &stuff[1], &error);
     if (error != Success)
         return error;
-    if (!AddResource(stuff->gc, RT_GC, (pointer)pGC))
+    if (!AddResource(stuff->gc, RT_GC, (void *)pGC))
 	return (BadAlloc);
     return(client->noClientException);
 }
@@ -2250,7 +2250,7 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
 				         nlines,
 				         format,
 				         planemask,
-				         (pointer) pBuf);
+				         (void *) pBuf);
 #ifdef XCSECURITY
 	    if (pVisibleRegion)
 		SecurityCensorImage(client, pVisibleRegion, widthBytesLine,
@@ -2291,7 +2291,7 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
 				                 nlines,
 				                 format,
 				                 plane,
-				                 (pointer)pBuf);
+				                 (void *)pBuf);
 #ifdef XCSECURITY
 		    if (pVisibleRegion)
 			SecurityCensorImage(client, pVisibleRegion,
@@ -3122,7 +3122,7 @@ ProcCreateCursor (register ClientPtr client)
     /* zeroing the (pad) bits helps some ddx cursor handling */
     bzero((char *)srcbits, n);
     (* src->drawable.pScreen->GetImage)( (DrawablePtr)src, 0, 0, width, height,
-					 XYPixmap, 1, (pointer)srcbits);
+					 XYPixmap, 1, (void *)srcbits);
     if ( msk == (PixmapPtr)NULL)
     {
 	register unsigned char *bits = mskbits;
@@ -3134,7 +3134,7 @@ ProcCreateCursor (register ClientPtr client)
 	/* zeroing the (pad) bits helps some ddx cursor handling */
 	bzero((char *)mskbits, n);
 	(* msk->drawable.pScreen->GetImage)( (DrawablePtr)msk, 0, 0, width,
-					height, XYPixmap, 1, (pointer)mskbits);
+					height, XYPixmap, 1, (void *)mskbits);
     }
     cm.width = width;
     cm.height = height;
@@ -3144,7 +3144,7 @@ ProcCreateCursor (register ClientPtr client)
 	    stuff->foreRed, stuff->foreGreen, stuff->foreBlue,
 	    stuff->backRed, stuff->backGreen, stuff->backBlue);
 
-    if (pCursor && AddResource(stuff->cid, RT_CURSOR, (pointer)pCursor))
+    if (pCursor && AddResource(stuff->cid, RT_CURSOR, (void *)pCursor))
 	    return (client->noClientException);
     return BadAlloc;
 }
@@ -3167,7 +3167,7 @@ ProcCreateGlyphCursor (register ClientPtr client)
 			   &pCursor, client);
     if (res != Success)
 	return res;
-    if (AddResource(stuff->cid, RT_CURSOR, (pointer)pCursor))
+    if (AddResource(stuff->cid, RT_CURSOR, (void *)pCursor))
 	return client->noClientException;
     return BadAlloc;
 }
@@ -3311,10 +3311,10 @@ ProcChangeHosts(register ClientPtr client)
 
     if(stuff->mode == HostInsert)
 	result = AddHost(client, (int)stuff->hostFamily,
-			 stuff->hostLength, (pointer)&stuff[1]);
+			 stuff->hostLength, (void *)&stuff[1]);
     else if (stuff->mode == HostDelete)
 	result = RemoveHost(client, (int)stuff->hostFamily, 
-			    stuff->hostLength, (pointer)&stuff[1]);  
+			    stuff->hostLength, (void *)&stuff[1]);  
     else
     {
 	client->errorValue = stuff->mode;
@@ -3330,7 +3330,7 @@ ProcListHosts(register ClientPtr client)
 {
     xListHostsReply reply;
     int	len, nHosts, result;
-    pointer	pdata;
+    void *	pdata;
     /* REQUEST(xListHostsReq); */
 
     REQUEST_SIZE_MATCH(xListHostsReq);
@@ -3582,7 +3582,7 @@ CloseDownClient(register ClientPtr client)
 		clientinfo.client = client; 
 		clientinfo.prefix = (xConnSetupPrefix *)NULL;  
 		clientinfo.setup = (xConnSetup *) NULL;
-		CallCallbacks((&ClientStateCallback), (pointer)&clientinfo);
+		CallCallbacks((&ClientStateCallback), (void *)&clientinfo);
             } 
 	}
 	client->clientGone = TRUE;  /* so events aren't sent to client */
@@ -3619,7 +3619,7 @@ CloseDownClient(register ClientPtr client)
 	    clientinfo.client = client; 
 	    clientinfo.prefix = (xConnSetupPrefix *)NULL;  
 	    clientinfo.setup = (xConnSetup *) NULL;
-	    CallCallbacks((&ClientStateCallback), (pointer)&clientinfo);
+	    CallCallbacks((&ClientStateCallback), (void *)&clientinfo);
 	} 	    
 	FreeClientResources(client);
 	if (client->index < nextFreeClientID)
@@ -3669,7 +3669,7 @@ CloseDownRetainedResources()
     }
 }
 
-void InitClient(ClientPtr client, int i, pointer ospriv)
+void InitClient(ClientPtr client, int i, void * ospriv)
 {
     client->index = i;
     client->sequence = 0; 
@@ -3759,11 +3759,11 @@ InitClientPrivates(ClientPtr client)
     {
 	if ( (size = *sizes) )
 	{
-	    ppriv->ptr = (pointer)ptr;
+	    ppriv->ptr = (void *)ptr;
 	    ptr += size;
 	}
 	else
-	    ppriv->ptr = (pointer)NULL;
+	    ppriv->ptr = (void *)NULL;
     }
     return 1;
 }
@@ -3775,7 +3775,7 @@ InitClientPrivates(ClientPtr client)
  * Returns NULL if there are no free clients.
  *************************/
 
-ClientPtr NextAvailableClient(pointer ospriv)
+ClientPtr NextAvailableClient(void * ospriv)
 {
     register int i;
     register ClientPtr client;
@@ -3813,7 +3813,7 @@ ClientPtr NextAvailableClient(pointer ospriv)
         clientinfo.client = client; 
         clientinfo.prefix = (xConnSetupPrefix *)NULL;  
         clientinfo.setup = (xConnSetup *) NULL;
-	CallCallbacks((&ClientStateCallback), (pointer)&clientinfo);
+	CallCallbacks((&ClientStateCallback), (void *)&clientinfo);
     } 	
     return(client);
 }
@@ -3948,7 +3948,7 @@ SendConnSetup(register ClientPtr client, char *reason)
         clientinfo.client = client; 
         clientinfo.prefix = lconnSetupPrefix;  
         clientinfo.setup = (xConnSetup *)lConnectionInfo;
-	CallCallbacks((&ClientStateCallback), (pointer)&clientinfo);
+	CallCallbacks((&ClientStateCallback), (void *)&clientinfo);
     } 	
     return (client->noClientException);
 }
diff --git a/nx-X11/programs/Xserver/dix/dixfonts.c b/nx-X11/programs/Xserver/dix/dixfonts.c
index c7f00ce47..156bba2d0 100644
--- a/nx-X11/programs/Xserver/dix/dixfonts.c
+++ b/nx-X11/programs/Xserver/dix/dixfonts.c
@@ -144,7 +144,7 @@ _NXGetFontPathError:
 
 #define QUERYCHARINFO(pci, pr)  *(pr) = (pci)->metrics
 
-extern pointer fosNaturalParams;
+extern void * fosNaturalParams;
 extern FontPtr defaultFont;
 
 static FontPathElementPtr *font_path_elements = (FontPathElementPtr *) 0;
@@ -258,7 +258,7 @@ RemoveFontWakeup(FontPathElementPtr fpe)
 }
 
 void
-FontWakeup(pointer data, int count, pointer LastSelectMask)
+FontWakeup(void * data, int count, void * LastSelectMask)
 {
     int         i;
     FontPathElementPtr fpe;
@@ -338,7 +338,7 @@ doOpenFont(ClientPtr client, OFclosurePtr c)
 	if (c->current_fpe < c->num_fpes)
 	{
 	    fpe = c->fpe_list[c->current_fpe];
-	    (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+	    (*fpe_functions[fpe->type].client_died) ((void *) client, fpe);
 	}
 	err = Successful;
 	goto bail;
@@ -346,7 +346,7 @@ doOpenFont(ClientPtr client, OFclosurePtr c)
     while (c->current_fpe < c->num_fpes) {
 	fpe = c->fpe_list[c->current_fpe];
 	err = (*fpe_functions[fpe->type].open_font)
-	    ((pointer) client, fpe, c->flags,
+	    ((void *) client, fpe, c->flags,
 	     c->fontname, c->fnamelen, FontFormat,
 	     BitmapFormatMaskByte |
 	     BitmapFormatMaskBit |
@@ -380,7 +380,7 @@ doOpenFont(ClientPtr client, OFclosurePtr c)
 	if (err == Suspended) {
 	    if (!c->slept) {
 		c->slept = TRUE;
-		ClientSleep(client, (ClientSleepProcPtr)doOpenFont, (pointer) c);
+		ClientSleep(client, (ClientSleepProcPtr)doOpenFont, (void *) c);
 	    }
 	    return TRUE;
 	}
@@ -418,7 +418,7 @@ doOpenFont(ClientPtr client, OFclosurePtr c)
 	    }
 	}
     }
-    if (!AddResource(c->fontid, RT_FONT, (pointer) pfont)) {
+    if (!AddResource(c->fontid, RT_FONT, (void *) pfont)) {
 	err = AllocError;
 	goto bail;
     }
@@ -481,7 +481,7 @@ OpenFont(ClientPtr client, XID fid, Mask flags, unsigned lenfname, char *pfontna
 	cached = FindCachedFontPattern(patternCache, pfontname, lenfname);
 	if (cached && cached->info.cachable)
 	{
-	    if (!AddResource(fid, RT_FONT, (pointer) cached))
+	    if (!AddResource(fid, RT_FONT, (void *) cached))
 		return BadAlloc;
 	    cached->refcnt++;
 	    return Success;
@@ -532,7 +532,7 @@ OpenFont(ClientPtr client, XID fid, Mask flags, unsigned lenfname, char *pfontna
  *  \param value must conform to DeleteType
  */
 int
-CloseFont(pointer value, XID fid)
+CloseFont(void * value, XID fid)
 {
     int         nscr;
     ScreenPtr   pscr;
@@ -660,7 +660,7 @@ doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
 	if (c->current.current_fpe < c->num_fpes)
 	{
 	    fpe = c->fpe_list[c->current.current_fpe];
-	    (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+	    (*fpe_functions[fpe->type].client_died) ((void *) client, fpe);
 	}
 	err = Successful;
 	goto bail;
@@ -678,7 +678,7 @@ doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
 	    /* This FPE doesn't support/require list_fonts_and_aliases */
 
 	    err = (*fpe_functions[fpe->type].list_fonts)
-		((pointer) c->client, fpe, c->current.pattern,
+		((void *) c->client, fpe, c->current.pattern,
 		 c->current.patlen, c->current.max_names - c->names->nnames,
 		 c->names);
 
@@ -687,7 +687,7 @@ doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
 		    c->slept = TRUE;
 		    ClientSleep(client,
 			(ClientSleepProcPtr)doListFontsAndAliases,
-			(pointer) c);
+			(void *) c);
 		}
 		return TRUE;
 	    }
@@ -707,14 +707,14 @@ doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
 
 	    if (!c->current.list_started) {
 		err = (*fpe_functions[fpe->type].start_list_fonts_and_aliases)
-		    ((pointer) c->client, fpe, c->current.pattern,
+		    ((void *) c->client, fpe, c->current.pattern,
 		     c->current.patlen, c->current.max_names - c->names->nnames,
 		     &c->current.private);
 		if (err == Suspended) {
 		    if (!c->slept) {
 			ClientSleep(client,
 				    (ClientSleepProcPtr)doListFontsAndAliases,
-				    (pointer) c);
+				    (void *) c);
 			c->slept = TRUE;
 		    }
 		    return TRUE;
@@ -726,13 +726,13 @@ doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
 		char    *tmpname;
 		name = 0;
 		err = (*fpe_functions[fpe->type].list_next_font_or_alias)
-		    ((pointer) c->client, fpe, &name, &namelen, &tmpname,
+		    ((void *) c->client, fpe, &name, &namelen, &tmpname,
 		     &resolvedlen, c->current.private);
 		if (err == Suspended) {
 		    if (!c->slept) {
 			ClientSleep(client,
 				    (ClientSleepProcPtr)doListFontsAndAliases,
-				    (pointer) c);
+				    (void *) c);
 			c->slept = TRUE;
 		    }
 		    return TRUE;
@@ -780,7 +780,7 @@ doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
 
 		    tmpname = 0;
 		    (void) (*fpe_functions[fpe->type].list_next_font_or_alias)
-			((pointer) c->client, fpe, &tmpname, &tmpnamelen,
+			((void *) c->client, fpe, &tmpname, &tmpnamelen,
 			 &tmpname, &tmpnamelen, c->current.private);
 		    if (--aliascount <= 0)
 		    {
@@ -968,7 +968,7 @@ doListFontsWithInfo(ClientPtr client, LFWIclosurePtr c)
 	if (c->current.current_fpe < c->num_fpes)
  	{
 	    fpe = c->fpe_list[c->current.current_fpe];
-	    (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+	    (*fpe_functions[fpe->type].client_died) ((void *) client, fpe);
 	}
 	err = Successful;
 	goto bail;
@@ -1237,7 +1237,7 @@ doPolyText(ClientPtr client, register PTclosurePtr c)
     if (client->clientGone)
     {
 	fpe = c->pGC->font->fpe;
-	(*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+	(*fpe_functions[fpe->type].client_died) ((void *) client, fpe);
 
 	if (c->slept)
 	{
@@ -1265,7 +1265,7 @@ doPolyText(ClientPtr client, register PTclosurePtr c)
 	   the FPE code to clean up after client and avoid further
 	   rendering while we clean up after ourself.  */
 	fpe = c->pGC->font->fpe;
-	(*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+	(*fpe_functions[fpe->type].client_died) ((void *) client, fpe);
 	c->pDraw = (DrawablePtr)0;
     }
 
@@ -1429,7 +1429,7 @@ doPolyText(ClientPtr client, register PTclosurePtr c)
 		    c->slept = TRUE;
 		    ClientSleep(client,
 		    	     (ClientSleepProcPtr)doPolyText,
-			     (pointer) c);
+			     (void *) c);
 
 		    /* Set up to perform steps 3 and 4 */
 		    client_state = START_SLEEP;
@@ -1535,7 +1535,7 @@ doImageText(ClientPtr client, register ITclosurePtr c)
     if (client->clientGone)
     {
 	fpe = c->pGC->font->fpe;
-	(*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+	(*fpe_functions[fpe->type].client_died) ((void *) client, fpe);
 	err = Success;
 	goto bail;
     }
@@ -1549,7 +1549,7 @@ doImageText(ClientPtr client, register ITclosurePtr c)
 	/* Our drawable has disappeared.  Treat like client died... ask
 	   the FPE code to clean up after client. */
 	fpe = c->pGC->font->fpe;
-	(*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+	(*fpe_functions[fpe->type].client_died) ((void *) client, fpe);
 	err = Success;
 	goto bail;
     }
@@ -1616,7 +1616,7 @@ doImageText(ClientPtr client, register ITclosurePtr c)
 	    ValidateGC(c->pDraw, c->pGC);
 
 	    c->slept = TRUE;
-            ClientSleep(client, (ClientSleepProcPtr)doImageText, (pointer) c);
+            ClientSleep(client, (ClientSleepProcPtr)doImageText, (void *) c);
         }
         return TRUE;
     }
@@ -1966,7 +1966,7 @@ DeleteClientFontStuff(ClientPtr client)
     {
 	fpe = font_path_elements[i];
 	if (fpe_functions[fpe->type].client_died)
-	    (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+	    (*fpe_functions[fpe->type].client_died) ((void *) client, fpe);
     }
 }
 
@@ -2106,7 +2106,7 @@ GetNewFontClientID()
 int
 StoreFontClientFont(FontPtr pfont, Font id)
 {
-    return AddResource(id, RT_NONE, (pointer) pfont);
+    return AddResource(id, RT_NONE, (void *) pfont);
 }
 
 void
@@ -2139,7 +2139,7 @@ init_fs_handlers(FontPathElementPtr fpe, BlockHandlerProcPtr block_handler)
 #endif
 
 	if (!RegisterBlockAndWakeupHandlers(block_handler,
-					    FontWakeup, (pointer) 0))
+					    FontWakeup, (void *) 0))
 	    return AllocError;
 	fs_handlers_installed++;
     }
@@ -2159,7 +2159,7 @@ remove_fs_handlers(FontPathElementPtr fpe, BlockHandlerProcPtr block_handler, Bo
 #endif
 
 	    RemoveBlockAndWakeupHandlers(block_handler, FontWakeup,
-					 (pointer) 0);
+					 (void *) 0);
 	}
     }
     RemoveFontWakeup(fpe);
@@ -2190,7 +2190,7 @@ dump_char_ascii(CharInfoPtr cip)
 
     bpr = GLYPH_SIZE(cip, 4);
     for (r = 0; r < (cip->metrics.ascent + cip->metrics.descent); r++) {
-	pointer     row = (pointer) cip->bits + r * bpr;
+	void *     row = (void *) cip->bits + r * bpr;
 
 	byte = 0;
 	for (l = 0; l <= (cip->metrics.rightSideBearing -
diff --git a/nx-X11/programs/Xserver/dix/dixutils.c b/nx-X11/programs/Xserver/dix/dixutils.c
index e7d4ccd4d..f3b3373d0 100644
--- a/nx-X11/programs/Xserver/dix/dixutils.c
+++ b/nx-X11/programs/Xserver/dix/dixutils.c
@@ -236,23 +236,23 @@ SecurityLookupWindow(XID rid, ClientPtr client, Mask access_mode)
 }
 
 
-pointer
+void *
 SecurityLookupDrawable(XID rid, ClientPtr client, Mask access_mode)
 {
     register DrawablePtr pDraw;
 
     if(rid == INVALID)
-	return (pointer) NULL;
+	return (void *) NULL;
     if (client->trustLevel != XSecurityClientTrusted)
 	return (DrawablePtr)SecurityLookupIDByClass(client, rid, RC_DRAWABLE,
 						    access_mode);
     if (client->lastDrawableID == rid)
-	return ((pointer) client->lastDrawable);
+	return ((void *) client->lastDrawable);
     pDraw = (DrawablePtr)SecurityLookupIDByClass(client, rid, RC_DRAWABLE,
 						 access_mode);
     if (pDraw && (pDraw->type != UNDRAWABLE_WINDOW))
-        return (pointer)pDraw;		
-    return (pointer)NULL;
+        return (void *)pDraw;
+    return (void *)NULL;
 }
 
 /* We can't replace the LookupWindow and LookupDrawable functions with
@@ -265,7 +265,7 @@ LookupWindow(XID rid, ClientPtr client)
     return SecurityLookupWindow(rid, client, SecurityUnknownAccess);
 }
 
-pointer
+void *
 LookupDrawable(XID rid, ClientPtr client)
 {
     return SecurityLookupDrawable(rid, client, SecurityUnknownAccess);
@@ -298,19 +298,19 @@ LookupWindow(XID rid, ClientPtr client)
 }
 
 
-pointer
+void *
 LookupDrawable(XID rid, ClientPtr client)
 {
     register DrawablePtr pDraw;
 
     if(rid == INVALID)
-	return (pointer) NULL;
+	return (void *) NULL;
     if (client->lastDrawableID == rid)
-	return ((pointer) client->lastDrawable);
+	return ((void *) client->lastDrawable);
     pDraw = (DrawablePtr)LookupIDByClass(rid, RC_DRAWABLE);
     if (pDraw && (pDraw->type != UNDRAWABLE_WINDOW))
-        return (pointer)pDraw;		
-    return (pointer)NULL;
+        return (void *)pDraw;
+    return (void *)NULL;
 }
 
 #endif /* XCSECURITY */
@@ -318,7 +318,7 @@ LookupDrawable(XID rid, ClientPtr client)
 ClientPtr
 LookupClient(XID rid, ClientPtr client)
 {
-    pointer pRes = (pointer)SecurityLookupIDByClass(client, rid, RC_ANY,
+    void * pRes = (void *)SecurityLookupIDByClass(client, rid, RC_ANY,
 						    SecurityReadAccess);
     int clientIndex = CLIENT_ID(rid);
 
@@ -343,7 +343,7 @@ AlterSaveSetForClient(ClientPtr client, WindowPtr pWin, unsigned mode,
     if (numnow)
     {
 	pTmp = client->saveSet;
-	while ((j < numnow) && (SaveSetWindow(pTmp[j]) != (pointer)pWin))
+	while ((j < numnow) && (SaveSetWindow(pTmp[j]) != (void *)pWin))
 	    j++;
     }
     if (mode == SetModeInsert)
@@ -413,7 +413,7 @@ NoopDDA(void)
 typedef struct _BlockHandler {
     BlockHandlerProcPtr BlockHandler;
     WakeupHandlerProcPtr WakeupHandler;
-    pointer blockData;
+    void * blockData;
     Bool    deleted;
 } BlockHandlerRec, *BlockHandlerPtr;
 
@@ -429,7 +429,7 @@ static Bool		handlerDeleted;
  *  \param pReadMask  nor how it represents the det of descriptors
  */
 void
-BlockHandler(pointer pTimeout, pointer pReadmask)
+BlockHandler(void * pTimeout, void * pReadmask)
 {
     register int i, j;
     
@@ -463,7 +463,7 @@ BlockHandler(pointer pTimeout, pointer pReadmask)
  *  \param pReadmask the resulting descriptor mask
  */
 void
-WakeupHandler(int result, pointer pReadmask)
+WakeupHandler(int result, void * pReadmask)
 {
     register int i, j;
 
@@ -498,7 +498,7 @@ WakeupHandler(int result, pointer pReadmask)
 Bool
 RegisterBlockAndWakeupHandlers (BlockHandlerProcPtr blockHandler, 
                                 WakeupHandlerProcPtr wakeupHandler, 
-                                pointer blockData)
+                                void * blockData)
 {
     BlockHandlerPtr new;
 
@@ -522,7 +522,7 @@ RegisterBlockAndWakeupHandlers (BlockHandlerProcPtr blockHandler,
 void
 RemoveBlockAndWakeupHandlers (BlockHandlerProcPtr blockHandler, 
                               WakeupHandlerProcPtr wakeupHandler, 
-                              pointer blockData)
+                              void * blockData)
 {
     int	    i;
 
@@ -616,8 +616,8 @@ ProcessWorkQueueZombies(void)
 
 Bool
 QueueWorkProc (
-    Bool (*function)(ClientPtr /* pClient */, pointer /* closure */),
-    ClientPtr client, pointer closure)
+    Bool (*function)(ClientPtr /* pClient */, void * /* closure */),
+    ClientPtr client, void * closure)
 {
     WorkQueuePtr    q;
 
@@ -645,13 +645,13 @@ typedef struct _SleepQueue {
     struct _SleepQueue	*next;
     ClientPtr		client;
     ClientSleepProcPtr  function;
-    pointer		closure;
+    void *		closure;
 } SleepQueueRec, *SleepQueuePtr;
 
 static SleepQueuePtr	sleepQueue = NULL;
 
 Bool
-ClientSleep (ClientPtr client, ClientSleepProcPtr function, pointer closure)
+ClientSleep (ClientPtr client, ClientSleepProcPtr function, void * closure)
 {
     SleepQueuePtr   q;
 
@@ -731,7 +731,7 @@ static Bool
 _AddCallback(
     CallbackListPtr *pcbl,
     CallbackProcPtr callback,
-    pointer         data)
+    void            *data)
 {
     CallbackPtr     cbr;
 
@@ -750,7 +750,7 @@ static Bool
 _DeleteCallback(
     CallbackListPtr *pcbl,
     CallbackProcPtr callback,
-    pointer         data)
+    void            *data)
 {
     CallbackListPtr cbl = *pcbl;
     CallbackPtr     cbr, pcbr;
@@ -785,7 +785,7 @@ _DeleteCallback(
 static void 
 _CallCallbacks(
     CallbackListPtr    *pcbl,
-    pointer	    call_data)
+    void	       *call_data)
 {
     CallbackListPtr cbl = *pcbl;
     CallbackPtr     cbr, pcbr;
@@ -914,7 +914,7 @@ CreateCallbackList(CallbackListPtr *pcbl, CallbackFuncsPtr cbfuncs)
 }
 
 Bool 
-AddCallback(CallbackListPtr *pcbl, CallbackProcPtr callback, pointer data)
+AddCallback(CallbackListPtr *pcbl, CallbackProcPtr callback, void * data)
 {
     if (!pcbl) return FALSE;
     if (!*pcbl)
@@ -926,14 +926,14 @@ AddCallback(CallbackListPtr *pcbl, CallbackProcPtr callback, pointer data)
 }
 
 Bool 
-DeleteCallback(CallbackListPtr *pcbl, CallbackProcPtr callback, pointer data)
+DeleteCallback(CallbackListPtr *pcbl, CallbackProcPtr callback, void * data)
 {
     if (!pcbl || !*pcbl) return FALSE;
     return ((*(*pcbl)->funcs.DeleteCallback) (pcbl, callback, data));
 }
 
 void 
-CallCallbacks(CallbackListPtr *pcbl, pointer call_data)
+CallCallbacks(CallbackListPtr *pcbl, void * call_data)
 {
     if (!pcbl || !*pcbl) return;
     (*(*pcbl)->funcs.CallCallbacks) (pcbl, call_data);
diff --git a/nx-X11/programs/Xserver/dix/events.c b/nx-X11/programs/Xserver/dix/events.c
index 9d1ebe7d0..ab995a772 100644
--- a/nx-X11/programs/Xserver/dix/events.c
+++ b/nx-X11/programs/Xserver/dix/events.c
@@ -1079,7 +1079,7 @@ EnqueueEvent(xEvent *xE, DeviceIntPtr device, int count)
 		WindowTable[sprite.hotPhys.pScreen->myNum]->drawable.id;
 	eventinfo.events = xE;
 	eventinfo.count = count;
-	CallCallbacks(&DeviceEventCallback, (pointer)&eventinfo);
+	CallCallbacks(&DeviceEventCallback, (void *)&eventinfo);
     }
     if (xE->u.u.type == MotionNotify)
     {
@@ -2587,7 +2587,7 @@ CheckPassiveGrabsOnWindow(
 a passive grab to be activated.  If the event is a keyboard event, the
 ancestors of the focus window are traced down and tried to see if they have
 any passive grabs to be activated.  If the focus window itself is reached and
-it's descendants contain they pointer, the ancestors of the window that the
+its descendants contain the pointer, the ancestors of the window that the
 pointer is in are then traced down starting at the focus window, otherwise no
 grabs are activated.  If the event is a pointer event, the ancestors of the
 window that the pointer is in are traced down starting at the root until
@@ -2812,7 +2812,7 @@ drawable.id:0;
 	    DeviceEventInfoRec eventinfo;
 	    eventinfo.events = xE;
 	    eventinfo.count = count;
-	    CallCallbacks(&DeviceEventCallback, (pointer)&eventinfo);
+	    CallCallbacks(&DeviceEventCallback, (void *)&eventinfo);
 	}
     }
 #ifdef XEVIE
@@ -2998,7 +2998,7 @@ ProcessPointerEvent (register xEvent *xE, register DeviceIntPtr mouse, int count
 		    WindowTable[sprite.hotPhys.pScreen->myNum]->drawable.id;
 	    eventinfo.events = xE;
 	    eventinfo.count = count;
-	    CallCallbacks(&DeviceEventCallback, (pointer)&eventinfo);
+	    CallCallbacks(&DeviceEventCallback, (void *)&eventinfo);
 	}
     }
     if (xE->u.u.type != MotionNotify)
@@ -3111,7 +3111,7 @@ RecalculateDeliverableEvents(pWin)
  *  \param value must conform to DeleteType
  */
 int
-OtherClientGone(pointer value, XID id)
+OtherClientGone(void * value, XID id)
 {
     register OtherClientsPtr other, prev;
     register WindowPtr pWin = (WindowPtr)value;
@@ -3206,7 +3206,7 @@ EventSelectForWindow(register WindowPtr pWin, register ClientPtr client, Mask ma
 	others->resource = FakeClientID(client->index);
 	others->next = pWin->optional->otherClients;
 	pWin->optional->otherClients = others;
-	if (!AddResource(others->resource, RT_OTHERCLIENT, (pointer)pWin))
+	if (!AddResource(others->resource, RT_OTHERCLIENT, (void *)pWin))
 	    return BadAlloc;
     }
 maskSet: 
@@ -4653,7 +4653,7 @@ WriteEventsToClient(ClientPtr pClient, int count, xEvent *events)
 	eventinfo.client = pClient;
 	eventinfo.events = events;
 	eventinfo.count = count;
-	CallCallbacks(&EventCallback, (pointer)&eventinfo);
+	CallCallbacks(&EventCallback, (void *)&eventinfo);
     }
     if(pClient->swapped)
     {
diff --git a/nx-X11/programs/Xserver/dix/gc.c b/nx-X11/programs/Xserver/dix/gc.c
index cb21e09fd..834919946 100644
--- a/nx-X11/programs/Xserver/dix/gc.c
+++ b/nx-X11/programs/Xserver/dix/gc.c
@@ -442,7 +442,7 @@ dixChangeGC(ClientPtr client, register GC *pGC, register BITS32 mask, CARD32 *pC
 		if(error == Success)
 		{
 		    (*pGC->funcs->ChangeClip)(pGC, clipType,
-					      (pointer)pPixmap, 0);
+					      (void *)pPixmap, 0);
 		}
 		break;
 	    }
@@ -534,7 +534,7 @@ ChangeGC(register GC *pGC, register BITS32 mask, XID *pval)
    pval contains an appropriate value for each mask.
    fPointer is true if the values for tiles, stipples, fonts or clipmasks
    are pointers instead of IDs.  Note: if you are passing pointers you
-   MUST declare the array of values as type pointer!  Other data types
+   MUST declare the array of values as type void*!  Other data types
    may not be large enough to hold pointers on some machines.  Yes,
    this means you have to cast to (XID *) when you pass the array to
    DoChangeGC.  Similarly, if you are not passing pointers (fPointer = 0) you
@@ -591,11 +591,11 @@ AllocateGC(ScreenPtr pScreen)
 	{
 	    if ( (size = *sizes) )
 	    {
-		ppriv->ptr = (pointer)ptr;
+		ppriv->ptr = (void *)ptr;
 		ptr += size;
 	    }
 	    else
-		ppriv->ptr = (pointer)NULL;
+		ppriv->ptr = (void *)NULL;
 	}
     }
     return pGC;
@@ -651,7 +651,7 @@ CreateGC(DrawablePtr pDrawable, BITS32 mask, XID *pval, int *pStatus)
     pGC->clipOrg.x = 0;
     pGC->clipOrg.y = 0;
     pGC->clientClipType = CT_NONE;
-    pGC->clientClip = (pointer)NULL;
+    pGC->clientClip = (void *)NULL;
     pGC->numInDashList = 2;
     pGC->dash = DefaultDash;
     pGC->dashOffset = 0;
@@ -890,7 +890,7 @@ CopyGC(register GC *pgcSrc, register GC *pgcDst, register BITS32 mask)
  *  \param value  must conform to DeleteType
  */
 int
-FreeGC(pointer value, XID gid)
+FreeGC(void * value, XID gid)
 {
     GCPtr pGC = (GCPtr)value;
 
@@ -1208,7 +1208,7 @@ SetClipRects(GCPtr pGC, int xOrigin, int yOrigin, int nrects,
 
     if (size)
 	memmove((char *)prectsNew, (char *)prects, size);
-    (*pGC->funcs->ChangeClip)(pGC, newct, (pointer)prectsNew, nrects);
+    (*pGC->funcs->ChangeClip)(pGC, newct, (void *)prectsNew, nrects);
     if (pGC->funcs->ChangeGC)
 	(*pGC->funcs->ChangeGC) (pGC, GCClipXOrigin|GCClipYOrigin|GCClipMask);
     return Success;
diff --git a/nx-X11/programs/Xserver/dix/glyphcurs.c b/nx-X11/programs/Xserver/dix/glyphcurs.c
index 8f8adf5ce..726297d96 100644
--- a/nx-X11/programs/Xserver/dix/glyphcurs.c
+++ b/nx-X11/programs/Xserver/dix/glyphcurs.c
@@ -119,7 +119,7 @@ ServerBitsFromGlyph(FontPtr pfont, unsigned ch, register CursorMetricPtr cm, uns
     /* fill the pixmap with 0 */
     gcval[0].val = GXcopy;
     gcval[1].val = 0;
-    gcval[2].ptr = (pointer)pfont;
+    gcval[2].ptr = (void *)pfont;
     dixChangeGC(NullClient, pGC, GCFunction | GCForeground | GCFont,
 		NULL, gcval);
     ValidateGC((DrawablePtr)ppix, pGC);
diff --git a/nx-X11/programs/Xserver/dix/grabs.c b/nx-X11/programs/Xserver/dix/grabs.c
index 1d76f7f07..e133c0dfc 100644
--- a/nx-X11/programs/Xserver/dix/grabs.c
+++ b/nx-X11/programs/Xserver/dix/grabs.c
@@ -128,7 +128,7 @@ FreeGrab(GrabPtr pGrab)
 }
 
 int
-DeletePassiveGrab(pointer value, XID id)
+DeletePassiveGrab(void * value, XID id)
 {
     register GrabPtr g, prev;
     GrabPtr pGrab = (GrabPtr)value;
@@ -295,7 +295,7 @@ AddPassiveGrabToList(GrabPtr pGrab)
     }
     pGrab->next = pGrab->window->optional->passiveGrabs;
     pGrab->window->optional->passiveGrabs = pGrab;
-    if (AddResource(pGrab->resource, RT_PASSIVEGRAB, (pointer)pGrab))
+    if (AddResource(pGrab->resource, RT_PASSIVEGRAB, (void *)pGrab))
 	return Success;
     return BadAlloc;
 }
@@ -389,7 +389,7 @@ DeletePassiveGrabFromList(GrabPtr pMinuendGrab)
 		ok = FALSE;
 	    }
 	    else if (!AddResource(pNewGrab->resource, RT_PASSIVEGRAB,
-				  (pointer)pNewGrab))
+				  (void *)pNewGrab))
 		ok = FALSE;
 	    else
 		adds[nadds++] = pNewGrab;
diff --git a/nx-X11/programs/Xserver/dix/main.c b/nx-X11/programs/Xserver/dix/main.c
index b7452c5c2..954c260c2 100644
--- a/nx-X11/programs/Xserver/dix/main.c
+++ b/nx-X11/programs/Xserver/dix/main.c
@@ -319,7 +319,7 @@ main(int argc, char *argv[], char *envp[])
 	    serverClient = (ClientPtr)xalloc(sizeof(ClientRec));
 	    if (!serverClient)
 		FatalError("couldn't create server client");
-	    InitClient(serverClient, 0, (pointer)NULL);
+	    InitClient(serverClient, 0, (void *)NULL);
 	}
 	else
 	    ResetWellKnownSockets ();
diff --git a/nx-X11/programs/Xserver/dix/pixmap.c b/nx-X11/programs/Xserver/dix/pixmap.c
index 4be7d03ce..7888cf90a 100644
--- a/nx-X11/programs/Xserver/dix/pixmap.c
+++ b/nx-X11/programs/Xserver/dix/pixmap.c
@@ -53,7 +53,7 @@ from The Open Group.
 /* callable by ddx */
 PixmapPtr
 GetScratchPixmapHeader(ScreenPtr pScreen, int width, int height, int depth, 
-                       int bitsPerPixel, int devKind, pointer pPixData)
+                       int bitsPerPixel, int devKind, void * pPixData)
 {
     PixmapPtr pPixmap = pScreen->pScratchPixmap;
 
@@ -139,11 +139,11 @@ AllocatePixmap(ScreenPtr pScreen, int pixDataSize)
     {
         if ((size = *sizes) != 0)
         {
-	    ppriv->ptr = (pointer)ptr;
+	    ppriv->ptr = (void *)ptr;
 	    ptr += size;
         }
         else
-	    ppriv->ptr = (pointer)NULL;
+	    ppriv->ptr = (void *)NULL;
     }
 #else
     pPixmap = (PixmapPtr)xalloc(sizeof(PixmapRec) + pixDataSize);
diff --git a/nx-X11/programs/Xserver/dix/property.c b/nx-X11/programs/Xserver/dix/property.c
index 72c8c70ef..f462a3ebd 100644
--- a/nx-X11/programs/Xserver/dix/property.c
+++ b/nx-X11/programs/Xserver/dix/property.c
@@ -263,10 +263,10 @@ ProcChangeProperty(ClientPtr client)
 
 #ifdef LBX
     err = LbxChangeWindowProperty(client, pWin, stuff->property, stuff->type,
-	 (int)format, (int)mode, len, TRUE, (pointer)&stuff[1], TRUE, NULL);
+	 (int)format, (int)mode, len, TRUE, (void *)&stuff[1], TRUE, NULL);
 #else
     err = ChangeWindowProperty(pWin, stuff->property, stuff->type, (int)format,
-			       (int)mode, len, (pointer)&stuff[1], TRUE);
+			       (int)mode, len, (void *)&stuff[1], TRUE);
 #endif
     if (err != Success)
 	return err;
@@ -276,7 +276,7 @@ ProcChangeProperty(ClientPtr client)
 
 int
 ChangeWindowProperty(WindowPtr pWin, Atom property, Atom type, int format, 
-                     int mode, unsigned long len, pointer value, 
+                     int mode, unsigned long len, void * value, 
                      Bool sendevent)
 {
 #ifdef LBX
@@ -288,7 +288,7 @@ ChangeWindowProperty(WindowPtr pWin, Atom property, Atom type, int format,
     xEvent event;
     int sizeInBytes;
     int totalSize;
-    pointer data;
+    void * data;
 
     sizeInBytes = format>>3;
     totalSize = len * sizeInBytes;
@@ -309,7 +309,7 @@ ChangeWindowProperty(WindowPtr pWin, Atom property, Atom type, int format,
         pProp = (PropertyPtr)xalloc(sizeof(PropertyRec));
 	if (!pProp)
 	    return(BadAlloc);
-        data = (pointer)xalloc(totalSize);
+        data = (void *)xalloc(totalSize);
 	if (!data && len)
 	{
 	    xfree(pProp);
@@ -340,7 +340,7 @@ ChangeWindowProperty(WindowPtr pWin, Atom property, Atom type, int format,
         {
 	    if (totalSize != pProp->size * (pProp->format >> 3))
 	    {
-	    	data = (pointer)xrealloc(pProp->data, totalSize);
+		data = (void *)xrealloc(pProp->data, totalSize);
 	    	if (!data && len)
 		    return(BadAlloc);
             	pProp->data = data;
@@ -357,7 +357,7 @@ ChangeWindowProperty(WindowPtr pWin, Atom property, Atom type, int format,
 	}
         else if (mode == PropModeAppend)
         {
-	    data = (pointer)xrealloc(pProp->data,
+	    data = (void *)xrealloc(pProp->data,
 				     sizeInBytes * (len + pProp->size));
 	    if (!data)
 		return(BadAlloc);
@@ -369,7 +369,7 @@ ChangeWindowProperty(WindowPtr pWin, Atom property, Atom type, int format,
 	}
         else if (mode == PropModePrepend)
         {
-            data = (pointer)xalloc(sizeInBytes * (len + pProp->size));
+            data = (void *)xalloc(sizeInBytes * (len + pProp->size));
 	    if (!data)
 		return(BadAlloc);
 	    memmove(&((char *)data)[totalSize], (char *)pProp->data, 
diff --git a/nx-X11/programs/Xserver/dix/resource.c b/nx-X11/programs/Xserver/dix/resource.c
index e12bc7b67..e0fc2b997 100644
--- a/nx-X11/programs/Xserver/dix/resource.c
+++ b/nx-X11/programs/Xserver/dix/resource.c
@@ -139,7 +139,7 @@ typedef struct _Resource {
     struct _Resource	*next;
     XID			id;
     RESTYPE		type;
-    pointer		value;
+    void *		value;
 } ResourceRec, *ResourcePtr;
 #define NullResource ((ResourcePtr)NULL)
 
@@ -423,7 +423,7 @@ FakeClientID(register int client)
 }
 
 Bool
-AddResource(XID id, RESTYPE type, pointer value)
+AddResource(XID id, RESTYPE type, void * value)
 {
     int client;
     register ClientResourceRec *rrec;
@@ -595,7 +595,7 @@ FreeResourceByType(XID id, RESTYPE type, Bool skipFree)
  */
 
 Bool
-ChangeResourceValue (XID id, RESTYPE rtype, pointer value)
+ChangeResourceValue (XID id, RESTYPE rtype, void * value)
 {
     int    cid;
     register    ResourcePtr res;
@@ -627,7 +627,7 @@ FindClientResourcesByType(
     ClientPtr client,
     RESTYPE type,
     FindResType func,
-    pointer cdata
+    void * cdata
 ){
     register ResourcePtr *resources;
     register ResourcePtr this, next;
@@ -658,7 +658,7 @@ void
 FindAllClientResources(
     ClientPtr client,
     FindAllRes func,
-    pointer cdata
+    void * cdata
 ){
     register ResourcePtr *resources;
     register ResourcePtr this, next;
@@ -684,12 +684,12 @@ FindAllClientResources(
 }
 
 
-pointer
+void *
 LookupClientResourceComplex(
     ClientPtr client,
     RESTYPE type,
     FindComplexResType func,
-    pointer cdata
+    void * cdata
 ){
     ResourcePtr *resources;
     ResourcePtr this;
@@ -831,12 +831,12 @@ LegalNewID(XID id, register ClientPtr client)
  * else NULL is returned.
  */
 
-pointer
+void *
 SecurityLookupIDByType(ClientPtr client, XID id, RESTYPE rtype, Mask mode)
 {
     int    cid;
     register    ResourcePtr res;
-    pointer retval = NULL;
+    void * retval = NULL;
 
     assert(client == NullClient ||
      (client->index <= currentMaxClients && clients[client->index] == client));
@@ -860,12 +860,12 @@ SecurityLookupIDByType(ClientPtr client, XID id, RESTYPE rtype, Mask mode)
 }
 
 
-pointer
+void *
 SecurityLookupIDByClass(ClientPtr client, XID id, RESTYPE classes, Mask mode)
 {
     int    cid;
     register ResourcePtr res = NULL;
-    pointer retval = NULL;
+    void * retval = NULL;
 
     assert(client == NullClient ||
      (client->index <= currentMaxClients && clients[client->index] == client));
@@ -892,14 +892,14 @@ SecurityLookupIDByClass(ClientPtr client, XID id, RESTYPE classes, Mask mode)
  * macros because of compatibility with loadable servers.
  */
 
-pointer
+void *
 LookupIDByType(XID id, RESTYPE rtype)
 {
     return SecurityLookupIDByType(NullClient, id, rtype,
 				  SecurityUnknownAccess);
 }
 
-pointer
+void *
 LookupIDByClass(XID id, RESTYPE classes)
 {
     return SecurityLookupIDByClass(NullClient, id, classes,
@@ -911,7 +911,7 @@ LookupIDByClass(XID id, RESTYPE classes)
 /*
  *  LookupIDByType returns the object with the given id and type, else NULL.
  */ 
-pointer
+void *
 LookupIDByType(XID id, RESTYPE rtype)
 {
     int    cid;
@@ -926,14 +926,14 @@ LookupIDByType(XID id, RESTYPE rtype)
 	    if ((res->id == id) && (res->type == rtype))
 		return res->value;
     }
-    return (pointer)NULL;
+    return (void *)NULL;
 }
 
 /*
  *  LookupIDByClass returns the object with the given id and any one of the
  *  given classes, else NULL.
  */ 
-pointer
+void *
 LookupIDByClass(XID id, RESTYPE classes)
 {
     int    cid;
@@ -948,7 +948,7 @@ LookupIDByClass(XID id, RESTYPE classes)
 	    if ((res->id == id) && (res->type & classes))
 		return res->value;
     }
-    return (pointer)NULL;
+    return (void *)NULL;
 }
 
 #endif /* XCSECURITY */
diff --git a/nx-X11/programs/Xserver/dix/window.c b/nx-X11/programs/Xserver/dix/window.c
index b65bda0e3..340ca50cc 100644
--- a/nx-X11/programs/Xserver/dix/window.c
+++ b/nx-X11/programs/Xserver/dix/window.c
@@ -203,7 +203,7 @@ PrintWindowTree()
 #endif
 
 int
-TraverseTree(register WindowPtr pWin, VisitWindowProcPtr func, pointer data)
+TraverseTree(register WindowPtr pWin, VisitWindowProcPtr func, void * data)
 {
     register int result;
     register WindowPtr pChild;
@@ -238,7 +238,7 @@ TraverseTree(register WindowPtr pWin, VisitWindowProcPtr func, pointer data)
  *****/
 
 int
-WalkTree(ScreenPtr pScreen, VisitWindowProcPtr func, pointer data)
+WalkTree(ScreenPtr pScreen, VisitWindowProcPtr func, void * data)
 {
     return(TraverseTree(WindowTable[pScreen->myNum], func, data));
 }
@@ -264,7 +264,7 @@ SetWindowToDefaults(register WindowPtr pWin)
 
     pWin->backingStore = NotUseful;
     pWin->DIXsaveUnder = FALSE;
-    pWin->backStorage = (pointer) NULL;
+    pWin->backStorage = (void *) NULL;
 
     pWin->mapped = FALSE;	    /* off */
     pWin->realized = FALSE;	/* off */
@@ -356,11 +356,11 @@ AllocateWindow(ScreenPtr pScreen)
 	{
 	    if ( (size = *sizes) )
 	    {
-		ppriv->ptr = (pointer)ptr;
+		ppriv->ptr = (void *)ptr;
 		ptr += size;
 	    }
 	    else
-		ppriv->ptr = (pointer)NULL;
+		ppriv->ptr = (void *)NULL;
 	}
     }
     return pWin;
@@ -454,7 +454,7 @@ CreateRootWindow(ScreenPtr pScreen)
     pWin->border.pixel = pScreen->blackPixel;
     pWin->borderWidth = 0;
 
-    if (!AddResource(pWin->drawable.id, RT_WINDOW, (pointer)pWin))
+    if (!AddResource(pWin->drawable.id, RT_WINDOW, (void *)pWin))
 	return FALSE;
 
     if (disableBackingStore)
@@ -879,7 +879,7 @@ CrushTree(WindowPtr pWin)
  *****/
 
 int
-DeleteWindow(pointer value, XID wid)
+DeleteWindow(void * value, XID wid)
  {
     register WindowPtr pParent;
     register WindowPtr pWin = (WindowPtr)value;
@@ -2525,7 +2525,7 @@ CirculateWindow(WindowPtr pParent, int direction, ClientPtr client)
 static int
 CompareWIDs(
     WindowPtr pWin,
-    pointer   value) /* must conform to VisitWindowProcPtr */
+    void *   value) /* must conform to VisitWindowProcPtr */
 {
     Window *wid = (Window *)value;
 
@@ -2550,7 +2550,7 @@ ReparentWindow(register WindowPtr pWin, register WindowPtr pParent,
     register ScreenPtr pScreen;
 
     pScreen = pWin->drawable.pScreen;
-    if (TraverseTree(pWin, CompareWIDs, (pointer)&pParent->drawable.id) == WT_STOPWALKING)
+    if (TraverseTree(pWin, CompareWIDs, (void *)&pParent->drawable.id) == WT_STOPWALKING)
 	return(BadMatch);		
     if (!MakeWindowOptional(pWin))
 	return(BadAlloc);
@@ -3483,7 +3483,7 @@ TileScreenSaver(int i, int kind)
 	if (cursor)
 	{
 	    cursorID = FakeClientID(0);
-	    if (AddResource (cursorID, RT_CURSOR, (pointer) cursor))
+	    if (AddResource (cursorID, RT_CURSOR, (void *) cursor))
 	    {
 		attributes[attri] = cursorID;
 		mask |= CWCursor;
@@ -3514,7 +3514,7 @@ TileScreenSaver(int i, int kind)
 	return FALSE;
 
     if (!AddResource(pWin->drawable.id, RT_WINDOW,
-		     (pointer)savedScreenInfo[i].pWindow))
+		     (void *)savedScreenInfo[i].pWindow))
 	return FALSE;
 
     if (mask & CWBackPixmap)
diff --git a/nx-X11/programs/Xserver/fb/fb.h b/nx-X11/programs/Xserver/fb/fb.h
index 3ee79d4af..202638d32 100644
--- a/nx-X11/programs/Xserver/fb/fb.h
+++ b/nx-X11/programs/Xserver/fb/fb.h
@@ -795,7 +795,7 @@ fb24_32ModifyPixmapHeader (PixmapPtr   pPixmap,
 			   int         depth,
 			   int         bitsPerPixel,
 			   int         devKind,
-			   pointer     pPixData);
+			   void        *pPixData);
 
 /*
  * fballpriv.c
@@ -1486,7 +1486,7 @@ fbPolyGlyphBlt (DrawablePtr	pDrawable,
 		int		y,
 		unsigned int	nglyph,
 		CharInfoPtr	*ppci,
-		pointer		pglyphBase);
+		void		*pglyphBase);
 
 void
 fbImageGlyphBlt (DrawablePtr	pDrawable,
@@ -1495,7 +1495,7 @@ fbImageGlyphBlt (DrawablePtr	pDrawable,
 		 int		y,
 		 unsigned int	nglyph,
 		 CharInfoPtr	*ppci,
-		 pointer	pglyphBase);
+		 void	        *pglyphBase);
 
 /*
  * fbimage.c
@@ -1732,7 +1732,7 @@ _fbSetWindowPixmap (WindowPtr pWindow, PixmapPtr pPixmap);
 
 Bool
 fbSetupScreen(ScreenPtr	pScreen, 
-	      pointer	pbits,		/* pointer to screen bitmap */
+	      void	*pbits,		/* pointer to screen bitmap */
 	      int	xsize, 		/* in pixels */
 	      int	ysize,
 	      int	dpix,		/* dots per inch */
@@ -1742,7 +1742,7 @@ fbSetupScreen(ScreenPtr	pScreen,
 
 Bool
 fbFinishScreenInit(ScreenPtr	pScreen,
-		   pointer	pbits,
+		   void		*pbits,
 		   int		xsize,
 		   int		ysize,
 		   int		dpix,
@@ -1752,7 +1752,7 @@ fbFinishScreenInit(ScreenPtr	pScreen,
 
 Bool
 fbScreenInit(ScreenPtr	pScreen,
-	     pointer	pbits,
+	     void	*pbits,
 	     int	xsize,
 	     int	ysize,
 	     int	dpix,
diff --git a/nx-X11/programs/Xserver/fb/fb24_32.c b/nx-X11/programs/Xserver/fb/fb24_32.c
index 214e2e6dd..68e0ef84d 100644
--- a/nx-X11/programs/Xserver/fb/fb24_32.c
+++ b/nx-X11/programs/Xserver/fb/fb24_32.c
@@ -571,7 +571,7 @@ fb24_32ReformatTile(PixmapPtr pOldTile, int bitsPerPixel)
 }
 
 typedef struct {
-    pointer pbits; 
+    void * pbits; 
     int width;   
 } miScreenInitParmsRec, *miScreenInitParmsPtr;
 
@@ -603,7 +603,7 @@ fb24_32ModifyPixmapHeader (PixmapPtr   pPixmap,
 			   int         depth,
 			   int         bitsPerPixel,
 			   int         devKind,
-			   pointer     pPixData)
+			   void        *pPixData)
 {
     int	    bpp, w;
 
diff --git a/nx-X11/programs/Xserver/fb/fb24_32.h b/nx-X11/programs/Xserver/fb/fb24_32.h
index 3c83f3423..023042025 100644
--- a/nx-X11/programs/Xserver/fb/fb24_32.h
+++ b/nx-X11/programs/Xserver/fb/fb24_32.h
@@ -32,7 +32,7 @@
 
 Bool
 fb24_32FinishScreenInit(ScreenPtr    pScreen,
-			pointer      pbits,
+			void         *pbits,
 			int          xsize,
 			int          ysize,
 			int          dpix,
@@ -42,7 +42,7 @@ fb24_32FinishScreenInit(ScreenPtr    pScreen,
 
 Bool
 fb24_32ScreenInit(ScreenPtr  pScreen,
-		  pointer    pbits,
+		  void       *pbits,
 		  int        xsize,
 		  int        ysize,
 		  int        dpix,
diff --git a/nx-X11/programs/Xserver/fb/fballpriv.c b/nx-X11/programs/Xserver/fb/fballpriv.c
index 75b577049..c1cd834f1 100644
--- a/nx-X11/programs/Xserver/fb/fballpriv.c
+++ b/nx-X11/programs/Xserver/fb/fballpriv.c
@@ -86,7 +86,7 @@ fbAllocatePrivates(ScreenPtr pScreen, int *pGCIndex)
 	pScreenPriv = (FbScreenPrivPtr) xalloc (sizeof (FbScreenPrivRec));
 	if (!pScreenPriv)
 	    return FALSE;
-	pScreen->devPrivates[fbScreenPrivateIndex].ptr = (pointer) pScreenPriv;
+	pScreen->devPrivates[fbScreenPrivateIndex].ptr = (void *) pScreenPriv;
     }
 #endif
     return TRUE;
diff --git a/nx-X11/programs/Xserver/fb/fbglyph.c b/nx-X11/programs/Xserver/fb/fbglyph.c
index 46334db50..bb0dda669 100644
--- a/nx-X11/programs/Xserver/fb/fbglyph.c
+++ b/nx-X11/programs/Xserver/fb/fbglyph.c
@@ -262,7 +262,7 @@ fbPolyGlyphBlt (DrawablePtr	pDrawable,
 		int		y,
 		unsigned int	nglyph,
 		CharInfoPtr	*ppci,
-		pointer		pglyphBase)
+		void *		pglyphBase)
 {
     FbGCPrivPtr	    pPriv = fbGetGCPrivate (pGC);
     CharInfoPtr	    pci;
@@ -350,7 +350,7 @@ fbImageGlyphBlt (DrawablePtr	pDrawable,
 		 int		y,
 		 unsigned int	nglyph,
 		 CharInfoPtr	*ppciInit,
-		 pointer	pglyphBase)
+		 void *	pglyphBase)
 {
     FbGCPrivPtr	    pPriv = fbGetGCPrivate(pGC);
     CharInfoPtr	    *ppci;
diff --git a/nx-X11/programs/Xserver/fb/fboverlay.c b/nx-X11/programs/Xserver/fb/fboverlay.c
index 87524e27e..81c54316f 100644
--- a/nx-X11/programs/Xserver/fb/fboverlay.c
+++ b/nx-X11/programs/Xserver/fb/fboverlay.c
@@ -64,7 +64,7 @@ fbOverlayCreateWindow(WindowPtr pWin)
 	pPixmap = pScrPriv->layer[i].u.run.pixmap;
 	if (pWin->drawable.depth == pPixmap->drawable.depth)
 	{
-	    pWin->devPrivates[fbWinPrivateIndex].ptr = (pointer) pPixmap;
+	    pWin->devPrivates[fbWinPrivateIndex].ptr = (void *) pPixmap;
 	    /*
 	     * Make sure layer keys are written correctly by
 	     * having non-root layers set to full while the
@@ -108,7 +108,7 @@ fbOverlayWindowLayer(WindowPtr pWin)
 
     for (i = 0; i < pScrPriv->nlayers; i++)
 	if (pWin->devPrivates[fbWinPrivateIndex].ptr ==
-	    (pointer) pScrPriv->layer[i].u.run.pixmap)
+	    (void *) pScrPriv->layer[i].u.run.pixmap)
 	    return i;
     return 0;
 }
@@ -119,7 +119,7 @@ fbOverlayCreateScreenResources(ScreenPtr pScreen)
     int			i;
     FbOverlayScrPrivPtr	pScrPriv = fbOverlayGetScrPriv(pScreen);
     PixmapPtr		pPixmap;
-    pointer		pbits;
+    void *		pbits;
     int			width;
     int			depth;
     BoxRec		box;
@@ -289,8 +289,8 @@ fbOverlayPaintWindow(WindowPtr pWin, RegionPtr pRegion, int what)
 
 Bool
 fbOverlaySetupScreen(ScreenPtr	pScreen,
-		     pointer	pbits1,
-		     pointer	pbits2,
+		     void *	pbits1,
+		     void *	pbits2,
 		     int	xsize,
 		     int	ysize,
 		     int	dpix,
@@ -336,8 +336,8 @@ fb24_32OverlayCreateScreenResources(ScreenPtr pScreen)
 
 Bool
 fbOverlayFinishScreenInit(ScreenPtr	pScreen,
-			  pointer	pbits1,
-			  pointer	pbits2,
+			  void *	pbits1,
+			  void *	pbits2,
 			  int		xsize,
 			  int		ysize,
 			  int		dpix,
@@ -436,7 +436,7 @@ fbOverlayFinishScreenInit(ScreenPtr	pScreen,
     pScrPriv->layer[1].u.init.width = width2;
     pScrPriv->layer[1].u.init.depth = depth2;
     
-    pScreen->devPrivates[fbOverlayScreenPrivateIndex].ptr = (pointer) pScrPriv;
+    pScreen->devPrivates[fbOverlayScreenPrivateIndex].ptr = (void *) pScrPriv;
     
     /* overwrite miCloseScreen with our own */
     pScreen->CloseScreen = fbOverlayCloseScreen;
diff --git a/nx-X11/programs/Xserver/fb/fboverlay.h b/nx-X11/programs/Xserver/fb/fboverlay.h
index e6a4e033f..d1469f22a 100644
--- a/nx-X11/programs/Xserver/fb/fboverlay.h
+++ b/nx-X11/programs/Xserver/fb/fboverlay.h
@@ -39,7 +39,7 @@ typedef	void	(*fbOverlayPaintKeyProc) (DrawablePtr, RegionPtr, CARD32, int);
 typedef struct _fbOverlayLayer {
     union {
 	struct {
-	    pointer	pbits;
+	    void *	pbits;
 	    int		width;
 	    int		depth;
 	} init;
@@ -100,8 +100,8 @@ fbOverlayPaintWindow(WindowPtr pWin, RegionPtr pRegion, int what);
 
 Bool
 fbOverlaySetupScreen(ScreenPtr	pScreen,
-		     pointer	pbits1,
-		     pointer	pbits2,
+		     void *	pbits1,
+		     void *	pbits2,
 		     int	xsize,
 		     int	ysize,
 		     int	dpix,
@@ -113,8 +113,8 @@ fbOverlaySetupScreen(ScreenPtr	pScreen,
 
 Bool
 fbOverlayFinishScreenInit(ScreenPtr	pScreen,
-			  pointer	pbits1,
-			  pointer	pbits2,
+			  void *	pbits1,
+			  void *	pbits2,
 			  int		xsize,
 			  int		ysize,
 			  int		dpix,
diff --git a/nx-X11/programs/Xserver/fb/fbpixmap.c b/nx-X11/programs/Xserver/fb/fbpixmap.c
index decc07ba6..7ea288cb1 100644
--- a/nx-X11/programs/Xserver/fb/fbpixmap.c
+++ b/nx-X11/programs/Xserver/fb/fbpixmap.c
@@ -73,7 +73,7 @@ fbCreatePixmapBpp (ScreenPtr pScreen, int width, int height, int depth, int bpp)
     pPixmap->drawable.height = height;
     pPixmap->devKind = paddedWidth;
     pPixmap->refcnt = 1;
-    pPixmap->devPrivate.ptr = (pointer) ((char *)pPixmap + base + adjust);
+    pPixmap->devPrivate.ptr = (void *) ((char *)pPixmap + base + adjust);
 #ifdef FB_DEBUG
     pPixmap->devPrivate.ptr = (void *) ((char *) pPixmap->devPrivate.ptr + paddedWidth);
     fbInitializeDrawable (&pPixmap->drawable);
diff --git a/nx-X11/programs/Xserver/fb/fbpseudocolor.c b/nx-X11/programs/Xserver/fb/fbpseudocolor.c
index ef40b7073..83d556a0e 100644
--- a/nx-X11/programs/Xserver/fb/fbpseudocolor.c
+++ b/nx-X11/programs/Xserver/fb/fbpseudocolor.c
@@ -20,7 +20,7 @@ static void xxValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDraw);
 static void xxDestroyGC(GCPtr pGC);
 static void xxChangeGC (GCPtr pGC, unsigned long   mask);
 static void xxCopyGC (GCPtr pGCSrc, unsigned long   mask, GCPtr pGCDst);
-static void xxChangeClip (GCPtr pGC, int type, pointer pvalue, int nrects);
+static void xxChangeClip (GCPtr pGC, int type, void * pvalue, int nrects);
 
 static void xxCopyClip(GCPtr pgcDst, GCPtr pgcSrc);
 static void xxDestroyClip(GCPtr pGC);
@@ -63,10 +63,10 @@ static void xxImageText16(DrawablePtr pDraw, GCPtr pGC, int x, int y,
 			  int count, unsigned short *chars);
 static void xxImageGlyphBlt(DrawablePtr pDraw, GCPtr pGC, int x, int y,
 			    unsigned int nglyph, CharInfoPtr *ppci,
-			    pointer pglyphBase);
+			    void * pglyphBase);
 static void xxPolyGlyphBlt(DrawablePtr pDraw, GCPtr pGC, int x, int y,
 			   unsigned int nglyph, CharInfoPtr *ppci,
-			   pointer pglyphBase);
+			   void * pglyphBase);
 static void xxPushPixels(GCPtr pGC, PixmapPtr pBitMap, DrawablePtr pDraw,
 			 int	dx, int dy, int xOrg, int yOrg);
 static void
@@ -108,7 +108,7 @@ typedef struct {
 #endif    
     PixmapPtr			pPixmap;
     char *			addr;
-    pointer			pBits;
+    void			*pBits;
     RegionRec			region;
     VisualPtr			bVisual;
     RegionRec			bRegion;
@@ -200,7 +200,7 @@ xxUpdateWindowImmediately(WindowPtr pWin)
 	    
     pmap = (ColormapPtr)LookupIDByType(wColormap(pWin),RT_COLORMAP);
     
-    if (pmap && (pCmapPriv = xxGetCmapPriv(pmap)) != (pointer)-1) {
+    if (pmap && (pCmapPriv = xxGetCmapPriv(pmap)) != (void *)-1) {
 	xxCopyPseudocolorRegion(pWin->drawable.pScreen,
 				&pScrPriv->region, pCmapPriv);
     }
@@ -259,7 +259,7 @@ xxCreateScreenResources(ScreenPtr pScreen)
     PixmapPtr		pPixmap;
     BoxRec		box;
     int			depth = pScrPriv->myDepth;
-    pointer		pBits;
+    void		*pBits;
     
     unwrap (pScrPriv,pScreen, CreateScreenResources);
     ret = pScreen->CreateScreenResources(pScreen);
@@ -364,16 +364,16 @@ xxInitColormapPrivate(ColormapPtr pmap)
 {
     xxScrPriv(pmap->pScreen);
     xxCmapPrivPtr	pCmapPriv;
-    pointer		cmap;
+    void		*cmap;
 
-    pmap->devPrivates[xxColormapPrivateIndex].ptr = (pointer) -1;
+    pmap->devPrivates[xxColormapPrivateIndex].ptr = (void *) -1;
     
     if (xxMyVisual(pmap->pScreen,pmap->pVisual->vid)) {
 	DBG("CreateColormap\n");
 	pCmapPriv = (xxCmapPrivPtr) xalloc (sizeof (xxCmapPrivRec));
 	if (!pCmapPriv)
 	    return FALSE;
-	pmap->devPrivates[xxColormapPrivateIndex].ptr = (pointer) pCmapPriv;
+	pmap->devPrivates[xxColormapPrivateIndex].ptr = (void *) pCmapPriv;
 	cmap = xalloc(sizeof (CARD32) * (1 << pScrPriv->myDepth));
 	if (!cmap)
 	return FALSE;
@@ -437,7 +437,7 @@ xxDestroyColormap(ColormapPtr pmap)
     xxScrPriv(pmap->pScreen);
     xxCmapPriv(pmap);
 
-    if (pCmapPriv != (pointer) -1) {
+    if (pCmapPriv != (void *) -1) {
 	xxCmapPrivPtr tmpCmapPriv = pScrPriv->Cmaps;
 	xxCmapPrivPtr *prevCmapPriv = &pScrPriv->Cmaps;
 	int n;
@@ -489,7 +489,7 @@ xxStoreColors(ColormapPtr pmap, int nColors, xColorItem *pColors)
     xxScrPriv(pmap->pScreen);
     xxCmapPriv(pmap);
 
-    if (pCmapPriv != (pointer) -1) {
+    if (pCmapPriv != (void *) -1) {
 
 	xColorItem	*expanddefs;
 	int		i;
@@ -547,7 +547,7 @@ xxInstallColormap(ColormapPtr pmap)
     xxScrPriv(pmap->pScreen);
     xxCmapPriv(pmap);
     
-    if (pCmapPriv != (pointer) -1) {
+    if (pCmapPriv != (void *) -1) {
 	Pixel		*pixels;
 	xrgb		*colors;
 	int		i;
@@ -619,7 +619,7 @@ xxUninstallColormap(ColormapPtr pmap)
     xxScrPriv(pmap->pScreen);
     xxCmapPriv(pmap);
 
-    if (pCmapPriv != (pointer) -1) {
+    if (pCmapPriv != (void *) -1) {
 	int num;
 	
 	if ((num = xxCmapInstalled(pmap)) == -1)
@@ -675,7 +675,7 @@ xxCreateWindow(WindowPtr pWin)
     
     DBG("CreateWindow\n");
 
-    pWin->devPrivates[fbWinPrivateIndex].ptr = (pointer) pScrPriv->pPixmap;
+    pWin->devPrivates[fbWinPrivateIndex].ptr = (void *) pScrPriv->pPixmap;
     PRINT_RECTS(pScrPriv->region);
 	if (!pWin->parent) {
 	REGION_EMPTY (pWin->drawable.pScreen, &pScrPriv->region);
@@ -962,15 +962,15 @@ xxGetWindowRegion(WindowPtr pWin,RegionPtr winreg)
 }
 
 static int
-xxUpdateRegion(WindowPtr pWin, pointer unused)
+xxUpdateRegion(WindowPtr pWin, void * unused)
 {
     ScreenPtr pScreen = pWin->drawable.pScreen;
     xxScrPriv(pScreen);
-    ColormapPtr pmap = (pointer) -1;
+    ColormapPtr pmap = (void *) -1;
     RegionRec		winreg, rgni;
     
     if (pScrPriv->myDepth == pWin->drawable.depth) {
-	xxCmapPrivPtr pCmapPriv = (pointer)-1;
+	xxCmapPrivPtr pCmapPriv = (void *)-1;
 	xxGetWindowRegion(pWin,&winreg);
 
 	if (pScrPriv->colormapDirty) {
@@ -980,7 +980,7 @@ xxUpdateRegion(WindowPtr pWin, pointer unused)
 		goto CONTINUE; /* return ? */
 
 	    pCmapPriv = xxGetCmapPriv(pmap);
-	    if (pCmapPriv == (pointer) -1)
+	    if (pCmapPriv == (void *) -1)
 		return WT_WALKCHILDREN;
 	    if (!pCmapPriv->dirty)
 		goto CONTINUE;
@@ -997,7 +997,7 @@ xxUpdateRegion(WindowPtr pWin, pointer unused)
 	REGION_INTERSECT (pScreen, &rgni, &winreg, &pScrPriv->region);
 	
 	if (REGION_NOTEMPTY (pScreen,&rgni)) {
-	    if (pmap == (pointer) -1) {
+	    if (pmap == (void *) -1) {
 		pmap =
 		    (ColormapPtr)LookupIDByType(wColormap(pWin),RT_COLORMAP);
 		if (!pmap) /* return ? */
@@ -1006,7 +1006,7 @@ xxUpdateRegion(WindowPtr pWin, pointer unused)
 		pCmapPriv = xxGetCmapPriv(pmap);
 	    }
 	    
-	    if (pCmapPriv != (pointer)-1)
+	    if (pCmapPriv != (void *)-1)
 		xxCopyPseudocolorRegion(pScreen,&rgni, pCmapPriv);
 	    REGION_SUBTRACT(pScreen, &pScrPriv->region, &pScrPriv->region,
 			    &rgni);
@@ -1034,13 +1034,13 @@ xxUpdateFb(ScreenPtr pScreen)
     WalkTree(pScreen,xxUpdateRegion,NULL);
 #if 0
     if (REGION_NOTEMPTY (pScreen,&pScrPriv->region)) {
-	ColormapPtr pmap = (pointer) -1;
+	ColormapPtr pmap = (void *) -1;
 	xxCmapPrivPtr pCmapPriv;
 	
 	pmap = (ColormapPtr)LookupIDByType(pScreen->defColormap,
 					   RT_COLORMAP);
 	pCmapPriv = xxGetCmapPriv(pmap);
-	if (pCmapPriv != (pointer)-1)
+	if (pCmapPriv != (void *)-1)
 	    xxCopyPseudocolorRegion(pScreen,&pScrPriv->region, pCmapPriv);
 	REGION_SUBTRACT(pScreen, &pScrPriv->region, &pScrPriv->region,
 			&pScrPriv->region);
@@ -1064,9 +1064,9 @@ xxUpdateFb(ScreenPtr pScreen)
 }
 
 static void
-xxBlockHandler (pointer	data,
+xxBlockHandler (void *	data,
 		OSTimePtr pTimeout,
-		pointer pRead)
+		void * pRead)
 {
     ScreenPtr	pScreen = (ScreenPtr) data;
     xxScrPriv(pScreen);
@@ -1076,7 +1076,7 @@ xxBlockHandler (pointer	data,
 }
 
 static void
-xxWakeupHandler (pointer data, int i, pointer LastSelectMask)
+xxWakeupHandler (void * data, int i, void * LastSelectMask)
 {
 }
 
@@ -1158,7 +1158,7 @@ xxSetup(ScreenPtr pScreen, int myDepth, int baseDepth, char* addr, xxSyncFunc sy
     
     if (!RegisterBlockAndWakeupHandlers (xxBlockHandler,
 					 xxWakeupHandler,
-					 (pointer) pScreen))
+					 (void *) pScreen))
 	return FALSE;
 
     wrap (pScrPriv, pScreen, CloseScreen, xxCloseScreen);
@@ -1184,7 +1184,7 @@ xxSetup(ScreenPtr pScreen, int myDepth, int baseDepth, char* addr, xxSyncFunc sy
     }
 #endif
     pScrPriv->addr = addr;
-    pScreen->devPrivates[xxScrPrivateIndex].ptr = (pointer) pScrPriv;
+    pScreen->devPrivates[xxScrPrivateIndex].ptr = (void *) pScrPriv;
 
     pDefMap = (ColormapPtr) LookupIDByType(pScreen->defColormap, RT_COLORMAP);
     if (!xxInitColormapPrivate(pDefMap))
@@ -1341,7 +1341,7 @@ static void
 xxChangeClip (
     GCPtr   pGC,
     int		type,
-    pointer	pvalue,
+    void *	pvalue,
     int		nrects 
 ){
     XX_GC_FUNC_PROLOGUE (pGC);
@@ -2114,7 +2114,7 @@ xxImageGlyphBlt(
     int x, int y,
     unsigned int nglyph,
     CharInfoPtr *ppci,
-    pointer pglyphBase 
+    void * pglyphBase 
 ){
     XX_GC_OP_PROLOGUE(pGC, pDraw);
     (*pGC->ops->ImageGlyphBlt)(pDraw, pGC, x, y, nglyph, 
@@ -2162,7 +2162,7 @@ xxPolyGlyphBlt(
     int x, int y,
     unsigned int nglyph,
     CharInfoPtr *ppci,
-    pointer pglyphBase 
+    void * pglyphBase 
 ){
     XX_GC_OP_PROLOGUE(pGC, pDraw);
     (*pGC->ops->PolyGlyphBlt)(pDraw, pGC, x, y, nglyph, 
diff --git a/nx-X11/programs/Xserver/fb/fbscreen.c b/nx-X11/programs/Xserver/fb/fbscreen.c
index 70d3d7a13..342fd5784 100644
--- a/nx-X11/programs/Xserver/fb/fbscreen.c
+++ b/nx-X11/programs/Xserver/fb/fbscreen.c
@@ -97,14 +97,14 @@ _fbSetWindowPixmap (WindowPtr pWindow, PixmapPtr pPixmap)
 #ifdef FB_NO_WINDOW_PIXMAPS
     FatalError ("Attempted to set window pixmap without fb support\n");
 #else
-    pWindow->devPrivates[fbWinPrivateIndex].ptr = (pointer) pPixmap;
+    pWindow->devPrivates[fbWinPrivateIndex].ptr = (void *) pPixmap;
 #endif
 }
 #endif
 
 Bool
 fbSetupScreen(ScreenPtr	pScreen, 
-	      pointer	pbits,		/* pointer to screen bitmap */
+	      void *	pbits,		/* pointer to screen bitmap */
 	      int	xsize, 		/* in pixels */
 	      int	ysize,
 	      int	dpix,		/* dots per inch */
@@ -160,7 +160,7 @@ fbSetupScreen(ScreenPtr	pScreen,
 
 Bool
 fbFinishScreenInit(ScreenPtr	pScreen,
-		   pointer	pbits,
+		   void *	pbits,
 		   int		xsize,
 		   int		ysize,
 		   int		dpix,
@@ -261,7 +261,7 @@ fbFinishScreenInit(ScreenPtr	pScreen,
 /* dts * (inch/dot) * (25.4 mm / inch) = mm */
 Bool
 fbScreenInit(ScreenPtr	pScreen,
-	     pointer	pbits,
+	     void *	pbits,
 	     int	xsize,
 	     int	ysize,
 	     int	dpix,
diff --git a/nx-X11/programs/Xserver/fb/fbwindow.c b/nx-X11/programs/Xserver/fb/fbwindow.c
index 0cfefa929..1269902b9 100644
--- a/nx-X11/programs/Xserver/fb/fbwindow.c
+++ b/nx-X11/programs/Xserver/fb/fbwindow.c
@@ -38,7 +38,7 @@ fbCreateWindow(WindowPtr pWin)
 {
 #ifndef FB_NO_WINDOW_PIXMAPS
     pWin->devPrivates[fbWinPrivateIndex].ptr = 
-	(pointer) fbGetScreenPixmap(pWin->drawable.pScreen);
+	(void *) fbGetScreenPixmap(pWin->drawable.pScreen);
 #endif
 #ifdef FB_SCREEN_PRIVATE
     if (pWin->drawable.bitsPerPixel == 32)
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Colormap.c b/nx-X11/programs/Xserver/hw/nxagent/Colormap.c
index fbe52db9c..3a47e270e 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Colormap.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Colormap.c
@@ -77,7 +77,7 @@ Bool nxagentCreateColormap(ColormapPtr pCmap)
   pVisual = pCmap->pVisual;
   ncolors = pVisual->ColormapEntries;
 
-  pCmap->devPriv = (pointer)xalloc(sizeof(nxagentPrivColormap));
+  pCmap->devPriv = (void *)xalloc(sizeof(nxagentPrivColormap));
 
   if (((visual = nxagentVisual(pVisual))) == NULL)
   {
@@ -174,7 +174,7 @@ void nxagentDestroyColormap(ColormapPtr pCmap)
 #define SEARCH_PREDICATE \
   (nxagentWindow(pWin) != None && wColormap(pWin) == icws->cmapIDs[i])
 
-static int nxagentCountInstalledColormapWindows(WindowPtr pWin, pointer ptr)
+static int nxagentCountInstalledColormapWindows(WindowPtr pWin, void * ptr)
 {
   nxagentInstalledColormapWindows *icws = (nxagentInstalledColormapWindows *) ptr;
 
@@ -189,7 +189,7 @@ static int nxagentCountInstalledColormapWindows(WindowPtr pWin, pointer ptr)
   return WT_WALKCHILDREN;
 }
 
-static int nxagentGetInstalledColormapWindows(WindowPtr pWin, pointer ptr)
+static int nxagentGetInstalledColormapWindows(WindowPtr pWin, void * ptr)
 {
   nxagentInstalledColormapWindows *icws = (nxagentInstalledColormapWindows *)ptr;
   int i;
@@ -233,11 +233,11 @@ void nxagentSetInstalledColormapWindows(ScreenPtr pScreen)
 				    sizeof(Colormap));
   icws.numCmapIDs = nxagentListInstalledColormaps(pScreen, icws.cmapIDs);
   icws.numWindows = 0;
-  WalkTree(pScreen, nxagentCountInstalledColormapWindows, (pointer)&icws);
+  WalkTree(pScreen, nxagentCountInstalledColormapWindows, (void *)&icws);
   if (icws.numWindows) {
     icws.windows = (Window *)xalloc((icws.numWindows + 1) * sizeof(Window));
     icws.index = 0;
-    WalkTree(pScreen, nxagentGetInstalledColormapWindows, (pointer)&icws);
+    WalkTree(pScreen, nxagentGetInstalledColormapWindows, (void *)&icws);
     icws.windows[icws.numWindows] = nxagentDefaultWindows[pScreen->myNum];
     numWindows = icws.numWindows + 1;
   }
@@ -388,10 +388,10 @@ void nxagentInstallColormap(ColormapPtr pCmap)
 
       /* Uninstall pInstalledMap. Notify all interested parties. */
       if(pOldCmap != (ColormapPtr)None)
-	WalkTree(pCmap->pScreen, TellLostMap, (pointer)&pOldCmap->mid);
+	WalkTree(pCmap->pScreen, TellLostMap, (void *)&pOldCmap->mid);
 
       InstalledMaps[index] = pCmap;
-      WalkTree(pCmap->pScreen, TellGainedMap, (pointer)&pCmap->mid);
+      WalkTree(pCmap->pScreen, TellGainedMap, (void *)&pCmap->mid);
 
       nxagentSetInstalledColormapWindows(pCmap->pScreen);
       nxagentDirectInstallColormaps(pCmap->pScreen);
@@ -542,7 +542,7 @@ Bool nxagentCreateDefaultColormap(ScreenPtr pScreen)
   return True;
 }
 
-static void nxagentReconnectColormap(pointer p0, XID x1, pointer p2)
+static void nxagentReconnectColormap(void * p0, XID x1, void * p2)
 {
   ColormapPtr pCmap = (ColormapPtr)p0;
   Bool* pBool = (Bool*)p2;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Cursor.c b/nx-X11/programs/Xserver/hw/nxagent/Cursor.c
index 9d48aa134..c0015a831 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Cursor.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Cursor.c
@@ -231,7 +231,7 @@ Bool nxagentRealizeCursor(ScreenPtr pScreen, CursorPtr pCursor)
   bg_color.green = pCursor->backGreen;
   bg_color.blue = pCursor->backBlue;
 
-  pCursor->devPriv[pScreen->myNum] = (pointer) xalloc(sizeof(nxagentPrivCursor));
+  pCursor->devPriv[pScreen->myNum] = (void *) xalloc(sizeof(nxagentPrivCursor));
 
   nxagentCursorPriv(pCursor, pScreen)->cursor =
          XCreatePixmapCursor(nxagentDisplay, source, mask, &fg_color,
@@ -311,7 +311,7 @@ Bool nxagentSetCursorPosition(ScreenPtr pScreen, int x, int y,
   }
 }
 
-void nxagentReconnectCursor(pointer p0, XID x1, pointer p2)
+void nxagentReconnectCursor(void * p0, XID x1, void * p2)
 {
   Bool* pBool = (Bool*)p2;
   CursorPtr pCursor = (CursorPtr) p0;
@@ -433,7 +433,7 @@ Bool nxagentReconnectAllCursor(void *p0)
   return r;
 }
 
-void nxagentDisconnectCursor(pointer p0, XID x1, pointer p2)
+void nxagentDisconnectCursor(void * p0, XID x1, void * p2)
 {
   Bool* pBool = (Bool *) p2;
   CursorPtr pCursor = (CursorPtr) p0;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Cursor.h b/nx-X11/programs/Xserver/hw/nxagent/Cursor.h
index 88dea2686..38f09cd9c 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Cursor.h
+++ b/nx-X11/programs/Xserver/hw/nxagent/Cursor.h
@@ -100,8 +100,8 @@ Bool nxagentSetCursorPosition(ScreenPtr pScreen, int x, int y,
 extern Bool (*nxagentSetCursorPositionW)(ScreenPtr pScreen, int x, int y,
                                              Bool generateEvent);
 
-void nxagentDisconnectCursor(pointer p0, XID x1, pointer p2);
-void nxagentReconnectCursor(pointer p0, XID x1, pointer p2);
+void nxagentDisconnectCursor(void * p0, XID x1, void * p2);
+void nxagentReconnectCursor(void * p0, XID x1, void * p2);
 void nxagentReDisplayCurrentCursor(void);
 Bool nxagentReconnectAllCursor(void *p0);
 Bool nxagentDisconnectAllCursor(void);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Drawable.c b/nx-X11/programs/Xserver/hw/nxagent/Drawable.c
index f2225996b..34781e816 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Drawable.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Drawable.c
@@ -106,7 +106,7 @@ void nxagentExposeBackgroundPredicate(void *p0, XID x1, void *p2);
  * Imported from NXresource.c
  */
 
-extern int nxagentFindClientResource(int, RESTYPE, pointer);
+extern int nxagentFindClientResource(int, RESTYPE, void *);
 
 unsigned long nxagentGetColor(DrawablePtr pDrawable, int xPixel, int yPixel);
 unsigned long nxagentGetDrawableColor(DrawablePtr pDrawable);
@@ -2391,7 +2391,7 @@ void nxagentFillRemoteRegion(DrawablePtr pDrawable, RegionPtr pRegion)
   }
 }
 
-int nxagentDestroyCorruptedWindowResource(pointer p, XID id)
+int nxagentDestroyCorruptedWindowResource(void * p, XID id)
 {
   #ifdef TEST
   fprintf(stderr, "nxagentDestroyCorruptedWindowResource: Removing corrupted window [%p] from resources.\n",
@@ -2403,7 +2403,7 @@ int nxagentDestroyCorruptedWindowResource(pointer p, XID id)
   return 1;
 }
 
-int nxagentDestroyCorruptedPixmapResource(pointer p, XID id)
+int nxagentDestroyCorruptedPixmapResource(void * p, XID id)
 {
   #ifdef TEST
   fprintf(stderr, "nxagentDestroyCorruptedPixmapResource: Removing corrupted pixmap [%p] from resources.\n",
@@ -2415,7 +2415,7 @@ int nxagentDestroyCorruptedPixmapResource(pointer p, XID id)
   return 1;
 }
 
-int nxagentDestroyCorruptedBackgroundResource(pointer p, XID id)
+int nxagentDestroyCorruptedBackgroundResource(void * p, XID id)
 {
   #ifdef TEST
   fprintf(stderr, "nxagentDestroyCorruptedBackgroundResource: Removing corrupted pixmap background [%p] from resources.\n",
@@ -2842,7 +2842,7 @@ void nxagentAllocateCorruptedResource(DrawablePtr pDrawable, RESTYPE type)
       nxagentWindowPriv((WindowPtr) pDrawable) -> corruptedId = FakeClientID(serverClient -> index);
 
       AddResource(nxagentWindowPriv((WindowPtr) pDrawable) -> corruptedId, RT_NX_CORR_WINDOW,
-                      (pointer) pDrawable);
+                      (void *) pDrawable);
     }
   }
   else if (type == RT_NX_CORR_BACKGROUND)
@@ -2869,7 +2869,7 @@ void nxagentAllocateCorruptedResource(DrawablePtr pDrawable, RESTYPE type)
       nxagentPixmapPriv(pRealPixmap) -> corruptedBackgroundId = FakeClientID(serverClient -> index);
 
       AddResource(nxagentPixmapPriv(pRealPixmap) -> corruptedBackgroundId, RT_NX_CORR_BACKGROUND,
-                      (pointer) pRealPixmap);
+                      (void *) pRealPixmap);
     }
   }
   else if (type == RT_NX_CORR_PIXMAP)
@@ -2896,7 +2896,7 @@ void nxagentAllocateCorruptedResource(DrawablePtr pDrawable, RESTYPE type)
         nxagentPixmapPriv(pRealPixmap) -> corruptedId = FakeClientID(serverClient -> index);
 
         AddResource(nxagentPixmapPriv(pRealPixmap) -> corruptedId, RT_NX_CORR_PIXMAP,
-                        (pointer) pRealPixmap);
+                        (void *) pRealPixmap);
       }
     }
   }
@@ -3204,7 +3204,7 @@ void nxagentExposeBackgroundPredicate(void *p0, XID x1, void *p2)
  * This function is similar to nxagentClipAndSendExpose().
  */
 
-int nxagentClipAndSendClearExpose(WindowPtr pWin, pointer ptr)
+int nxagentClipAndSendClearExpose(WindowPtr pWin, void * ptr)
 {
   RegionPtr exposeRgn;
   RegionPtr remoteExposeRgn;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Drawable.h b/nx-X11/programs/Xserver/hw/nxagent/Drawable.h
index c987fa119..4ebbc928e 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Drawable.h
+++ b/nx-X11/programs/Xserver/hw/nxagent/Drawable.h
@@ -182,9 +182,9 @@ extern void nxagentFillRemoteRegion(DrawablePtr pDrawable, RegionPtr pRegion);
 
 extern void nxagentAllocateCorruptedResource(DrawablePtr pDrawable, RESTYPE type);
 extern void nxagentDestroyCorruptedResource(DrawablePtr pDrawable, RESTYPE type);
-extern int nxagentDestroyCorruptedBackgroundResource(pointer p, XID id);
-extern int nxagentDestroyCorruptedWindowResource(pointer p, XID id);
-extern int nxagentDestroyCorruptedPixmapResource(pointer p, XID id);
+extern int nxagentDestroyCorruptedBackgroundResource(void * p, XID id);
+extern int nxagentDestroyCorruptedWindowResource(void * p, XID id);
+extern int nxagentDestroyCorruptedPixmapResource(void * p, XID id);
 
 extern void nxagentCreateDrawableBitmap(DrawablePtr pDrawable);
 extern void nxagentDestroyDrawableBitmap(DrawablePtr pDrawable);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Events.c b/nx-X11/programs/Xserver/hw/nxagent/Events.c
index be5dd9032..c33564092 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Events.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Events.c
@@ -218,7 +218,7 @@ RegionPtr nxagentRemoteExposeRegion = NULL;
 
 static void nxagentForwardRemoteExpose(void);
 
-static int nxagentClipAndSendExpose(WindowPtr pWin, pointer ptr);
+static int nxagentClipAndSendExpose(WindowPtr pWin, void * ptr);
 
 /*
  * This is from NXproperty.c.
@@ -778,7 +778,7 @@ void nxagentGetEventMask(WindowPtr pWin, Mask *mask_return)
   *mask_return = mask;
 }
 
-static int nxagentChangeMapPrivate(WindowPtr pWin, pointer ptr)
+static int nxagentChangeMapPrivate(WindowPtr pWin, void * ptr)
 {
   if (pWin && nxagentWindowPriv(pWin))
   {
@@ -788,7 +788,7 @@ static int nxagentChangeMapPrivate(WindowPtr pWin, pointer ptr)
   return WT_WALKCHILDREN;
 }
 
-static int nxagentChangeVisibilityPrivate(WindowPtr pWin, pointer ptr)
+static int nxagentChangeVisibilityPrivate(WindowPtr pWin, void * ptr)
 {
   if (pWin && nxagentWindowPriv(pWin))
   {
@@ -4276,7 +4276,7 @@ void nxagentAddRectToRemoteExposeRegion(BoxPtr rect)
   REGION_UNINIT(nxagentDefaultScreen, &exposeRegion);
 }
 
-int nxagentClipAndSendExpose(WindowPtr pWin, pointer ptr)
+int nxagentClipAndSendExpose(WindowPtr pWin, void * ptr)
 {
   RegionPtr exposeRgn;
   RegionPtr remoteExposeRgn;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Font.c b/nx-X11/programs/Xserver/hw/nxagent/Font.c
index 5becb2cff..9123f4bbe 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Font.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Font.c
@@ -103,7 +103,7 @@ is" without express or implied warranty.
 static int reconnectFlexibility;
 
 static void nxagentCleanCacheAfterReconnect(void);
-static void nxagentFontReconnect(FontPtr, XID, pointer);
+static void nxagentFontReconnect(FontPtr, XID, void *);
 static XFontStruct *nxagentLoadBestQueryFont(Display* dpy, char *fontName, FontPtr pFont);
 static XFontStruct *nxagentLoadQueryFont(register Display *dpy , char *fontName , FontPtr pFont);
 int nxagentFreeFont(XFontStruct *fs);
@@ -486,7 +486,7 @@ Bool nxagentFontLookUp(const char *name)
 
 Bool nxagentRealizeFont(ScreenPtr pScreen, FontPtr pFont)
 {
-  pointer priv;
+  void * priv;
   Atom name_atom, value_atom;
   int nprops;
   FontPropPtr props;
@@ -538,7 +538,7 @@ Bool nxagentRealizeFont(ScreenPtr pScreen, FontPtr pFont)
      name = origName;
   }
 
-  priv = (pointer)xalloc(sizeof(nxagentPrivFont));
+  priv = (void *)xalloc(sizeof(nxagentPrivFont));
   FontSetPrivate(pFont, nxagentFontPrivateIndex, priv);
 
   nxagentFontPriv(pFont) -> mirrorID = 0;
@@ -693,7 +693,7 @@ Bool nxagentUnrealizeFont(ScreenPtr pScreen, FontPtr pFont)
   return True;
 }
 
-int nxagentDestroyNewFontResourceType(pointer p, XID id)
+int nxagentDestroyNewFontResourceType(void * p, XID id)
 {
   #ifdef TEST
   fprintf(stderr, "nxagentDestroyNewFontResourceType: Destroying mirror id [%ld] for font at [%p].\n",
@@ -858,7 +858,7 @@ static XFontStruct *nxagentLoadBestQueryFont(Display* dpy, char *fontName, FontP
   return fontStruct;
 }
 
-static void nxagentFontDisconnect(FontPtr pFont, XID param1, pointer param2)
+static void nxagentFontDisconnect(FontPtr pFont, XID param1, void * param2)
 {
   nxagentPrivFont *privFont;
   Bool *pBool = (Bool*)param2;
@@ -959,7 +959,7 @@ static void nxagentCollectFailedFont(FontPtr fpt, XID id)
   nxagentFailedToReconnectFonts.index++;
 }
 
-static void nxagentFontReconnect(FontPtr pFont, XID param1, pointer param2)
+static void nxagentFontReconnect(FontPtr pFont, XID param1, void * param2)
 {
   int i;
   nxagentPrivFont *privFont;
@@ -1164,7 +1164,7 @@ Bool nxagentReconnectAllFonts(void *p0)
   return fontSuccess;
 }
 
-static void nxagentFailedFontReconnect(FontPtr pFont, XID param1, pointer param2)
+static void nxagentFailedFontReconnect(FontPtr pFont, XID param1, void * param2)
 {
   int i;
   nxagentPrivFont *privFont;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Font.h b/nx-X11/programs/Xserver/hw/nxagent/Font.h
index d3ee2b0da..873efba51 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Font.h
+++ b/nx-X11/programs/Xserver/hw/nxagent/Font.h
@@ -65,7 +65,7 @@ int nxagentFontLookUp(const char *name);
 Bool nxagentFontFind(const char *name, int *pos);
 void nxagentListRemoteAddName(const char *name, int status);
 
-int nxagentDestroyNewFontResourceType(pointer p, XID id);
+int nxagentDestroyNewFontResourceType(void * p, XID id);
 
 Bool nxagentDisconnectAllFonts(void);
 Bool nxagentReconnectAllFonts(void *p0);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/GC.c b/nx-X11/programs/Xserver/hw/nxagent/GC.c
index ec51bbedc..808220346 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/GC.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/GC.c
@@ -75,7 +75,7 @@ void nxagentDisconnectGraphicContexts(void);
 GCPtr nxagentCreateGraphicContext(int depth);
 
 static void nxagentReconnectGC(void*, XID, void*);
-static void nxagentReconnectClip(GCPtr, int, pointer, int);
+static void nxagentReconnectClip(GCPtr, int, void *, int);
 static int  nxagentCompareRegions(RegionPtr, RegionPtr);
 
 struct nxagentGCRec
@@ -198,7 +198,7 @@ Bool nxagentCreateGC(GCPtr pGC)
 
   nxagentGCPriv(pGC) -> pPixmap = NULL;
 
-  AddResource(nxagentGCPriv(pGC) -> mid, RT_NX_GC, (pointer) pGC);
+  AddResource(nxagentGCPriv(pGC) -> mid, RT_NX_GC, (void *) pGC);
 
   return True;
 }
@@ -602,7 +602,7 @@ void nxagentDestroyGC(GCPtr pGC)
   miDestroyGC(pGC);
 }
 
-void nxagentChangeClip(GCPtr pGC, int type, pointer pValue, int nRects)
+void nxagentChangeClip(GCPtr pGC, int type, void * pValue, int nRects)
 {
   int i, size;
   BoxPtr pBox;
@@ -699,7 +699,7 @@ void nxagentChangeClip(GCPtr pGC, int type, pointer pValue, int nRects)
                          nxagentPixmap((PixmapPtr)pValue));
       }
 
-      pGC->clientClip = (pointer) (*pGC->pScreen->BitmapToRegion)((PixmapPtr) pValue);
+      pGC->clientClip = (void *) (*pGC->pScreen->BitmapToRegion)((PixmapPtr) pValue);
 
       nxagentGCPriv(pGC)->pPixmap = (PixmapPtr)pValue;
 
@@ -768,7 +768,7 @@ void nxagentChangeClip(GCPtr pGC, int type, pointer pValue, int nRects)
        * CT_REGION client clips.
        */
 
-      pGC->clientClip = (pointer) RECTS_TO_REGION(pGC->pScreen, nRects,
+      pGC->clientClip = (void *) RECTS_TO_REGION(pGC->pScreen, nRects,
                                                   (xRectangle *)pValue, type);
       xfree(pValue);
 
@@ -987,7 +987,7 @@ static void nxagentRestoreGCList()
   }
 }
 
-int nxagentDestroyNewGCResourceType(pointer p, XID id)
+int nxagentDestroyNewGCResourceType(void * p, XID id)
 {
   /*
    * Address of the destructor is set in Init.c.
@@ -1003,7 +1003,7 @@ int nxagentDestroyNewGCResourceType(pointer p, XID id)
   return 1;
 }
 
-static void nxagentReconnectGC(void *param0, XID param1, pointer param2)
+static void nxagentReconnectGC(void *param0, XID param1, void * param2)
 {
   XGCValues values;
   unsigned long valuemask;
@@ -1188,7 +1188,7 @@ Bool nxagentReconnectAllGCs(void *p0)
   return GCSuccess;
 }
 
-void nxagentDisconnectGC(pointer p0, XID x1, pointer p2)
+void nxagentDisconnectGC(void * p0, XID x1, void * p2)
 {
   GCPtr pGC = (GCPtr) p0;
   Bool* pBool = (Bool*) p2;
@@ -1255,7 +1255,7 @@ Bool nxagentDisconnectAllGCs()
   return success;
 }
 
-static void nxagentReconnectClip(GCPtr pGC, int type, pointer pValue, int nRects)
+static void nxagentReconnectClip(GCPtr pGC, int type, void * pValue, int nRects)
 {
   int i, size;
   BoxPtr pBox;
@@ -1320,7 +1320,7 @@ static void nxagentReconnectClip(GCPtr pGC, int type, pointer pValue, int nRects
 
       XSetClipOrigin(nxagentDisplay, nxagentGC(pGC), pGC -> clipOrg.x, pGC -> clipOrg.y);
 
-      pGC->clientClip = (pointer) (*pGC->pScreen->BitmapToRegion)((PixmapPtr) pValue);
+      pGC->clientClip = (void *) (*pGC->pScreen->BitmapToRegion)((PixmapPtr) pValue);
 
       nxagentGCPriv(pGC)->pPixmap = (PixmapPtr)pValue;
 
@@ -1370,7 +1370,7 @@ static void nxagentReconnectClip(GCPtr pGC, int type, pointer pValue, int nRects
        * CT_PIXMAP and CT_REGION client clips.
        */
 
-      pGC->clientClip = (pointer) RECTS_TO_REGION(pGC->pScreen, nRects,
+      pGC->clientClip = (void *) RECTS_TO_REGION(pGC->pScreen, nRects,
                                                   (xRectangle *)pValue, type);
       xfree(pValue);
       pValue = pGC->clientClip;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/GCOps.c b/nx-X11/programs/Xserver/hw/nxagent/GCOps.c
index c489d12c4..25f5fa6d7 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/GCOps.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/GCOps.c
@@ -2042,7 +2042,7 @@ void nxagentImageText16(DrawablePtr pDrawable, GCPtr pGC, int x,
 
 void nxagentImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
                               unsigned int nGlyphs, CharInfoPtr *pCharInfo,
-                                  pointer pGlyphBase)
+                                  void * pGlyphBase)
 {
   if ((pDrawable)->type == DRAWABLE_PIXMAP)
   {
@@ -2061,7 +2061,7 @@ void nxagentImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
 
 void nxagentPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
                              unsigned int nGlyphs, CharInfoPtr *pCharInfo,
-                                 pointer pGlyphBase)
+                                 void * pGlyphBase)
 {
   if ((pDrawable)->type == DRAWABLE_PIXMAP)
   {
diff --git a/nx-X11/programs/Xserver/hw/nxagent/GCOps.h b/nx-X11/programs/Xserver/hw/nxagent/GCOps.h
index fa4967aee..725b382c5 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/GCOps.h
+++ b/nx-X11/programs/Xserver/hw/nxagent/GCOps.h
@@ -93,10 +93,10 @@ void nxagentImageText16(DrawablePtr pDrawable, GCPtr pGC, int x,
                             int y, int count, unsigned short *string);
 
 void nxagentImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
-                              unsigned int nGlyphs, CharInfoPtr *pCharInfo, pointer pGlyphBase);
+                              unsigned int nGlyphs, CharInfoPtr *pCharInfo, void * pGlyphBase);
 
 void nxagentPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
-                             unsigned int nGlyphs, CharInfoPtr *pCharInfo, pointer pGlyphBase);
+                             unsigned int nGlyphs, CharInfoPtr *pCharInfo, void * pGlyphBase);
 
 void nxagentPushPixels(GCPtr pGC, PixmapPtr pBitmap, DrawablePtr pDrawable,
                            int width, int height, int x, int y);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/GCs.h b/nx-X11/programs/Xserver/hw/nxagent/GCs.h
index f7e13477a..bbd090dcc 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/GCs.h
+++ b/nx-X11/programs/Xserver/hw/nxagent/GCs.h
@@ -87,17 +87,17 @@ void nxagentValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDrawable);
 void nxagentChangeGC(GCPtr pGC, unsigned long mask);
 void nxagentCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst);
 void nxagentDestroyGC(GCPtr pGC);
-void nxagentChangeClip(GCPtr pGC, int type, pointer pValue, int nRects);
+void nxagentChangeClip(GCPtr pGC, int type, void * pValue, int nRects);
 void nxagentDestroyClip(GCPtr pGC);
 void nxagentDestroyClipHelper(GCPtr pGC);
 void nxagentCopyClip(GCPtr pGCDst, GCPtr pGCSrc);
 
-void nxagentDisconnectGC(pointer p0, XID x1, pointer p2);
+void nxagentDisconnectGC(void * p0, XID x1, void * p2);
 Bool nxagentDisconnectAllGCs(void);
 
 Bool nxagentReconnectAllGCs(void *p0);
 
-int nxagentDestroyNewGCResourceType(pointer p, XID id);
+int nxagentDestroyNewGCResourceType(void * p, XID id);
 
 void nxagentFreeGCList(void);
 void nxagentInitGCSafeVector(void);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Handlers.c b/nx-X11/programs/Xserver/hw/nxagent/Handlers.c
index 1fc6bbf8b..0396a458e 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Handlers.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Handlers.c
@@ -161,7 +161,7 @@ struct _DispatchRec nxagentDispatch = { UNDEFINED, 0, 0, 0 };
 
 extern int nxagentSkipImage;
 
-void nxagentBlockHandler(pointer data, struct timeval **timeout, pointer mask)
+void nxagentBlockHandler(void * data, struct timeval **timeout, void * mask)
 {
   /*
    * Zero timeout.
@@ -569,7 +569,7 @@ void nxagentBlockHandler(pointer data, struct timeval **timeout, pointer mask)
   #endif
 }
 
-void nxagentWakeupHandler(pointer data, int count, pointer mask)
+void nxagentWakeupHandler(void * data, int count, void * mask)
 {
   #ifdef BLOCKS
   fprintf(stderr, "[Begin wakeup]\n");
@@ -723,7 +723,7 @@ void nxagentWakeupHandler(pointer data, int count, pointer mask)
   #endif
 }
 
-void nxagentShadowBlockHandler(pointer data, struct timeval **timeout, pointer mask)
+void nxagentShadowBlockHandler(void * data, struct timeval **timeout, void * mask)
 {
   static struct timeval zero;
 
@@ -851,7 +851,7 @@ FIXME: Must queue multiple writes and handle
   #endif
 }
 
-void nxagentShadowWakeupHandler(pointer data, int count, pointer mask)
+void nxagentShadowWakeupHandler(void * data, int count, void * mask)
 {
   #ifdef BLOCKS
   fprintf(stderr, "[Begin wakeup]\n");
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Handlers.h b/nx-X11/programs/Xserver/hw/nxagent/Handlers.h
index 3d3b335c0..0ef8b9ac2 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Handlers.h
+++ b/nx-X11/programs/Xserver/hw/nxagent/Handlers.h
@@ -100,8 +100,8 @@ extern struct _TokensRec nxagentTokens;
  * The agent's block and wakeup handlers.
  */
 
-void nxagentBlockHandler(pointer data, struct timeval **timeout, pointer mask);
-void nxagentWakeupHandler(pointer data, int count, pointer mask);
+void nxagentBlockHandler(void * data, struct timeval **timeout, void * mask);
+void nxagentWakeupHandler(void * data, int count, void * mask);
 
 /*
  * Executed after each request processed.
@@ -109,8 +109,8 @@ void nxagentWakeupHandler(pointer data, int count, pointer mask);
 
 void nxagentDispatchHandler(ClientPtr client, int in, int out);
 
-void nxagentShadowBlockHandler(pointer data, struct timeval **timeout, pointer mask);
-void nxagentShadowWakeupHandler(pointer data, int count, pointer mask);
+void nxagentShadowBlockHandler(void * data, struct timeval **timeout, void * mask);
+void nxagentShadowWakeupHandler(void * data, int count, void * mask);
 
 extern GCPtr nxagentShadowGCPtr;
 extern unsigned char nxagentShadowDepth;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Init.c b/nx-X11/programs/Xserver/hw/nxagent/Init.c
index 3722800ff..0b25aa57d 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Init.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Init.c
@@ -132,8 +132,8 @@ void OsVendorEndRedirectErrorFFunction();
  */
 
 
-static void nxagentGrabServerCallback(CallbackListPtr *callbacks, pointer data,
-                                   pointer args);
+static void nxagentGrabServerCallback(CallbackListPtr *callbacks, void *data,
+                                   void *args);
 
 void ddxInitGlobals(void)
 {
@@ -398,7 +398,7 @@ void InitInput(argc, argv)
      int argc;
      char *argv[];
 {
-  pointer ptr, kbd;
+  void *ptr, *kbd;
 
   ptr = AddInputDevice(nxagentPointerProc, True);
   kbd = AddInputDevice(nxagentKeyboardProc, True);
@@ -530,8 +530,8 @@ int SelectWaitTime = 10000; /* usec */
 
 ServerGrabInfoRec nxagentGrabServerInfo;
 
-static void nxagentGrabServerCallback(CallbackListPtr *callbacks, pointer data,
-                                   pointer args)
+static void nxagentGrabServerCallback(CallbackListPtr *callbacks, void *data,
+                                   void *args)
 {
     ServerGrabInfoRec *grab = (ServerGrabInfoRec*)args;
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c b/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c
index 9c89b555f..835aebeb6 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c
@@ -571,7 +571,7 @@ static char *nxagentXkbGetRules()
   return XKB_DFLT_RULES_FILE;
 }
  
-void nxagentBell(int volume, DeviceIntPtr pDev, pointer ctrl, int cls)
+void nxagentBell(int volume, DeviceIntPtr pDev, void * ctrl, int cls)
 {
   XBell(nxagentDisplay, volume);
 }
@@ -978,7 +978,7 @@ XkbError:
           #endif
 
           XkbSetRulesDflts(rules, model, layout, variants, options);
-          XkbInitKeyboardDeviceStruct((pointer)pDev, &names, &keySyms, modmap,
+          XkbInitKeyboardDeviceStruct((void *)pDev, &names, &keySyms, modmap,
                                           nxagentBell, nxagentChangeKeyboardControl);
 
           if (!nxagentKeyboard ||
@@ -1068,7 +1068,7 @@ XkbError:
           #endif
 
           XkbSetRulesDflts(rules, model, layout, variants, options);
-          XkbInitKeyboardDeviceStruct((pointer)pDev, &names, &keySyms, modmap,
+          XkbInitKeyboardDeviceStruct((void *)pDev, &names, &keySyms, modmap,
                                           nxagentBell, nxagentChangeKeyboardControl);
 
           free(nxagentXkbConfigFilePath);
@@ -1087,9 +1087,9 @@ XkbError:
         #endif
 
         XkbSetRulesDflts(rules, model, layout, variants, options);
-        XkbInitKeyboardDeviceStruct((pointer)pDev, &names, &keySyms, modmap,
+        XkbInitKeyboardDeviceStruct((void *)pDev, &names, &keySyms, modmap,
                                     nxagentBell, nxagentChangeKeyboardControl);
-        XkbDDXChangeControls((pointer)pDev, xkb->ctrls, xkb->ctrls);
+        XkbDDXChangeControls((void *)pDev, xkb->ctrls, xkb->ctrls);
 
 XkbEnd:
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Keyboard.h b/nx-X11/programs/Xserver/hw/nxagent/Keyboard.h
index 12d953d93..036eec57f 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Keyboard.h
+++ b/nx-X11/programs/Xserver/hw/nxagent/Keyboard.h
@@ -89,7 +89,7 @@ extern char *nxagentKeyboard;
  * and utility functions.
  */
 
-void nxagentBell(int volume, DeviceIntPtr pDev, pointer ctrl, int cls);
+void nxagentBell(int volume, DeviceIntPtr pDev, void * ctrl, int cls);
 
 int nxagentKeyboardProc(DeviceIntPtr pDev, int onoff);
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXdamage.c b/nx-X11/programs/Xserver/hw/nxagent/NXdamage.c
index cf5d48ba2..06f2de57c 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXdamage.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXdamage.c
@@ -344,7 +344,7 @@ static void damageValidateGC(GCPtr, unsigned long, DrawablePtr);
 static void damageChangeGC(GCPtr, unsigned long);
 static void damageCopyGC(GCPtr, unsigned long, GCPtr);
 static void damageDestroyGC(GCPtr);
-static void damageChangeClip(GCPtr, int, pointer, int);
+static void damageChangeClip(GCPtr, int, void *, int);
 static void damageDestroyClip(GCPtr);
 static void damageCopyClip(GCPtr, GCPtr);
 
@@ -457,7 +457,7 @@ damageCopyGC (GCPtr	    pGCSrc,
 static void
 damageChangeClip (GCPtr	    pGC,
 		  int	    type,
-		  pointer   pvalue,
+		  void      *pvalue,
 		  int	    nrects)
 {
     DAMAGE_GC_FUNC_PROLOGUE (pGC);
@@ -1560,7 +1560,7 @@ damageImageGlyphBlt(DrawablePtr	    pDrawable,
 		    int		    y,
 		    unsigned int    nglyph,
 		    CharInfoPtr	    *ppci,
-		    pointer	    pglyphBase)
+		    void	    *pglyphBase)
 {
     DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
     damageDamageChars (pDrawable, pGC->font, x + pDrawable->x, y + pDrawable->y,
@@ -1577,7 +1577,7 @@ damagePolyGlyphBlt(DrawablePtr	pDrawable,
 		   int		y,
 		   unsigned int	nglyph,
 		   CharInfoPtr	*ppci,
-		   pointer	pglyphBase)
+		   void		*pglyphBase)
 {
     DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
     damageDamageChars (pDrawable, pGC->font, x + pDrawable->x, y + pDrawable->y,
@@ -1908,7 +1908,7 @@ DamageSetup (ScreenPtr pScreen)
     }
 #endif
 
-    pScreen->devPrivates[damageScrPrivateIndex].ptr = (pointer) pScrPriv;
+    pScreen->devPrivates[damageScrPrivateIndex].ptr = (void *) pScrPriv;
     return TRUE;
 }
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c b/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c
index ea4f59d19..af76ed4c2 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c
@@ -245,7 +245,7 @@ extern WindowPtr nxagentViewportFrameBelow;
 
 extern int nxagentMaxAllowedResets;
 
-extern int nxagentFindClientResource(int, RESTYPE, pointer);
+extern int nxagentFindClientResource(int, RESTYPE, void *);
 
 static ClientPtr grabClient;
 #define GrabNone 0
@@ -883,7 +883,7 @@ ProcCreateWindow(ClientPtr client)
 	Mask mask = pWin->eventMask;
 
 	pWin->eventMask = 0; /* subterfuge in case AddResource fails */
-	if (!AddResource(stuff->wid, RT_WINDOW, (pointer)pWin))
+	if (!AddResource(stuff->wid, RT_WINDOW, (void *)pWin))
 	    return BadAlloc;
 	pWin->eventMask = mask;
     }
@@ -1573,7 +1573,7 @@ ProcGrabServer(register ClientPtr client)
 	ServerGrabInfoRec grabinfo;
 	grabinfo.client = client;
 	grabinfo.grabstate  = SERVER_GRABBED;
-	CallCallbacks(&ServerGrabCallback, (pointer)&grabinfo);
+	CallCallbacks(&ServerGrabCallback, (void *)&grabinfo);
     }
 
     return(client->noClientException);
@@ -1602,7 +1602,7 @@ UngrabServer(ClientPtr client)
 	ServerGrabInfoRec grabinfo;
 	grabinfo.client = client;
 	grabinfo.grabstate  = SERVER_UNGRABBED;
-	CallCallbacks(&ServerGrabCallback, (pointer)&grabinfo);
+	CallCallbacks(&ServerGrabCallback, (void *)&grabinfo);
     }
 }
 
@@ -1966,7 +1966,7 @@ ProcListFontsWithInfo(register ClientPtr client)
  *  \param value must conform to DeleteType
  */
 int
-dixDestroyPixmap(pointer value, XID pid)
+dixDestroyPixmap(void * value, XID pid)
 {
     PixmapPtr pPixmap = (PixmapPtr)value;
     return (*pPixmap->drawable.pScreen->DestroyPixmap)(pPixmap);
@@ -2025,7 +2025,7 @@ CreatePmap:
     {
 	pMap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
 	pMap->drawable.id = stuff->pid;
-	if (AddResource(stuff->pid, RT_PIXMAP, (pointer)pMap))
+	if (AddResource(stuff->pid, RT_PIXMAP, (void *)pMap))
 	    return(client->noClientException);
     }
     return (BadAlloc);
@@ -2108,7 +2108,7 @@ ProcCreateGC(register ClientPtr client)
 			 (XID *) &stuff[1], &error);
     if (error != Success)
         return error;
-    if (!AddResource(stuff->gc, RT_GC, (pointer)pGC))
+    if (!AddResource(stuff->gc, RT_GC, (void *)pGC))
 	return (BadAlloc);
     return(client->noClientException);
 }
@@ -2798,7 +2798,7 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
 				         nlines,
 				         format,
 				         planemask,
-				         (pointer) pBuf);
+				         (void *) pBuf);
 #ifdef XCSECURITY
 	    if (pVisibleRegion)
 		SecurityCensorImage(client, pVisibleRegion, widthBytesLine,
@@ -2839,7 +2839,7 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
 				                 nlines,
 				                 format,
 				                 plane,
-				                 (pointer)pBuf);
+				                 (void *)pBuf);
 #ifdef XCSECURITY
 		    if (pVisibleRegion)
 			SecurityCensorImage(client, pVisibleRegion,
@@ -3669,7 +3669,7 @@ ProcCreateCursor (register ClientPtr client)
     /* zeroing the (pad) bits helps some ddx cursor handling */
     bzero((char *)srcbits, n);
     (* src->drawable.pScreen->GetImage)( (DrawablePtr)src, 0, 0, width, height,
-					 XYPixmap, 1, (pointer)srcbits);
+					 XYPixmap, 1, (void *)srcbits);
     if ( msk == (PixmapPtr)NULL)
     {
 	register unsigned char *bits = mskbits;
@@ -3681,7 +3681,7 @@ ProcCreateCursor (register ClientPtr client)
 	/* zeroing the (pad) bits helps some ddx cursor handling */
 	bzero((char *)mskbits, n);
 	(* msk->drawable.pScreen->GetImage)( (DrawablePtr)msk, 0, 0, width,
-					height, XYPixmap, 1, (pointer)mskbits);
+					height, XYPixmap, 1, (void *)mskbits);
     }
     cm.width = width;
     cm.height = height;
@@ -3691,7 +3691,7 @@ ProcCreateCursor (register ClientPtr client)
 	    stuff->foreRed, stuff->foreGreen, stuff->foreBlue,
 	    stuff->backRed, stuff->backGreen, stuff->backBlue);
 
-    if (pCursor && AddResource(stuff->cid, RT_CURSOR, (pointer)pCursor))
+    if (pCursor && AddResource(stuff->cid, RT_CURSOR, (void *)pCursor))
     {
         #ifdef TEST
         fprintf(stderr, "ProcCreateCursor: Created cursor at [%p].\n", (void *) pCursor);
@@ -3721,7 +3721,7 @@ ProcCreateGlyphCursor (register ClientPtr client)
 			   &pCursor, client);
     if (res != Success)
 	return res;
-    if (AddResource(stuff->cid, RT_CURSOR, (pointer)pCursor))
+    if (AddResource(stuff->cid, RT_CURSOR, (void *)pCursor))
 	return client->noClientException;
     return BadAlloc;
 }
@@ -3908,10 +3908,10 @@ ProcChangeHosts(register ClientPtr client)
 
     if(stuff->mode == HostInsert)
 	result = AddHost(client, (int)stuff->hostFamily,
-			 stuff->hostLength, (pointer)&stuff[1]);
+			 stuff->hostLength, (void *)&stuff[1]);
     else if (stuff->mode == HostDelete)
 	result = RemoveHost(client, (int)stuff->hostFamily, 
-			    stuff->hostLength, (pointer)&stuff[1]);  
+			    stuff->hostLength, (void *)&stuff[1]);  
     else
     {
 	client->errorValue = stuff->mode;
@@ -3927,7 +3927,7 @@ ProcListHosts(register ClientPtr client)
 {
     xListHostsReply reply;
     int	len, nHosts, result;
-    pointer	pdata;
+    void *	pdata;
     /* REQUEST(xListHostsReq); */
 
     REQUEST_SIZE_MATCH(xListHostsReq);
@@ -4222,7 +4222,7 @@ CloseDownClient(register ClientPtr client)
 		clientinfo.client = client; 
 		clientinfo.prefix = (xConnSetupPrefix *)NULL;  
 		clientinfo.setup = (xConnSetup *) NULL;
-		CallCallbacks((&ClientStateCallback), (pointer)&clientinfo);
+		CallCallbacks((&ClientStateCallback), (void *)&clientinfo);
             } 
 	}
 	client->clientGone = TRUE;  /* so events aren't sent to client */
@@ -4259,7 +4259,7 @@ CloseDownClient(register ClientPtr client)
 	    clientinfo.client = client; 
 	    clientinfo.prefix = (xConnSetupPrefix *)NULL;  
 	    clientinfo.setup = (xConnSetup *) NULL;
-	    CallCallbacks((&ClientStateCallback), (pointer)&clientinfo);
+	    CallCallbacks((&ClientStateCallback), (void *)&clientinfo);
 	} 	    
 	FreeClientResources(client);
 	if (client->index < nextFreeClientID)
@@ -4309,7 +4309,7 @@ CloseDownRetainedResources()
     }
 }
 
-void InitClient(ClientPtr client, int i, pointer ospriv)
+void InitClient(ClientPtr client, int i, void * ospriv)
 {
     client->index = i;
     client->sequence = 0; 
@@ -4399,11 +4399,11 @@ InitClientPrivates(ClientPtr client)
     {
 	if ( (size = *sizes) )
 	{
-	    ppriv->ptr = (pointer)ptr;
+	    ppriv->ptr = (void *)ptr;
 	    ptr += size;
 	}
 	else
-	    ppriv->ptr = (pointer)NULL;
+	    ppriv->ptr = (void *)NULL;
     }
 
     /*
@@ -4422,7 +4422,7 @@ InitClientPrivates(ClientPtr client)
  * Returns NULL if there are no free clients.
  *************************/
 
-ClientPtr NextAvailableClient(pointer ospriv)
+ClientPtr NextAvailableClient(void * ospriv)
 {
     register int i;
     register ClientPtr client;
@@ -4460,7 +4460,7 @@ ClientPtr NextAvailableClient(pointer ospriv)
         clientinfo.client = client; 
         clientinfo.prefix = (xConnSetupPrefix *)NULL;  
         clientinfo.setup = (xConnSetup *) NULL;
-	CallCallbacks((&ClientStateCallback), (pointer)&clientinfo);
+	CallCallbacks((&ClientStateCallback), (void *)&clientinfo);
     } 	
     return(client);
 }
@@ -4595,7 +4595,7 @@ SendConnSetup(register ClientPtr client, char *reason)
         clientinfo.client = client; 
         clientinfo.prefix = lconnSetupPrefix;  
         clientinfo.setup = (xConnSetup *)lConnectionInfo;
-	CallCallbacks((&ClientStateCallback), (pointer)&clientinfo);
+	CallCallbacks((&ClientStateCallback), (void *)&clientinfo);
     } 	
     return (client->noClientException);
 }
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c b/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c
index 828b9bf4c..4f41ee228 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c
@@ -177,7 +177,7 @@ _NXGetFontPathError:
 
 #define QUERYCHARINFO(pci, pr)  *(pr) = (pci)->metrics
 
-extern pointer fosNaturalParams;
+extern void * fosNaturalParams;
 extern FontPtr defaultFont;
 
 static FontPathElementPtr *font_path_elements = (FontPathElementPtr *) 0;
@@ -291,7 +291,7 @@ RemoveFontWakeup(FontPathElementPtr fpe)
 }
 
 void
-FontWakeup(pointer data, int count, pointer LastSelectMask)
+FontWakeup(void * data, int count, void * LastSelectMask)
 {
     int         i;
     FontPathElementPtr fpe;
@@ -381,7 +381,7 @@ doOpenFont(ClientPtr client, OFclosurePtr c)
 	if (c->current_fpe < c->num_fpes)
 	{
 	    fpe = c->fpe_list[c->current_fpe];
-	    (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+	    (*fpe_functions[fpe->type].client_died) ((void *) client, fpe);
 	}
 	err = Successful;
 	goto bail;
@@ -389,7 +389,7 @@ doOpenFont(ClientPtr client, OFclosurePtr c)
     while (c->current_fpe < c->num_fpes) {
 	fpe = c->fpe_list[c->current_fpe];
 	err = (*fpe_functions[fpe->type].open_font)
-	    ((pointer) client, fpe, c->flags,
+	    ((void *) client, fpe, c->flags,
 	     c->fontname, c->fnamelen, FontFormat,
 	     BitmapFormatMaskByte |
 	     BitmapFormatMaskBit |
@@ -423,7 +423,7 @@ doOpenFont(ClientPtr client, OFclosurePtr c)
 	if (err == Suspended) {
 	    if (!c->slept) {
 		c->slept = TRUE;
-		ClientSleep(client, (ClientSleepProcPtr)doOpenFont, (pointer) c);
+		ClientSleep(client, (ClientSleepProcPtr)doOpenFont, (void *) c);
 #ifdef NXAGENT_DEBUG
                 fprintf(stderr, " NXdixfonts: doOpenFont: client [%lx] sleeping.\n", client);
 #endif
@@ -469,7 +469,7 @@ doOpenFont(ClientPtr client, OFclosurePtr c)
 	    }
 	}
     }
-    if (!AddResource(c->fontid, RT_FONT, (pointer) pfont)) {
+    if (!AddResource(c->fontid, RT_FONT, (void *) pfont)) {
 	err = AllocError;
 	goto bail;
     }
@@ -478,7 +478,7 @@ doOpenFont(ClientPtr client, OFclosurePtr c)
       extern RESTYPE RT_NX_FONT;
 
       nxagentFontPriv(pfont) -> mirrorID = FakeClientID(0);
-      if (!AddResource(nxagentFontPriv(pfont) -> mirrorID, RT_NX_FONT, (pointer) pfont)) {
+      if (!AddResource(nxagentFontPriv(pfont) -> mirrorID, RT_NX_FONT, (void *) pfont)) {
         FreeResource(c->fontid, RT_NONE);
         err = AllocError;
         goto bail;
@@ -548,7 +548,7 @@ OpenFont(ClientPtr client, XID fid, Mask flags, unsigned lenfname, char *pfontna
 	cached = FindCachedFontPattern(patternCache, pfontname, lenfname);
 	if (cached && cached->info.cachable)
 	{
-	    if (!AddResource(fid, RT_FONT, (pointer) cached))
+	    if (!AddResource(fid, RT_FONT, (void *) cached))
 		return BadAlloc;
 	    cached->refcnt++;
 	    return Success;
@@ -599,7 +599,7 @@ OpenFont(ClientPtr client, XID fid, Mask flags, unsigned lenfname, char *pfontna
  *  \param value must conform to DeleteType
  */
 int
-CloseFont(pointer value, XID fid)
+CloseFont(void * value, XID fid)
 {
     int         nscr;
     ScreenPtr   pscr;
@@ -730,7 +730,7 @@ doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
 	if (c->current.current_fpe < c->num_fpes)
 	{
 	    fpe = c->fpe_list[c->current.current_fpe];
-	    (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+	    (*fpe_functions[fpe->type].client_died) ((void *) client, fpe);
 	}
 	err = Successful;
 	goto bail;
@@ -748,7 +748,7 @@ doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
 	    /* This FPE doesn't support/require list_fonts_and_aliases */
 
 	    err = (*fpe_functions[fpe->type].list_fonts)
-		((pointer) c->client, fpe, c->current.pattern,
+		((void *) c->client, fpe, c->current.pattern,
 		 c->current.patlen, c->current.max_names - c->names->nnames,
 		 c->names);
 
@@ -757,7 +757,7 @@ doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
 		    c->slept = TRUE;
 		    ClientSleep(client,
 			(ClientSleepProcPtr)doListFontsAndAliases,
-			(pointer) c);
+			(void *) c);
 #ifdef NXAGENT_DEBUG
                     fprintf(stderr, " NXdixfonts: doListFont (1): client [%lx] sleeping.\n", client);
 #endif
@@ -780,14 +780,14 @@ doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
 
 	    if (!c->current.list_started) {
 		err = (*fpe_functions[fpe->type].start_list_fonts_and_aliases)
-		    ((pointer) c->client, fpe, c->current.pattern,
+		    ((void *) c->client, fpe, c->current.pattern,
 		     c->current.patlen, c->current.max_names - c->names->nnames,
 		     &c->current.private);
 		if (err == Suspended) {
 		    if (!c->slept) {
 			ClientSleep(client,
 				    (ClientSleepProcPtr)doListFontsAndAliases,
-				    (pointer) c);
+				    (void *) c);
 			c->slept = TRUE;
 		    }
 		    return TRUE;
@@ -799,13 +799,13 @@ doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
 		char    *tmpname;
 		name = 0;
 		err = (*fpe_functions[fpe->type].list_next_font_or_alias)
-		    ((pointer) c->client, fpe, &name, &namelen, &tmpname,
+		    ((void *) c->client, fpe, &name, &namelen, &tmpname,
 		     &resolvedlen, c->current.private);
 		if (err == Suspended) {
 		    if (!c->slept) {
 			ClientSleep(client,
 				    (ClientSleepProcPtr)doListFontsAndAliases,
-				    (pointer) c);
+				    (void *) c);
 			c->slept = TRUE;
 #ifdef NXAGENT_DEBUG
                         fprintf(stderr, " NXdixfonts: doListFont (2): client [%lx] sleeping.\n", client);
@@ -859,7 +859,7 @@ doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
 
 		    tmpname = 0;
 		    (void) (*fpe_functions[fpe->type].list_next_font_or_alias)
-			((pointer) c->client, fpe, &tmpname, &tmpnamelen,
+			((void *) c->client, fpe, &tmpname, &tmpnamelen,
 			 &tmpname, &tmpnamelen, c->current.private);
 		    if (--aliascount <= 0)
 		    {
@@ -1070,7 +1070,7 @@ doListFontsWithInfo(ClientPtr client, LFWIclosurePtr c)
 	if (c->current.current_fpe < c->num_fpes)
  	{
 	    fpe = c->fpe_list[c->current.current_fpe];
-	    (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+	    (*fpe_functions[fpe->type].client_died) ((void *) client, fpe);
 	}
 	err = Successful;
 	goto bail;
@@ -1361,7 +1361,7 @@ doPolyText(ClientPtr client, register PTclosurePtr c)
     if (client->clientGone)
     {
 	fpe = c->pGC->font->fpe;
-	(*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+	(*fpe_functions[fpe->type].client_died) ((void *) client, fpe);
 
 	if (c->slept)
 	{
@@ -1389,7 +1389,7 @@ doPolyText(ClientPtr client, register PTclosurePtr c)
 	   the FPE code to clean up after client and avoid further
 	   rendering while we clean up after ourself.  */
 	fpe = c->pGC->font->fpe;
-	(*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+	(*fpe_functions[fpe->type].client_died) ((void *) client, fpe);
 	c->pDraw = (DrawablePtr)0;
     }
 
@@ -1558,7 +1558,7 @@ doPolyText(ClientPtr client, register PTclosurePtr c)
 		    c->slept = TRUE;
 		    ClientSleep(client,
 		    	     (ClientSleepProcPtr)doPolyText,
-			     (pointer) c);
+			     (void *) c);
 #ifdef NXAGENT_DEBUG
                     fprintf(stderr, " NXdixfonts: doPolyText (1): client [%lx] sleeping.\n", client);
 #endif
@@ -1670,7 +1670,7 @@ doImageText(ClientPtr client, register ITclosurePtr c)
     if (client->clientGone)
     {
 	fpe = c->pGC->font->fpe;
-	(*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+	(*fpe_functions[fpe->type].client_died) ((void *) client, fpe);
 	err = Success;
 	goto bail;
     }
@@ -1684,7 +1684,7 @@ doImageText(ClientPtr client, register ITclosurePtr c)
 	/* Our drawable has disappeared.  Treat like client died... ask
 	   the FPE code to clean up after client. */
 	fpe = c->pGC->font->fpe;
-	(*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+	(*fpe_functions[fpe->type].client_died) ((void *) client, fpe);
 	err = Success;
 	goto bail;
     }
@@ -1756,7 +1756,7 @@ doImageText(ClientPtr client, register ITclosurePtr c)
 	    ValidateGC(c->pDraw, c->pGC);
 
 	    c->slept = TRUE;
-            ClientSleep(client, (ClientSleepProcPtr)doImageText, (pointer) c);
+            ClientSleep(client, (ClientSleepProcPtr)doImageText, (void *) c);
 #ifdef NXAGENT_DEBUG
             fprintf(stderr, " NXdixfonts: doImageText (1): client [%lx] sleeping.\n", client);
 #endif
@@ -2115,7 +2115,7 @@ DeleteClientFontStuff(ClientPtr client)
     {
 	fpe = font_path_elements[i];
 	if (fpe_functions[fpe->type].client_died)
-	    (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+	    (*fpe_functions[fpe->type].client_died) ((void *) client, fpe);
     }
 }
 
@@ -2255,7 +2255,7 @@ GetNewFontClientID()
 int
 StoreFontClientFont(FontPtr pfont, Font id)
 {
-    return AddResource(id, RT_NONE, (pointer) pfont);
+    return AddResource(id, RT_NONE, (void *) pfont);
 }
 
 void
@@ -2288,7 +2288,7 @@ init_fs_handlers(FontPathElementPtr fpe, BlockHandlerProcPtr block_handler)
 #endif
 
 	if (!RegisterBlockAndWakeupHandlers(block_handler,
-					    FontWakeup, (pointer) 0))
+					    FontWakeup, (void *) 0))
 	    return AllocError;
 	fs_handlers_installed++;
     }
@@ -2308,7 +2308,7 @@ remove_fs_handlers(FontPathElementPtr fpe, BlockHandlerProcPtr block_handler, Bo
 #endif
 
 	    RemoveBlockAndWakeupHandlers(block_handler, FontWakeup,
-					 (pointer) 0);
+					 (void *) 0);
 	}
     }
     RemoveFontWakeup(fpe);
@@ -2339,7 +2339,7 @@ dump_char_ascii(CharInfoPtr cip)
 
     bpr = GLYPH_SIZE(cip, 4);
     for (r = 0; r < (cip->metrics.ascent + cip->metrics.descent); r++) {
-	pointer     row = (pointer) cip->bits + r * bpr;
+	void *     row = (void *) cip->bits + r * bpr;
 
 	byte = 0;
 	for (l = 0; l <= (cip->metrics.rightSideBearing -
@@ -2386,7 +2386,7 @@ nxdoListFontsAndAliases(client, fss)
 	if (c->current.current_fpe < c->num_fpes)
 	{
 	    fpe = c->fpe_list[c->current.current_fpe];
-	    (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+	    (*fpe_functions[fpe->type].client_died) ((void *) client, fpe);
 	}
 	err = Successful;
 	goto bail;
@@ -2404,7 +2404,7 @@ nxdoListFontsAndAliases(client, fss)
 	    /* This FPE doesn't support/require list_fonts_and_aliases */
 
 	    err = (*fpe_functions[fpe->type].list_fonts)
-		((pointer) c->client, fpe, c->current.pattern,
+		((void *) c->client, fpe, c->current.pattern,
 		 c->current.patlen, c->current.max_names - c->names->nnames,
 		 c->names);
 
@@ -2413,7 +2413,7 @@ nxdoListFontsAndAliases(client, fss)
 		    c->slept = TRUE;
 		    ClientSleep(client,
 			(ClientSleepProcPtr)nxdoListFontsAndAliases,
-			(pointer) fss);
+			(void *) fss);
 #ifdef NXAGENT_DEBUG
                     fprintf(stderr, " NXdixfonts: nxdoListFont (1): client [%lx] sleeping.\n", client);
 #endif
@@ -2436,14 +2436,14 @@ nxdoListFontsAndAliases(client, fss)
 
 	    if (!c->current.list_started) {
 		err = (*fpe_functions[fpe->type].start_list_fonts_and_aliases)
-		    ((pointer) c->client, fpe, c->current.pattern,
+		    ((void *) c->client, fpe, c->current.pattern,
 		     c->current.patlen, c->current.max_names - c->names->nnames,
 		     &c->current.private);
 		if (err == Suspended) {
 		    if (!c->slept) {
 			ClientSleep(client,
 				    (ClientSleepProcPtr)nxdoListFontsAndAliases,
-				    (pointer) fss);
+				    (void *) fss);
 			c->slept = TRUE;
 #ifdef NXAGENT_DEBUG
                         fprintf(stderr, " NXdixfonts: nxdoListFont (2): client [%lx] sleeping.\n", client);
@@ -2458,13 +2458,13 @@ nxdoListFontsAndAliases(client, fss)
 		char    *tmpname;
 		name = 0;
 		err = (*fpe_functions[fpe->type].list_next_font_or_alias)
-		    ((pointer) c->client, fpe, &name, &namelen, &tmpname,
+		    ((void *) c->client, fpe, &name, &namelen, &tmpname,
 		     &resolvedlen, c->current.private);
 		if (err == Suspended) {
 		    if (!c->slept) {
 			ClientSleep(client,
 				    (ClientSleepProcPtr)nxdoListFontsAndAliases,
-				    (pointer) fss);
+				    (void *) fss);
 			c->slept = TRUE;
 #ifdef NXAGENT_DEBUG
                         fprintf(stderr, " NXdixfonts: nxdoListFont (3): client [%lx] sleeping.\n", client);
@@ -2529,7 +2529,7 @@ nxdoListFontsAndAliases(client, fss)
 
 		    tmpname = 0;
 		    (void) (*fpe_functions[fpe->type].list_next_font_or_alias)
-			((pointer) c->client, fpe, &tmpname, &tmpnamelen,
+			((void *) c->client, fpe, &tmpname, &tmpnamelen,
 			 &tmpname, &tmpnamelen, c->current.private);
 		    if (--aliascount <= 0)
 		    {
@@ -2694,7 +2694,7 @@ nxOpenFont(client, fid, flags, lenfname, pfontname)
 	cached = FindCachedFontPattern(patternCache, pfontname, lenfname);
 	if (cached && cached->info.cachable)
 	{
-	    if (!AddResource(fid, RT_FONT, (pointer) cached))
+	    if (!AddResource(fid, RT_FONT, (void *) cached))
 		return BadAlloc;
 	    cached->refcnt++;
 	    return Success;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXevents.c b/nx-X11/programs/Xserver/hw/nxagent/NXevents.c
index 872a02ce5..5940fe7d1 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXevents.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXevents.c
@@ -1112,7 +1112,7 @@ EnqueueEvent(xEvent *xE, DeviceIntPtr device, int count)
 		WindowTable[sprite.hotPhys.pScreen->myNum]->drawable.id;
 	eventinfo.events = xE;
 	eventinfo.count = count;
-	CallCallbacks(&DeviceEventCallback, (pointer)&eventinfo);
+	CallCallbacks(&DeviceEventCallback, (void *)&eventinfo);
     }
     if (xE->u.u.type == MotionNotify)
     {
@@ -2783,7 +2783,7 @@ CheckPassiveGrabsOnWindow(
 a passive grab to be activated.  If the event is a keyboard event, the
 ancestors of the focus window are traced down and tried to see if they have
 any passive grabs to be activated.  If the focus window itself is reached and
-it's descendants contain they pointer, the ancestors of the window that the
+its descendants contain the pointer, the ancestors of the window that the
 pointer is in are then traced down starting at the focus window, otherwise no
 grabs are activated.  If the event is a pointer event, the ancestors of the
 window that the pointer is in are traced down starting at the root until
@@ -3008,7 +3008,7 @@ drawable.id:0;
 	    DeviceEventInfoRec eventinfo;
 	    eventinfo.events = xE;
 	    eventinfo.count = count;
-	    CallCallbacks(&DeviceEventCallback, (pointer)&eventinfo);
+	    CallCallbacks(&DeviceEventCallback, (void *)&eventinfo);
 	}
     }
 #ifdef XEVIE
@@ -3212,7 +3212,7 @@ ProcessPointerEvent (register xEvent *xE, register DeviceIntPtr mouse, int count
 		    WindowTable[sprite.hotPhys.pScreen->myNum]->drawable.id;
 	    eventinfo.events = xE;
 	    eventinfo.count = count;
-	    CallCallbacks(&DeviceEventCallback, (pointer)&eventinfo);
+	    CallCallbacks(&DeviceEventCallback, (void *)&eventinfo);
 	}
     }
     if (xE->u.u.type != MotionNotify)
@@ -3402,7 +3402,7 @@ RecalculateDeliverableEvents(pWin)
  *  \param value must conform to DeleteType
  */
 int
-OtherClientGone(pointer value, XID id)
+OtherClientGone(void * value, XID id)
 {
     register OtherClientsPtr other, prev;
     register WindowPtr pWin = (WindowPtr)value;
@@ -3497,7 +3497,7 @@ EventSelectForWindow(register WindowPtr pWin, register ClientPtr client, Mask ma
 	others->resource = FakeClientID(client->index);
 	others->next = pWin->optional->otherClients;
 	pWin->optional->otherClients = others;
-	if (!AddResource(others->resource, RT_OTHERCLIENT, (pointer)pWin))
+	if (!AddResource(others->resource, RT_OTHERCLIENT, (void *)pWin))
 	    return BadAlloc;
     }
 maskSet: 
@@ -5029,7 +5029,7 @@ WriteEventsToClient(ClientPtr pClient, int count, xEvent *events)
 	eventinfo.client = pClient;
 	eventinfo.events = events;
 	eventinfo.count = count;
-	CallCallbacks(&EventCallback, (pointer)&eventinfo);
+	CallCallbacks(&EventCallback, (void *)&eventinfo);
     }
     if(pClient->swapped)
     {
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXglxext.c b/nx-X11/programs/Xserver/hw/nxagent/NXglxext.c
index 51c547984..4b9ac9a67 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXglxext.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXglxext.c
@@ -442,7 +442,7 @@ static int __glXDispatch(ClientPtr client)
 	** with the client so we will be notified when the client dies.
 	*/
 	XID xid = FakeClientID(client->index);
-	if (!AddResource( xid, __glXClientRes, (pointer)(long)client->index)) {
+	if (!AddResource( xid, __glXClientRes, (void *)(long)client->index)) {
 	    return BadAlloc;
 	}
 	ResetClientState(client->index);
@@ -520,7 +520,7 @@ static int __glXSwapDispatch(ClientPtr client)
 	** with the client so we will be notified when the client dies.
 	*/
 	XID xid = FakeClientID(client->index);
-	if (!AddResource( xid, __glXClientRes, (pointer)(long)client->index)) {
+	if (!AddResource( xid, __glXClientRes, (void *)(long)client->index)) {
 	    return BadAlloc;
 	}
 	ResetClientState(client->index);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXglyph.c b/nx-X11/programs/Xserver/hw/nxagent/NXglyph.c
index cd65fdc0e..47db919ef 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXglyph.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXglyph.c
@@ -147,30 +147,30 @@ ResetGlyphSetPrivateIndex (void)
 }
 
 Bool
-_GlyphSetSetNewPrivate (GlyphSetPtr glyphSet, int n, pointer ptr)
+_GlyphSetSetNewPrivate (GlyphSetPtr glyphSet, int n, void * ptr)
 {
-    pointer *new;
+    void **new;
 
     if (n > glyphSet->maxPrivate) {
 	if (glyphSet->devPrivates &&
-	    glyphSet->devPrivates != (pointer)(&glyphSet[1])) {
-	    new = (pointer *) xrealloc (glyphSet->devPrivates,
-					(n + 1) * sizeof (pointer));
+	    glyphSet->devPrivates != (void *)(&glyphSet[1])) {
+	    new = (void **) xrealloc (glyphSet->devPrivates,
+					(n + 1) * sizeof (void *));
 	    if (!new)
 		return FALSE;
 	} else {
-	    new = (pointer *) xalloc ((n + 1) * sizeof (pointer));
+	    new = (void **) xalloc ((n + 1) * sizeof (void *));
 	    if (!new)
 		return FALSE;
 	    if (glyphSet->devPrivates)
 		memcpy (new,
 			glyphSet->devPrivates,
-			(glyphSet->maxPrivate + 1) * sizeof (pointer));
+			(glyphSet->maxPrivate + 1) * sizeof (void *));
 	}
 	glyphSet->devPrivates = new;
 	/* Zero out new, uninitialize privates */
 	while (++glyphSet->maxPrivate < n)
-	    glyphSet->devPrivates[glyphSet->maxPrivate] = (pointer)0;
+	    glyphSet->devPrivates[glyphSet->maxPrivate] = (void *)0;
     }
     glyphSet->devPrivates[n] = ptr;
     return TRUE;
@@ -522,14 +522,14 @@ AllocateGlyphSet (int fdepth, PictFormatPtr format)
     }
 
     size = (sizeof (GlyphSetRec) +
-	    (sizeof (pointer) * _GlyphSetPrivateAllocateIndex));
+	    (sizeof (void *) * _GlyphSetPrivateAllocateIndex));
     glyphSet = xalloc (size);
     if (!glyphSet)
 	return FALSE;
     bzero((char *)glyphSet, size);
     glyphSet->maxPrivate = _GlyphSetPrivateAllocateIndex - 1;
     if (_GlyphSetPrivateAllocateIndex)
-	glyphSet->devPrivates = (pointer)(&glyphSet[1]);
+	glyphSet->devPrivates = (void *)(&glyphSet[1]);
 
     if (!AllocateGlyphHash (&glyphSet->hash, &glyphHashSets[0]))
     {
@@ -543,7 +543,7 @@ AllocateGlyphSet (int fdepth, PictFormatPtr format)
 }
 
 int
-FreeGlyphSet (pointer	value,
+FreeGlyphSet (void *	value,
 	      XID       gid)
 {
     GlyphSetPtr	glyphSet = (GlyphSetPtr) value;
@@ -571,7 +571,7 @@ FreeGlyphSet (pointer	value,
 	xfree (table);
 
 	if (glyphSet->devPrivates &&
-	    glyphSet->devPrivates != (pointer)(&glyphSet[1]))
+	    glyphSet->devPrivates != (void *)(&glyphSet[1]))
 	    xfree(glyphSet->devPrivates);
 
 	xfree (glyphSet);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXglyphstr.h b/nx-X11/programs/Xserver/hw/nxagent/NXglyphstr.h
index fa6b5fb02..e7bb2d841 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXglyphstr.h
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXglyphstr.h
@@ -94,13 +94,13 @@ typedef struct _GlyphSet {
     int		    fdepth;
     GlyphHashRec    hash;
     int             maxPrivate;
-    pointer         *devPrivates;
+    void            **devPrivates;
     CARD32          remoteID;
 } GlyphSetRec, *GlyphSetPtr;
 
 #define GlyphSetGetPrivate(pGlyphSet,n)					\
 	((n) > (pGlyphSet)->maxPrivate ?				\
-	 (pointer) 0 :							\
+	 (void *) 0 :							\
 	 (pGlyphSet)->devPrivates[n])
 
 #define GlyphSetSetPrivate(pGlyphSet,n,ptr)				\
@@ -127,7 +127,7 @@ void
 ResetGlyphSetPrivateIndex (void);
 
 Bool
-_GlyphSetSetNewPrivate (GlyphSetPtr glyphSet, int n, pointer ptr);
+_GlyphSetSetNewPrivate (GlyphSetPtr glyphSet, int n, void * ptr);
 
 Bool
 GlyphInit (ScreenPtr pScreen);
@@ -166,7 +166,7 @@ GlyphSetPtr
 AllocateGlyphSet (int fdepth, PictFormatPtr format);
 
 int
-FreeGlyphSet (pointer   value,
+FreeGlyphSet (void      *value,
 	      XID       gid);
 
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXmiexpose.c b/nx-X11/programs/Xserver/hw/nxagent/NXmiexpose.c
index 125f1b1c4..e1c6b6d8c 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXmiexpose.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXmiexpose.c
@@ -672,7 +672,7 @@ static GCPtr	screenContext[MAXSCREENS];
 /*ARGSUSED*/
 static int
 tossGC (
-    pointer value,
+    void * value,
     XID id)
 {
     GCPtr pGC = (GCPtr)value;
@@ -757,7 +757,7 @@ int what;
 	    gcmask |= GCForeground | GCFillStyle;
 	    break;
 	case BackgroundPixmap:
-	    newValues[TILE].ptr = (pointer)pWin->background.pixmap;
+	    newValues[TILE].ptr = (void *)pWin->background.pixmap;
 	    newValues[FILLSTYLE].val = FillTiled;
 	    gcmask |= GCTile | GCFillStyle | GCTileStipXOrigin | GCTileStipYOrigin;
 	    break;
@@ -773,7 +773,7 @@ int what;
 	}
 	else
 	{
-	    newValues[TILE].ptr = (pointer)pWin->border.pixmap;
+	    newValues[TILE].ptr = (void *)pWin->border.pixmap;
 	    newValues[FILLSTYLE].val = FillTiled;
 	    gcmask |= GCTile | GCFillStyle | GCTileStipXOrigin | GCTileStipYOrigin;
 	}
@@ -846,7 +846,7 @@ int what;
 		return;
 	    numGCs++;
 	    if (!AddResource(FakeClientID(0), ResType,
-			     (pointer)screenContext[i]))
+			     (void *)screenContext[i]))
 	        return;
 	}
 	pGC = screenContext[i];
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXmiglyph.c b/nx-X11/programs/Xserver/hw/nxagent/NXmiglyph.c
index 5f32334ae..f86c81de6 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXmiglyph.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXmiglyph.c
@@ -225,7 +225,7 @@ miGlyphs (CARD8		op,
 		pPixmap = GetScratchPixmapHeader (pScreen, glyph->info.width, glyph->info.height, 
 						  list->format->depth,
 						  list->format->depth, 
-						  0, (pointer) (glyph + 1));
+						  0, (void *) (glyph + 1));
 		if (!pPixmap)
 		    return;
 		component_alpha = NeedsComponent(list->format->format);
@@ -240,7 +240,7 @@ miGlyphs (CARD8		op,
 	    }
 	    (*pScreen->ModifyPixmapHeader) (pPixmap, 
 					    glyph->info.width, glyph->info.height,
-					    0, 0, -1, (pointer) (glyph + 1));
+					    0, 0, -1, (void *) (glyph + 1));
 
             #ifdef NXAGENT_SERVER
 
@@ -292,7 +292,7 @@ miGlyphs (CARD8		op,
 	if (pPicture)
 	{
 	    FreeScratchPixmapHeader (pPixmap);
-	    FreePicture ((pointer) pPicture, 0);
+	    FreePicture ((void *) pPicture, 0);
 	    pPicture = 0;
 	    pPixmap = 0;
 	}
@@ -311,7 +311,7 @@ miGlyphs (CARD8		op,
 			  x, y,
 			  width, height);
 
-	FreePicture ((pointer) pMask, (XID) 0);
+	FreePicture ((void *) pMask, (XID) 0);
 	(*pScreen->DestroyPixmap) (pMaskPixmap);
     }
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXmiwindow.c b/nx-X11/programs/Xserver/hw/nxagent/NXmiwindow.c
index 190294979..8132e9dd0 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXmiwindow.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXmiwindow.c
@@ -596,7 +596,7 @@ miMoveWindow(pWin, x, y, pNextSib, kind)
 static int
 miRecomputeExposures (
     register WindowPtr	pWin,
-    pointer		value) /* must conform to VisitWindowProcPtr */
+    void *		value) /* must conform to VisitWindowProcPtr */
 {
     register ScreenPtr	pScreen;
     RegionPtr	pValid = (RegionPtr)value;
@@ -927,7 +927,7 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 		    continue;
 		REGION_INTERSECT(pScreen, pRegion,
 				       &pChild->borderClip, gravitate[g]);
-		TraverseTree (pChild, miRecomputeExposures, (pointer)pRegion);
+		TraverseTree (pChild, miRecomputeExposures, (void *)pRegion);
 	    }
 
 	    /*
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXpicture.c b/nx-X11/programs/Xserver/hw/nxagent/NXpicture.c
index 4b342ebcf..9c438394a 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXpicture.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXpicture.c
@@ -152,7 +152,7 @@ PictureDestroyWindow (WindowPtr pWindow)
 	SetPictureWindow(pWindow, pPicture->pNext);
 	if (pPicture->id)
 	    FreeResource (pPicture->id, PictureType);
-	FreePicture ((pointer) pPicture, pPicture->id);
+	FreePicture ((void *) pPicture, pPicture->id);
     }
     pScreen->DestroyWindow = ps->DestroyWindow;
     ret = (*pScreen->DestroyWindow) (pWindow);
@@ -731,7 +731,7 @@ PictureInit (ScreenPtr pScreen, PictFormatPtr formats, int nformats)
     }
     for (n = 0; n < nformats; n++)
     {
-	if (!AddResource (formats[n].id, PictFormatType, (pointer) (formats+n)))
+	if (!AddResource (formats[n].id, PictFormatType, (void *) (formats+n)))
 	{
 	    xfree (formats);
 	    return FALSE;
@@ -867,11 +867,11 @@ AllocatePicture (ScreenPtr  pScreen)
     {
 	if ( (size = *sizes) )
 	{
-	    ppriv->ptr = (pointer)ptr;
+	    ppriv->ptr = (void *)ptr;
 	    ptr += size;
 	}
 	else
-	    ppriv->ptr = (pointer)NULL;
+	    ppriv->ptr = (void *)NULL;
     }
 
     nxagentPicturePriv(pPicture) -> picture = 0;
@@ -1103,7 +1103,7 @@ static PicturePtr createSourcePicture(void)
 
       privPictureRecAddr = (char *) &ppriv[picturePrivateCount];
 
-      ppriv[nxagentPicturePrivateIndex].ptr = (pointer) privPictureRecAddr;
+      ppriv[nxagentPicturePrivateIndex].ptr = (void *) privPictureRecAddr;
 
       pPicture -> devPrivates = ppriv;
 
@@ -1364,7 +1364,7 @@ ChangePicture (PicturePtr	pPicture,
 		    if (pAlpha && pAlpha->pDrawable->type == DRAWABLE_PIXMAP)
 			pAlpha->refcnt++;
 		    if (pPicture->alphaMap)
-			FreePicture ((pointer) pPicture->alphaMap, (XID) 0);
+			FreePicture ((void *) pPicture->alphaMap, (XID) 0);
 		    pPicture->alphaMap = pAlpha;
 		}
 	    }
@@ -1442,7 +1442,7 @@ ChangePicture (PicturePtr	pPicture,
                 #endif
 
 		error = (*ps->ChangePictureClip)(pPicture, clipType,
-						 (pointer)pPixmap, 0);
+						 (void *)pPixmap, 0);
 		break;
 	    }
 	case CPGraphicsExposure:
@@ -1542,7 +1542,7 @@ SetPictureClipRects (PicturePtr	pPicture,
     if (!clientClip)
 	return BadAlloc;
     result =(*ps->ChangePictureClip) (pPicture, CT_REGION, 
-				      (pointer) clientClip, 0);
+				      (void *) clientClip, 0);
     if (result == Success)
     {
 	pPicture->clipOrigin.x = xOrigin;
@@ -1586,7 +1586,7 @@ SetPictureClipRegion (PicturePtr    pPicture,
     }
 
     result =(*ps->ChangePictureClip) (pPicture, type,
-                                      (pointer) clientClip, 0);
+                                      (void *) clientClip, 0);
     if (result == Success)
     {
         pPicture->clipOrigin.x = xOrigin;
@@ -1658,7 +1658,7 @@ CopyPicture (PicturePtr	pSrc,
 	    if (pSrc->alphaMap && pSrc->alphaMap->pDrawable->type == DRAWABLE_PIXMAP)
 		pSrc->alphaMap->refcnt++;
 	    if (pDst->alphaMap)
-		FreePicture ((pointer) pDst->alphaMap, (XID) 0);
+		FreePicture ((void *) pDst->alphaMap, (XID) 0);
 	    pDst->alphaMap = pSrc->alphaMap;
 	    break;
 	case CPAlphaXOrigin:
@@ -1740,7 +1740,7 @@ ValidatePicture(PicturePtr pPicture)
 }
 
 int
-FreePicture (pointer	value,
+FreePicture (void *	value,
 	     XID	pid)
 {
     PicturePtr	pPicture = (PicturePtr) value;
@@ -1764,7 +1764,7 @@ FreePicture (pointer	value,
             PictureScreenPtr    ps = GetPictureScreen(pScreen);
 	
             if (pPicture->alphaMap)
-                FreePicture ((pointer) pPicture->alphaMap, (XID) 0);
+                FreePicture ((void *) pPicture->alphaMap, (XID) 0);
             (*ps->DestroyPicture) (pPicture);
             (*ps->DestroyPictureClip) (pPicture);
             if (pPicture->pDrawable->type == DRAWABLE_WINDOW)
@@ -1794,7 +1794,7 @@ FreePicture (pointer	value,
 }
 
 int
-FreePictFormat (pointer	pPictFormat,
+FreePictFormat (void *	pPictFormat,
 		XID     pid)
 {
     return Success;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXpicturestr.h b/nx-X11/programs/Xserver/hw/nxagent/NXpicturestr.h
index b2679257c..9f9c32c35 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXpicturestr.h
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXpicturestr.h
@@ -174,7 +174,7 @@ typedef struct _Picture {
     DDXPointRec	    alphaOrigin;
 
     DDXPointRec	    clipOrigin;
-    pointer	    clientClip;
+    void *	    clientClip;
 
     Atom	    dither;
 
@@ -220,7 +220,7 @@ typedef int	(*CreatePictureProcPtr)	    (PicturePtr pPicture);
 typedef void	(*DestroyPictureProcPtr)    (PicturePtr pPicture);
 typedef int	(*ChangePictureClipProcPtr) (PicturePtr	pPicture,
 					     int	clipType,
-					     pointer    value,
+					     void       *value,
 					     int	n);
 typedef void	(*DestroyPictureClipProcPtr)(PicturePtr	pPicture);
 
@@ -393,9 +393,9 @@ extern RESTYPE		GlyphSetType;
 
 #define GetPictureScreen(s) ((PictureScreenPtr) ((s)->devPrivates[PictureScreenPrivateIndex].ptr))
 #define GetPictureScreenIfSet(s) ((PictureScreenPrivateIndex != -1) ? GetPictureScreen(s) : NULL)
-#define SetPictureScreen(s,p) ((s)->devPrivates[PictureScreenPrivateIndex].ptr = (pointer) (p))
+#define SetPictureScreen(s,p) ((s)->devPrivates[PictureScreenPrivateIndex].ptr = (void *) (p))
 #define GetPictureWindow(w) ((PicturePtr) ((w)->devPrivates[PictureWindowPrivateIndex].ptr))
-#define SetPictureWindow(w,p) ((w)->devPrivates[PictureWindowPrivateIndex].ptr = (pointer) (p))
+#define SetPictureWindow(w,p) ((w)->devPrivates[PictureWindowPrivateIndex].ptr = (void *) (p))
 
 #define VERIFY_PICTURE(pPicture, pid, client, mode, err) {\
     pPicture = SecurityLookupIDByType(client, pid, PictureType, mode);\
@@ -535,11 +535,11 @@ void
 ValidatePicture(PicturePtr pPicture);
 
 int
-FreePicture (pointer	pPicture,
+FreePicture (void *	pPicture,
 	     XID	pid);
 
 int
-FreePictFormat (pointer	pPictFormat,
+FreePictFormat (void *	pPictFormat,
 		XID     pid);
 
 void
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXproperty.c b/nx-X11/programs/Xserver/hw/nxagent/NXproperty.c
index ee2d6da94..a2d4a8e52 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXproperty.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXproperty.c
@@ -317,10 +317,10 @@ ProcChangeProperty(ClientPtr client)
 
 #ifdef LBX
     err = LbxChangeWindowProperty(client, pWin, stuff->property, stuff->type,
-	 (int)format, (int)mode, len, TRUE, (pointer)&stuff[1], TRUE, NULL);
+	 (int)format, (int)mode, len, TRUE, (void *)&stuff[1], TRUE, NULL);
 #else
     err = ChangeWindowProperty(pWin, stuff->property, stuff->type, (int)format,
-			       (int)mode, len, (pointer)&stuff[1], TRUE);
+			       (int)mode, len, (void *)&stuff[1], TRUE);
 #endif
     if (err != Success)
 	return err;
@@ -329,7 +329,7 @@ ProcChangeProperty(ClientPtr client)
       if (nxagentOption(Rootless) == 1)
       {
         nxagentExportProperty(pWin, stuff->property, stuff->type, (int) format,
-                                  (int) mode, len, (pointer) &stuff[1]);
+                                  (int) mode, len, (void *) &stuff[1]);
       }
 
       nxagentGuessClientHint(client, stuff->property, (char *) &stuff[1]);
@@ -346,7 +346,7 @@ ProcChangeProperty(ClientPtr client)
 
 int
 ChangeWindowProperty(WindowPtr pWin, Atom property, Atom type, int format, 
-                     int mode, unsigned long len, pointer value, 
+                     int mode, unsigned long len, void * value, 
                      Bool sendevent)
 {
 #ifdef LBX
@@ -358,7 +358,7 @@ ChangeWindowProperty(WindowPtr pWin, Atom property, Atom type, int format,
     xEvent event;
     int sizeInBytes;
     int totalSize;
-    pointer data;
+    void * data;
     int copySize;
 
     sizeInBytes = format>>3;
@@ -392,7 +392,7 @@ ChangeWindowProperty(WindowPtr pWin, Atom property, Atom type, int format,
         pProp = (PropertyPtr)xalloc(sizeof(PropertyRec));
 	if (!pProp)
 	    return(BadAlloc);
-        data = (pointer)xalloc(totalSize);
+        data = (void *)xalloc(totalSize);
 	if (!data && len)
 	{
 	    xfree(pProp);
@@ -423,7 +423,7 @@ ChangeWindowProperty(WindowPtr pWin, Atom property, Atom type, int format,
         {
 	    if (totalSize != pProp->size * (pProp->format >> 3))
 	    {
-	    	data = (pointer)xrealloc(pProp->data, totalSize);
+	    	data = (void *)xrealloc(pProp->data, totalSize);
 	    	if (!data && len)
 		    return(BadAlloc);
             	pProp->data = data;
@@ -440,7 +440,7 @@ ChangeWindowProperty(WindowPtr pWin, Atom property, Atom type, int format,
 	}
         else if (mode == PropModeAppend)
         {
-	    data = (pointer)xrealloc(pProp->data,
+	    data = (void *)xrealloc(pProp->data,
 				     sizeInBytes * (len + pProp->size));
 	    if (!data)
 		return(BadAlloc);
@@ -452,7 +452,7 @@ ChangeWindowProperty(WindowPtr pWin, Atom property, Atom type, int format,
 	}
         else if (mode == PropModePrepend)
         {
-            data = (pointer)xalloc(sizeInBytes * (len + pProp->size));
+            data = (void *)xalloc(sizeInBytes * (len + pProp->size));
 	    if (!data)
 		return(BadAlloc);
 	    memmove(&((char *)data)[totalSize], (char *)pProp->data, 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXrender.c b/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
index e34689399..260355c6e 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
@@ -125,9 +125,9 @@ void nxagentCreateGlyphSet(GlyphSetPtr glyphSet);
 void nxagentReferenceGlyphSet(GlyphSetPtr glyphSet);
 void nxagentFreeGlyphs(GlyphSetPtr glyphSet, CARD32 *gids, int nglyph);
 void nxagentFreeGlyphSet(GlyphSetPtr glyphSet);
-void nxagentSetPictureTransform(PicturePtr pPicture, pointer transform);
+void nxagentSetPictureTransform(PicturePtr pPicture, void * transform);
 void nxagentSetPictureFilter(PicturePtr pPicture, char *filter, int name_size,
-                                 pointer params, int nparams);
+                                 void * params, int nparams);
 void nxagentTrapezoids(CARD8 op, PicturePtr pSrc, PicturePtr pDst, PictFormatPtr maskFormat,
                            INT16 xSrc, INT16 ySrc, int ntrap, xTrapezoid *traps);
 
@@ -334,8 +334,8 @@ typedef struct _RenderClient {
 
 static void
 RenderClientCallback (CallbackListPtr	*list,
-		      pointer		closure,
-		      pointer		data)
+		      void *		closure,
+		      void *		data)
 {
     NewClientInfoRec	*clientinfo = (NewClientInfoRec *) data;
     ClientPtr		pClient = clientinfo->client;
@@ -767,7 +767,7 @@ ProcRenderCreatePicture (ClientPtr client)
 	return error;
     nxagentCreatePicture(pPicture, stuff -> mask);
 
-    if (!AddResource (stuff->pid, PictureType, (pointer)pPicture))
+    if (!AddResource (stuff->pid, PictureType, (void *)pPicture))
 	return BadAlloc;
     return Success;
 }
@@ -1341,7 +1341,7 @@ ProcRenderCreateGlyphSet (ClientPtr client)
     glyphSet = AllocateGlyphSet (f, format);
     if (!glyphSet)
 	return BadAlloc;
-    if (!AddResource (stuff->gsid, GlyphSetType, (pointer)glyphSet))
+    if (!AddResource (stuff->gsid, GlyphSetType, (void *)glyphSet))
 	return BadAlloc;
 
     nxagentCreateGlyphSet(glyphSet);
@@ -1372,7 +1372,7 @@ ProcRenderReferenceGlyphSet (ClientPtr client)
 
     nxagentReferenceGlyphSet(glyphSet);
 
-    if (!AddResource (stuff->gsid, GlyphSetType, (pointer)glyphSet))
+    if (!AddResource (stuff->gsid, GlyphSetType, (void *)glyphSet))
 	return BadAlloc;
     return client->noClientException;
 }
@@ -1953,7 +1953,7 @@ ProcRenderCreateCursor (ClientPtr client)
     {
 	(*pScreen->GetImage) (pSrc->pDrawable,
 			      0, 0, width, height, ZPixmap,
-			      0xffffffff, (pointer) argbbits);
+			      0xffffffff, (void *) argbbits);
     }
     else
     {
@@ -1993,7 +1993,7 @@ ProcRenderCreateCursor (ClientPtr client)
 			  0, 0, 0, 0, 0, 0, width, height);
 	(*pScreen->GetImage) (pPicture->pDrawable,
 			      0, 0, width, height, ZPixmap,
-			      0xffffffff, (pointer) argbbits);
+			      0xffffffff, (void *) argbbits);
 	FreePicture (pPicture, 0);
     }
     /*
@@ -2120,7 +2120,7 @@ ProcRenderCreateCursor (ClientPtr client)
 
     nxagentRenderRealizeCursor(pScreen, pCursor);
 
-    if (AddResource(stuff->cid, RT_CURSOR, (pointer)pCursor))
+    if (AddResource(stuff->cid, RT_CURSOR, (void *)pCursor))
 	return (client->noClientException);
     return BadAlloc;
 }
@@ -2324,7 +2324,7 @@ ProcRenderCreateAnimCursor (ClientPtr client)
       pCursor -> devPriv[i] = NULL;
     }
 
-    if (AddResource (stuff->cid, RT_CURSOR, (pointer)pCursor))
+    if (AddResource (stuff->cid, RT_CURSOR, (void *)pCursor))
 	return client->noClientException;
     return BadAlloc;
 }
@@ -2370,7 +2370,7 @@ static int ProcRenderCreateSolidFill(ClientPtr client)
     nxagentRenderCreateSolidFill(pPicture, &stuff -> color);
 
     /* AGENT SERVER */
-    if (!AddResource (stuff->pid, PictureType, (pointer)pPicture))
+    if (!AddResource (stuff->pid, PictureType, (void *)pPicture))
 	return BadAlloc;
     return Success;
 }
@@ -2407,7 +2407,7 @@ static int ProcRenderCreateLinearGradient (ClientPtr client)
                                           stuff->nStops, stops, colors);
 
     /* AGENT SERVER */
-    if (!AddResource (stuff->pid, PictureType, (pointer)pPicture))
+    if (!AddResource (stuff->pid, PictureType, (void *)pPicture))
 	return BadAlloc;
     return Success;
 }
@@ -2445,7 +2445,7 @@ static int ProcRenderCreateRadialGradient (ClientPtr client)
                                                   stuff->nStops, stops, colors);
 
     /* AGENT SERVER */
-    if (!AddResource (stuff->pid, PictureType, (pointer)pPicture))
+    if (!AddResource (stuff->pid, PictureType, (void *)pPicture))
 	return BadAlloc;
     return Success;
 }
@@ -2481,7 +2481,7 @@ static int ProcRenderCreateConicalGradient (ClientPtr client)
                                                colors);
 
     /* AGENT SERVER */
-    if (!AddResource (stuff->pid, PictureType, (pointer)pPicture))
+    if (!AddResource (stuff->pid, PictureType, (void *)pPicture))
 	return BadAlloc;
     return Success;
 }
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXresource.c b/nx-X11/programs/Xserver/hw/nxagent/NXresource.c
index d1c8325f2..833a33fd3 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXresource.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXresource.c
@@ -170,7 +170,7 @@ typedef struct _Resource {
     struct _Resource	*next;
     XID			id;
     RESTYPE		type;
-    pointer		value;
+    void *		value;
 } ResourceRec, *ResourcePtr;
 #define NullResource ((ResourcePtr)NULL)
 
@@ -459,7 +459,7 @@ FakeClientID(register int client)
 
 #ifdef NXAGENT_SERVER
 
-int nxagentFindClientResource(int client, RESTYPE type, pointer value)
+int nxagentFindClientResource(int client, RESTYPE type, void * value)
 {
   ResourcePtr pResource;
   ResourcePtr *resources;
@@ -488,7 +488,7 @@ int nxagentFindClientResource(int client, RESTYPE type, pointer value)
   return 0;
 }
 
-int nxagentSwitchResourceType(int client, RESTYPE type, pointer value)
+int nxagentSwitchResourceType(int client, RESTYPE type, void * value)
 {
   ResourcePtr pResource;
   ResourcePtr *resources;
@@ -552,7 +552,7 @@ int nxagentSwitchResourceType(int client, RESTYPE type, pointer value)
 #endif
 
 Bool
-AddResource(XID id, RESTYPE type, pointer value)
+AddResource(XID id, RESTYPE type, void * value)
 {
     int client;
     register ClientResourceRec *rrec;
@@ -753,7 +753,7 @@ FreeResourceByType(XID id, RESTYPE type, Bool skipFree)
  */
 
 Bool
-ChangeResourceValue (XID id, RESTYPE rtype, pointer value)
+ChangeResourceValue (XID id, RESTYPE rtype, void * value)
 {
     int    cid;
     register    ResourcePtr res;
@@ -785,7 +785,7 @@ FindClientResourcesByType(
     ClientPtr client,
     RESTYPE type,
     FindResType func,
-    pointer cdata
+    void * cdata
 ){
     register ResourcePtr *resources;
     register ResourcePtr this, next;
@@ -870,7 +870,7 @@ void
 FindAllClientResources(
     ClientPtr client,
     FindAllRes func,
-    pointer cdata
+    void * cdata
 ){
     register ResourcePtr *resources;
     register ResourcePtr this, next;
@@ -950,12 +950,12 @@ RestartLoop:
 }
 
 
-pointer
+void *
 LookupClientResourceComplex(
     ClientPtr client,
     RESTYPE type,
     FindComplexResType func,
-    pointer cdata
+    void * cdata
 ){
     ResourcePtr *resources;
     ResourcePtr this;
@@ -1126,12 +1126,12 @@ LegalNewID(XID id, register ClientPtr client)
  * else NULL is returned.
  */
 
-pointer
+void *
 SecurityLookupIDByType(ClientPtr client, XID id, RESTYPE rtype, Mask mode)
 {
     int    cid;
     register    ResourcePtr res;
-    pointer retval = NULL;
+    void * retval = NULL;
 
     assert(client == NullClient ||
      (client->index <= currentMaxClients && clients[client->index] == client));
@@ -1155,12 +1155,12 @@ SecurityLookupIDByType(ClientPtr client, XID id, RESTYPE rtype, Mask mode)
 }
 
 
-pointer
+void *
 SecurityLookupIDByClass(ClientPtr client, XID id, RESTYPE classes, Mask mode)
 {
     int    cid;
     register ResourcePtr res = NULL;
-    pointer retval = NULL;
+    void * retval = NULL;
 
     assert(client == NullClient ||
      (client->index <= currentMaxClients && clients[client->index] == client));
@@ -1187,14 +1187,14 @@ SecurityLookupIDByClass(ClientPtr client, XID id, RESTYPE classes, Mask mode)
  * macros because of compatibility with loadable servers.
  */
 
-pointer
+void *
 LookupIDByType(XID id, RESTYPE rtype)
 {
     return SecurityLookupIDByType(NullClient, id, rtype,
 				  SecurityUnknownAccess);
 }
 
-pointer
+void *
 LookupIDByClass(XID id, RESTYPE classes)
 {
     return SecurityLookupIDByClass(NullClient, id, classes,
@@ -1206,7 +1206,7 @@ LookupIDByClass(XID id, RESTYPE classes)
 /*
  *  LookupIDByType returns the object with the given id and type, else NULL.
  */ 
-pointer
+void *
 LookupIDByType(XID id, RESTYPE rtype)
 {
     int    cid;
@@ -1221,14 +1221,14 @@ LookupIDByType(XID id, RESTYPE rtype)
 	    if ((res->id == id) && (res->type == rtype))
 		return res->value;
     }
-    return (pointer)NULL;
+    return (void *)NULL;
 }
 
 /*
  *  LookupIDByClass returns the object with the given id and any one of the
  *  given classes, else NULL.
  */ 
-pointer
+void *
 LookupIDByClass(XID id, RESTYPE classes)
 {
     int    cid;
@@ -1243,7 +1243,7 @@ LookupIDByClass(XID id, RESTYPE classes)
 	    if ((res->id == id) && (res->type & classes))
 		return res->value;
     }
-    return (pointer)NULL;
+    return (void *)NULL;
 }
 
 #endif /* XCSECURITY */
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXshm.c b/nx-X11/programs/Xserver/hw/nxagent/NXshm.c
index 468dd480d..3b40b82f7 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXshm.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXshm.c
@@ -128,7 +128,7 @@ static void miShmPutImage(XSHM_PUT_IMAGE_ARGS);
 static void fbShmPutImage(XSHM_PUT_IMAGE_ARGS);
 static PixmapPtr fbShmCreatePixmap(XSHM_CREATE_PIXMAP_ARGS);
 static int ShmDetachSegment(
-    pointer		/* value */,
+    void *		/* value */,
     XID			/* shmseg */
     );
 static void ShmResetProc(
@@ -361,7 +361,7 @@ ShmDestroyPixmap (PixmapPtr pPixmap)
 #else
 	char	*base = (char *) pPixmap->devPrivate.ptr;
 	
-	if (base != (pointer) (pPixmap + 1))
+	if (base != (void *) (pPixmap + 1))
 	{
 	    for (shmdesc = Shmsegs; shmdesc; shmdesc = shmdesc->next)
 	    {
@@ -373,7 +373,7 @@ ShmDestroyPixmap (PixmapPtr pPixmap)
 	    shmdesc = 0;
 #endif
 	if (shmdesc)
-	    ShmDetachSegment ((pointer) shmdesc, pPixmap->drawable.id);
+	    ShmDetachSegment ((void *) shmdesc, pPixmap->drawable.id);
     }
     
     pScreen->DestroyPixmap = destroyPixmap[pScreen->myNum];
@@ -520,7 +520,7 @@ ProcShmAttach(client)
 	shmdesc->next = Shmsegs;
 	Shmsegs = shmdesc;
     }
-    if (!AddResource(stuff->shmseg, ShmSegType, (pointer)shmdesc))
+    if (!AddResource(stuff->shmseg, ShmSegType, (void *)shmdesc))
 	return BadAlloc;
     return(client->noClientException);
 }
@@ -528,7 +528,7 @@ ProcShmAttach(client)
 /*ARGSUSED*/
 static int
 ShmDetachSegment(value, shmseg)
-    pointer value; /* must conform to DeleteType */
+    void * value; /* must conform to DeleteType */
     XID shmseg;
 {
     ShmDescPtr shmdesc = (ShmDescPtr)value;
@@ -618,7 +618,7 @@ fbShmPutImage(dst, pGC, depth, format, w, h, sx, sy, sw, sh, dx, dy, data)
 	PixmapPtr pPixmap;
 
 	pPixmap = GetScratchPixmapHeader(dst->pScreen, w, h, depth,
-		BitsPerPixel(depth), PixmapBytePad(w, depth), (pointer)data);
+		BitsPerPixel(depth), PixmapBytePad(w, depth), (void *)data);
 	if (!pPixmap)
 	    return;
 	if (format == XYBitmap)
@@ -898,12 +898,12 @@ CreatePmap:
 
 	if (pMap) {
 #ifdef PIXPRIV
-            pMap->devPrivates[shmPixmapPrivate].ptr = (pointer) shmdesc;
+            pMap->devPrivates[shmPixmapPrivate].ptr = (void *) shmdesc;
 #endif
             shmdesc->refcnt++;
 	    pMap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
 	    pMap->drawable.id = newPix->info[j].id;
-	    if (!AddResource(newPix->info[j].id, RT_PIXMAP, (pointer)pMap)) {
+	    if (!AddResource(newPix->info[j].id, RT_PIXMAP, (void *)pMap)) {
 		(*pScreen->DestroyPixmap)(pMap);
 		result = BadAlloc;
 		break;
@@ -1173,7 +1173,7 @@ fbShmCreatePixmap (pScreen, width, height, depth, addr)
     #endif
 
     if (!(*pScreen->ModifyPixmapHeader)(pPixmap, width, height, depth,
-	    BitsPerPixel(depth), PixmapBytePad(width, depth), (pointer)addr)) 
+	    BitsPerPixel(depth), PixmapBytePad(width, depth), (void *)addr)) 
     {
       #ifdef WARNING
       fprintf(stderr,"fbShmCreatePixmap: Return Null Pixmap.\n");
@@ -1251,12 +1251,12 @@ CreatePmap:
     if (pMap)
     {
 #ifdef PIXPRIV
-	pMap->devPrivates[shmPixmapPrivate].ptr = (pointer) shmdesc;
+	pMap->devPrivates[shmPixmapPrivate].ptr = (void *) shmdesc;
 #endif
 	shmdesc->refcnt++;
 	pMap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
 	pMap->drawable.id = stuff->pid;
-	if (AddResource(stuff->pid, RT_PIXMAP, (pointer)pMap))
+	if (AddResource(stuff->pid, RT_PIXMAP, (void *)pMap))
 	{
 	    return(client->noClientException);
 	}
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c b/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c
index bb28961d1..4017099e9 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c
@@ -249,7 +249,7 @@ PrintWindowTree()
 #endif
 
 int
-TraverseTree(register WindowPtr pWin, VisitWindowProcPtr func, pointer data)
+TraverseTree(register WindowPtr pWin, VisitWindowProcPtr func, void * data)
 {
     register int result;
     register WindowPtr pChild;
@@ -284,7 +284,7 @@ TraverseTree(register WindowPtr pWin, VisitWindowProcPtr func, pointer data)
  *****/
 
 int
-WalkTree(ScreenPtr pScreen, VisitWindowProcPtr func, pointer data)
+WalkTree(ScreenPtr pScreen, VisitWindowProcPtr func, void * data)
 {
     return(TraverseTree(WindowTable[pScreen->myNum], func, data));
 }
@@ -310,7 +310,7 @@ SetWindowToDefaults(register WindowPtr pWin)
 
     pWin->backingStore = NotUseful;
     pWin->DIXsaveUnder = FALSE;
-    pWin->backStorage = (pointer) NULL;
+    pWin->backStorage = (void *) NULL;
 
     pWin->mapped = FALSE;	    /* off */
     pWin->realized = FALSE;	/* off */
@@ -430,11 +430,11 @@ AllocateWindow(ScreenPtr pScreen)
 	{
 	    if ( (size = *sizes) )
 	    {
-		ppriv->ptr = (pointer)ptr;
+		ppriv->ptr = (void *)ptr;
 		ptr += size;
 	    }
 	    else
-		ppriv->ptr = (pointer)NULL;
+		ppriv->ptr = (void *)NULL;
 	}
     }
     return pWin;
@@ -528,7 +528,7 @@ CreateRootWindow(ScreenPtr pScreen)
     pWin->border.pixel = pScreen->blackPixel;
     pWin->borderWidth = 0;
 
-    if (!AddResource(pWin->drawable.id, RT_WINDOW, (pointer)pWin))
+    if (!AddResource(pWin->drawable.id, RT_WINDOW, (void *)pWin))
 	return FALSE;
 
     if (disableBackingStore)
@@ -1065,7 +1065,7 @@ CrushTree(WindowPtr pWin)
  *****/
 
 int
-DeleteWindow(pointer value, XID wid)
+DeleteWindow(void * value, XID wid)
  {
     register WindowPtr pParent;
     register WindowPtr pWin = (WindowPtr)value;
@@ -2798,7 +2798,7 @@ CirculateWindow(WindowPtr pParent, int direction, ClientPtr client)
 static int
 CompareWIDs(
     WindowPtr pWin,
-    pointer   value) /* must conform to VisitWindowProcPtr */
+    void      *value) /* must conform to VisitWindowProcPtr */
 {
     Window *wid = (Window *)value;
 
@@ -2823,7 +2823,7 @@ ReparentWindow(register WindowPtr pWin, register WindowPtr pParent,
     register ScreenPtr pScreen;
 
     pScreen = pWin->drawable.pScreen;
-    if (TraverseTree(pWin, CompareWIDs, (pointer)&pParent->drawable.id) == WT_STOPWALKING)
+    if (TraverseTree(pWin, CompareWIDs, (void *)&pParent->drawable.id) == WT_STOPWALKING)
 	return(BadMatch);		
     if (!MakeWindowOptional(pWin))
 	return(BadAlloc);
@@ -3791,7 +3791,7 @@ TileScreenSaver(int i, int kind)
 	if (cursor)
 	{
 	    cursorID = FakeClientID(0);
-	    if (AddResource (cursorID, RT_CURSOR, (pointer) cursor))
+	    if (AddResource (cursorID, RT_CURSOR, (void *) cursor))
 	    {
 		attributes[attri] = cursorID;
 		mask |= CWCursor;
@@ -3822,7 +3822,7 @@ TileScreenSaver(int i, int kind)
 	return FALSE;
 
     if (!AddResource(pWin->drawable.id, RT_WINDOW,
-		     (pointer)savedScreenInfo[i].pWindow))
+		     (void *)savedScreenInfo[i].pWindow))
 	return FALSE;
 
     if (mask & CWBackPixmap)
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Pixmap.c b/nx-X11/programs/Xserver/hw/nxagent/Pixmap.c
index ad7e9c313..1dbd059ac 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Pixmap.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Pixmap.c
@@ -534,7 +534,7 @@ RegionPtr nxagentPixmapToRegion(PixmapPtr pPixmap)
 }
 
 Bool nxagentModifyPixmapHeader(PixmapPtr pPixmap, int width, int height, int depth,
-                                   int bitsPerPixel, int devKind, pointer pPixData)
+                                   int bitsPerPixel, int devKind, void * pPixData)
 {
   PixmapPtr pVirtualPixmap;
 
@@ -732,7 +732,7 @@ PixmapPtr nxagentPixmapPtr(Pixmap pixmap)
  * Reconnection stuff.
  */
 
-int nxagentDestroyNewPixmapResourceType(pointer p, XID id)
+int nxagentDestroyNewPixmapResourceType(void * p, XID id)
 {
   /*
    * Address of the destructor is set in Init.c.
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Pixmaps.h b/nx-X11/programs/Xserver/hw/nxagent/Pixmaps.h
index 98d5666d1..b42956fcf 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Pixmaps.h
+++ b/nx-X11/programs/Xserver/hw/nxagent/Pixmaps.h
@@ -115,7 +115,7 @@ Bool nxagentDestroyPixmap(PixmapPtr pPixmap);
 RegionPtr nxagentPixmapToRegion(PixmapPtr pPixmap);
 
 Bool nxagentModifyPixmapHeader(PixmapPtr pPixmap, int width, int height, int depth,
-                                   int bitsPerPixel, int devKind, pointer pPixData);
+                                   int bitsPerPixel, int devKind, void * pPixData);
 
 RegionPtr nxagentCreateRegion(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
                                   int width, int height);
@@ -125,7 +125,7 @@ Bool nxagentReconnectAllPixmaps(void *p0);
 void nxagentDisconnectPixmap(void *p0, XID x1, void* p2);
 Bool nxagentDisconnectAllPixmaps(void);
 
-int nxagentDestroyNewPixmapResourceType(pointer p, XID id);
+int nxagentDestroyNewPixmapResourceType(void * p, XID id);
 
 void nxagentSynchronizeShmPixmap(DrawablePtr pDrawable, int xPict, int yPict,
                                      int wPict, int hPict);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Render.c b/nx-X11/programs/Xserver/hw/nxagent/Render.c
index ca9959e81..c9f589c3b 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Render.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Render.c
@@ -188,10 +188,10 @@ void nxagentFreeGlyphs(GlyphSetPtr glyphSet, CARD32 *gids, int nglyph);
 
 void nxagentFreeGlyphSet(GlyphSetPtr glyphSet);
 
-void nxagentSetPictureTransform(PicturePtr pPicture, pointer transform);
+void nxagentSetPictureTransform(PicturePtr pPicture, void * transform);
 
 void nxagentSetPictureFilter(PicturePtr pPicture, char *filter, int name_size,
-                                 pointer params, int nparams);
+                                 void * params, int nparams);
 
 Bool nxagentReconnectAllGlyphSet(void *p);
 
@@ -2337,7 +2337,7 @@ void nxagentFreeGlyphs(GlyphSetPtr glyphSet, CARD32 *gids, int nglyph)
   }
 }
 
-void nxagentSetPictureTransform(PicturePtr pPicture, pointer transform)
+void nxagentSetPictureTransform(PicturePtr pPicture, void * transform)
 {
   #ifdef TEST
   fprintf(stderr, "nxagentSetPictureTransform: Going to set transform [%p] to picture at [%p].\n",
@@ -2358,7 +2358,7 @@ FIXME: Is this useful or just a waste of bandwidth?
 }
 
 void nxagentSetPictureFilter(PicturePtr pPicture, char *filter, int name_size,
-                                 pointer params, int nparams)
+                                 void * params, int nparams)
 {
   char *szFilter = Xmalloc(name_size + 1);
 
@@ -2561,7 +2561,7 @@ Bool nxagentReconnectAllGlyphSet(void *p)
   return success;
 }
 
-void nxagentReconnectPicture(pointer p0, XID x1, void *p2)
+void nxagentReconnectPicture(void * p0, XID x1, void *p2)
 {
   PicturePtr pPicture = (PicturePtr) p0;
   Bool *pBool = (Bool *) p2;
@@ -2737,7 +2737,7 @@ Bool nxagentReconnectAllPicture(void *p)
   return True;
 }
 
-void nxagentDisconnectPicture(pointer p0, XID x1, void* p2)
+void nxagentDisconnectPicture(void * p0, XID x1, void* p2)
 {
   PicturePtr pPicture = (PicturePtr) p0;
   Bool *pBool = (Bool *) p2;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Render.h b/nx-X11/programs/Xserver/hw/nxagent/Render.h
index 6f61ca85f..70f0ef20f 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Render.h
+++ b/nx-X11/programs/Xserver/hw/nxagent/Render.h
@@ -100,8 +100,8 @@ int nxagentRenderRealizeCursor(ScreenPtr pScreen, CursorPtr pCursor);
 void nxagentAddGlyphs(GlyphSetPtr glyphSet, Glyph *gids, xGlyphInfo *gi,
                                   int nglyphs, CARD8 *images, int sizeImages);
 
-void nxagentReconnectPicture(pointer p0, XID x1, void *p2);
-void nxagentDisconnectPicture(pointer p0, XID x1, void* p2);
+void nxagentReconnectPicture(void * p0, XID x1, void *p2);
+void nxagentDisconnectPicture(void * p0, XID x1, void* p2);
 
 void nxagentReconnectGlyphSet(void* p0, XID x1, void *p2);
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Rootless.c b/nx-X11/programs/Xserver/hw/nxagent/Rootless.c
index 74d2d1fe5..53a3b3fb7 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Rootless.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Rootless.c
@@ -444,7 +444,7 @@ int nxagentExportProperty(pWin, property, type, format, mode, nUnits, value)
     Atom        property, type;
     int         format, mode;
     unsigned long nUnits;
-    pointer     value;
+    void        *value;
 {
   char *propertyS, *typeS;
   Atom propertyX, typeX;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Rootless.h b/nx-X11/programs/Xserver/hw/nxagent/Rootless.h
index 1ea258db3..f502b54c3 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Rootless.h
+++ b/nx-X11/programs/Xserver/hw/nxagent/Rootless.h
@@ -63,7 +63,7 @@ void nxagentRootlessRestack(unsigned long *toplevel, unsigned int ntoplevel);
 int nxagentExportAllProperty(WindowPtr pWin);
 
 int nxagentExportProperty(WindowPtr pWin, Atom property, Atom type, int format,
-                              int mode, unsigned long nUnits, pointer value);
+                              int mode, unsigned long nUnits, void * value);
 
 #define MAX_RETRIEVED_PROPERTY_SIZE 256 * 1024
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Screen.c b/nx-X11/programs/Xserver/hw/nxagent/Screen.c
index 37296e80f..095aa7b08 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Screen.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Screen.c
@@ -211,7 +211,7 @@ RegionRec nxagentShadowUpdateRegion;
  * but we need it here.
  */
 
-int TellChanged(WindowPtr pWin, pointer value);
+int TellChanged(WindowPtr pWin, void * value);
 
 int nxagentBitsPerPixel(int depth)
 {
@@ -664,7 +664,7 @@ void nxagentInitViewportFrame(ScreenPtr pScreen, WindowPtr pRootWin)
                                                       pRootWin -> drawable.depth,
                                                           serverClient, visual, &error);
 
-  AddResource(xid, RT_WINDOW, (pointer) nxagentViewportFrameLeft);
+  AddResource(xid, RT_WINDOW, (void *) nxagentViewportFrameLeft);
 
   if (error != Success)
   {
@@ -689,7 +689,7 @@ void nxagentInitViewportFrame(ScreenPtr pScreen, WindowPtr pRootWin)
                                                                serverClient, visual,
                                                                    &error);
 
-  AddResource(xid, RT_WINDOW, (pointer) nxagentViewportFrameRight);
+  AddResource(xid, RT_WINDOW, (void *) nxagentViewportFrameRight);
 
   if (error != Success)
   {
@@ -714,7 +714,7 @@ void nxagentInitViewportFrame(ScreenPtr pScreen, WindowPtr pRootWin)
                                                                serverClient, visual,
                                                                    &error);
 
-  AddResource(xid, RT_WINDOW, (pointer) nxagentViewportFrameAbove);
+  AddResource(xid, RT_WINDOW, (void *) nxagentViewportFrameAbove);
 
   if (error != Success)
   {
@@ -739,7 +739,7 @@ void nxagentInitViewportFrame(ScreenPtr pScreen, WindowPtr pRootWin)
                                                                pRootWin -> drawable.depth,
                                                                    serverClient, visual, &error);
 
-  AddResource(xid, RT_WINDOW, (pointer) nxagentViewportFrameBelow);
+  AddResource(xid, RT_WINDOW, (void *) nxagentViewportFrameBelow);
 
   if (error != Success)
   {
@@ -835,7 +835,7 @@ Bool nxagentOpenScreen(int index, ScreenPtr pScreen,
   VisualID defaultVisual;
   int rootDepth;
 
-  pointer pFrameBufferBits;
+  void * pFrameBufferBits;
   int bitsPerPixel;
   int sizeInBytes;
 
@@ -2423,7 +2423,7 @@ FIXME: We should try to restore the previously
   nxagentMoveViewport(pScreen, 0, 0);
 
   /*
-   * Update pointer bounds.
+   * Update void * bounds.
    */
 
   ScreenRestructured(pScreen);
@@ -2773,11 +2773,11 @@ int nxagentShadowInit(ScreenPtr pScreen, WindowPtr pWin)
 
   accessPixmapID = FakeClientID(serverClient -> index);
 
-  AddResource(accessPixmapID, RT_PIXMAP, (pointer)nxagentShadowPixmapPtr);
+  AddResource(accessPixmapID, RT_PIXMAP, (void *)nxagentShadowPixmapPtr);
 
   accessWindowID = FakeClientID(serverClient -> index);
 
-  AddResource(accessWindowID, RT_WINDOW, (pointer)nxagentShadowWindowPtr);
+  AddResource(accessWindowID, RT_WINDOW, (void *)nxagentShadowWindowPtr);
 
   nxagentResizeScreen(pScreen, nxagentShadowWidth, nxagentShadowHeight, pScreen -> mmWidth, pScreen -> mmHeight);
 
@@ -2847,7 +2847,7 @@ int nxagentShadowCreateMainWindow(ScreenPtr pScreen, WindowPtr pWin, int width,
 
   if (nxagentShadowPixmapPtr)
   {
-    ChangeResourceValue(accessPixmapID, RT_PIXMAP, (pointer) nxagentShadowPixmapPtr);
+    ChangeResourceValue(accessPixmapID, RT_PIXMAP, (void *) nxagentShadowPixmapPtr);
     nxagentShadowPixmapPtr -> drawable.id = accessPixmapID;
 
     #ifdef TEST
@@ -2933,7 +2933,7 @@ int nxagentShadowCreateMainWindow(ScreenPtr pScreen, WindowPtr pWin, int width,
 
     #endif
 
-    ChangeResourceValue(accessWindowID, RT_WINDOW, (pointer) nxagentShadowWindowPtr);
+    ChangeResourceValue(accessWindowID, RT_WINDOW, (void *) nxagentShadowWindowPtr);
   }
   else
   {
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Window.c b/nx-X11/programs/Xserver/hw/nxagent/Window.c
index c4aedf482..782ab9c9c 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Window.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Window.c
@@ -162,19 +162,19 @@ static Bool nxagentSomeWindowsAreMapped(void);
 
 static void nxagentFrameBufferPaintWindow(WindowPtr pWin, RegionPtr pRegion, int what);
 
-static void nxagentTraverseWindow(WindowPtr, void(*)(pointer, XID, pointer), pointer);
+static void nxagentTraverseWindow(WindowPtr, void(*)(void *, XID, void *), void *);
 
-static void nxagentDisconnectWindow(pointer, XID, pointer);
+static void nxagentDisconnectWindow(void *, XID, void *);
 
-static Bool nxagentLoopOverWindows(void(*)(pointer, XID, pointer));
+static Bool nxagentLoopOverWindows(void(*)(void *, XID, void *));
 
-static void nxagentReconfigureWindowCursor(pointer, XID, pointer);
+static void nxagentReconfigureWindowCursor(void *, XID, void *);
 
-static void nxagentReconnectWindow(pointer, XID, pointer);
+static void nxagentReconnectWindow(void *, XID, void *);
 
-static void nxagentReconfigureWindow(pointer, XID, pointer);
+static void nxagentReconfigureWindow(void *, XID, void *);
 
-static int nxagentForceExposure(WindowPtr pWin, pointer ptr);
+static int nxagentForceExposure(WindowPtr pWin, void * ptr);
 
 /* by dimbor */
 typedef struct
@@ -218,7 +218,7 @@ WindowPtr nxagentGetWindowFromID(Window id)
   return NULL;
 }
 
-static int nxagentFindWindowMatch(WindowPtr pWin, pointer ptr)
+static int nxagentFindWindowMatch(WindowPtr pWin, void * ptr)
 {
   WindowMatchRec *match = (WindowMatchRec *) ptr;
 
@@ -245,7 +245,7 @@ WindowPtr nxagentWindowPtr(Window window)
 
   for (i = 0; i < nxagentNumScreens; i++)
   {
-    WalkTree(screenInfo.screens[i], nxagentFindWindowMatch, (pointer) &match);
+    WalkTree(screenInfo.screens[i], nxagentFindWindowMatch, (void *) &match);
 
     if (match.pWin) break;
   }
@@ -2437,7 +2437,7 @@ void nxagentShapeWindow(WindowPtr pWin)
 }
 #endif /* SHAPE */
 
-static int nxagentForceExposure(WindowPtr pWin, pointer ptr)
+static int nxagentForceExposure(WindowPtr pWin, void * ptr)
 {
   RegionPtr exposedRgn;
   BoxRec Box;
@@ -2623,12 +2623,12 @@ Bool nxagentDisconnectAllWindows(void)
 }
 
 /*
- * FIXME: We are giving up reconnecting those pointer
+ * FIXME: We are giving up reconnecting those void *
  * that are not resource, and we are just disconnecting them.
  * perhaps we could do better and reconnect them.
  */
 
-void nxagentDisconnectWindow(pointer p0, XID x1, pointer p2)
+void nxagentDisconnectWindow(void * p0, XID x1, void * p2)
 {
   WindowPtr pWin = (WindowPtr)p0;
   Bool*     pBool = (Bool*)p2;
@@ -2828,8 +2828,8 @@ Bool nxagentSetWindowCursors(void *p0)
 
 static void nxagentTraverseWindow(
   WindowPtr pWin,
-  void (*pF)(pointer, XID, pointer),
-  pointer p)
+  void (*pF)(void *, XID, void *),
+  void * p)
 {
   pF(pWin, 0, p);
 
@@ -2844,7 +2844,7 @@ static void nxagentTraverseWindow(
   }
 }
 
-static Bool nxagentLoopOverWindows(void (*pF)(pointer, XID, pointer))
+static Bool nxagentLoopOverWindows(void (*pF)(void *, XID, void *))
 {
   int i;
   Bool windowSuccess = True;
@@ -2859,7 +2859,7 @@ static Bool nxagentLoopOverWindows(void (*pF)(pointer, XID, pointer))
   return windowSuccess;
 }
 
-static void nxagentReconnectWindow(pointer param0, XID param1, pointer data_buffer)
+static void nxagentReconnectWindow(void * param0, XID param1, void * data_buffer)
 {
   WindowPtr pWin = (WindowPtr)param0;
   Bool *pBool = (Bool*)data_buffer;
@@ -3113,7 +3113,7 @@ FIXME: Do we need to set save unders attribute here?
   }
 }
 
-static void nxagentReconfigureWindowCursor(pointer param0, XID param1, pointer data_buffer)
+static void nxagentReconfigureWindowCursor(void * param0, XID param1, void * data_buffer)
 {
   WindowPtr pWin = (WindowPtr)param0;
   Bool *pBool = (Bool*)data_buffer;
@@ -3164,7 +3164,7 @@ static void nxagentReconfigureWindowCursor(pointer param0, XID param1, pointer d
   }
 }
 
-static void nxagentReconfigureWindow(pointer param0, XID param1, pointer data_buffer)
+static void nxagentReconfigureWindow(void * param0, XID param1, void * data_buffer)
 {
   WindowPtr pWin = (WindowPtr)param0;
   unsigned long mask = 0;
@@ -3732,7 +3732,7 @@ StaticResizedWindowStruct *nxagentFindStaticResizedWindow(unsigned long sequence
   return ret;
 }
 
-void nxagentEmptyBackingStoreRegion(pointer param0, XID param1, pointer data_buffer)
+void nxagentEmptyBackingStoreRegion(void * param0, XID param1, void * data_buffer)
 {
   WindowPtr pWin = (WindowPtr) param0;
 
diff --git a/nx-X11/programs/Xserver/hw/xfree86/os-support/xf86_ansic.h b/nx-X11/programs/Xserver/hw/xfree86/os-support/xf86_ansic.h
index c4090dc16..1322e72ee 100644
--- a/nx-X11/programs/Xserver/hw/xfree86/os-support/xf86_ansic.h
+++ b/nx-X11/programs/Xserver/hw/xfree86/os-support/xf86_ansic.h
@@ -268,7 +268,7 @@ extern int xf86vsnprintf(char*,xf86size_t,const char*,va_list);
 extern int xf86open(const char*, int,...);
 extern int xf86close(int);
 extern long xf86lseek(int, long, int);
-extern int xf86ioctl(int, unsigned long, pointer);
+extern int xf86ioctl(int, unsigned long, void *);
 extern xf86ssize_t xf86read(int, void *, xf86size_t);
 extern xf86ssize_t xf86write(int, const void *, xf86size_t);
 extern void* xf86mmap(void*, xf86size_t, int, int, int, xf86size_t /* off_t */);
@@ -306,7 +306,7 @@ unsigned int xf86sleep(unsigned int seconds);
 extern int xf86shmget(xf86key_t key, int size, int xf86shmflg);
 extern char * xf86shmat(int id, char *addr, int xf86shmflg);
 extern int xf86shmdt(char *addr);
-extern int xf86shmctl(int id, int xf86cmd, pointer buf);
+extern int xf86shmctl(int id, int xf86cmd, void * buf);
 
 extern int xf86setjmp(xf86jmp_buf env);
 extern int xf86setjmp0(xf86jmp_buf env);
diff --git a/nx-X11/programs/Xserver/include/closestr.h b/nx-X11/programs/Xserver/include/closestr.h
index d70f754b2..c06010113 100644
--- a/nx-X11/programs/Xserver/include/closestr.h
+++ b/nx-X11/programs/Xserver/include/closestr.h
@@ -69,7 +69,7 @@ typedef struct _LFWIstate {
     int		current_fpe;
     int		max_names;
     Bool	list_started;
-    pointer	private;
+    void *	private;
 } LFWIstateRec, *LFWIstatePtr;
 
 typedef struct _LFWIclosure {
diff --git a/nx-X11/programs/Xserver/include/colormap.h b/nx-X11/programs/Xserver/include/colormap.h
index 1f2c33075..d519bb782 100644
--- a/nx-X11/programs/Xserver/include/colormap.h
+++ b/nx-X11/programs/Xserver/include/colormap.h
@@ -87,16 +87,16 @@ extern int CreateColormap(
     int /*client*/);
 
 extern int FreeColormap(
-    pointer /*pmap*/,
+    void * /*pmap*/,
     XID /*mid*/);
 
 extern int TellLostMap(
     WindowPtr /*pwin*/,
-    pointer /* Colormap *pmid */);
+    void * /* Colormap *pmid */);
 
 extern int TellGainedMap(
     WindowPtr /*pwin*/,
-    pointer /* Colormap *pmid */);
+    void * /* Colormap *pmid */);
 
 extern int CopyColormapAndFree(
     Colormap /*mid*/,
@@ -140,7 +140,7 @@ extern int QueryColors(
     xrgb* /*prgbList*/);
 
 extern int FreeClientPixels(
-    pointer /*pcr*/,
+    void * /*pcr*/,
     XID /*fakeid*/);
 
 extern int AllocColorCells(
diff --git a/nx-X11/programs/Xserver/include/colormapst.h b/nx-X11/programs/Xserver/include/colormapst.h
index 5ceee9870..6b52b8350 100644
--- a/nx-X11/programs/Xserver/include/colormapst.h
+++ b/nx-X11/programs/Xserver/include/colormapst.h
@@ -113,7 +113,7 @@ typedef struct _ColormapRec
     Entry	*red;
     Entry 	*green;
     Entry	*blue;
-    pointer	devPriv;
+    void *	devPriv;
     DevUnion	*devPrivates;	/* dynamic devPrivates added after devPriv
 				   already existed - must keep devPriv */
 } ColormapRec;
diff --git a/nx-X11/programs/Xserver/include/cursor.h b/nx-X11/programs/Xserver/include/cursor.h
index 9eb799e1c..9e760df02 100644
--- a/nx-X11/programs/Xserver/include/cursor.h
+++ b/nx-X11/programs/Xserver/include/cursor.h
@@ -68,7 +68,7 @@ typedef struct _CursorMetric *CursorMetricPtr;
 extern CursorPtr rootCursor;
 
 extern int FreeCursor(
-    pointer /*pCurs*/,
+    void * /*pCurs*/,
     XID /*cid*/);
 
 /* Quartz support on Mac OS X pulls in the QuickDraw
diff --git a/nx-X11/programs/Xserver/include/cursorstr.h b/nx-X11/programs/Xserver/include/cursorstr.h
index c877d6cc9..894467289 100644
--- a/nx-X11/programs/Xserver/include/cursorstr.h
+++ b/nx-X11/programs/Xserver/include/cursorstr.h
@@ -65,7 +65,7 @@ typedef struct _CursorBits {
     Bool emptyMask;				/* all zeros mask */
     unsigned short width, height, xhot, yhot;	/* metrics */
     int refcnt;					/* can be shared */
-    pointer devPriv[MAXSCREENS];		/* set by pScr->RealizeCursor*/
+    void * devPriv[MAXSCREENS];		/* set by pScr->RealizeCursor*/
 #ifdef ARGB_CURSOR
     CARD32 *argb;				/* full-color alpha blended */
 #endif
@@ -76,7 +76,7 @@ typedef struct _Cursor {
     unsigned short foreRed, foreGreen, foreBlue; /* device-independent color */
     unsigned short backRed, backGreen, backBlue; /* device-independent color */
     int refcnt;
-    pointer devPriv[MAXSCREENS];		/* set by pScr->RealizeCursor*/
+    void * devPriv[MAXSCREENS];		/* set by pScr->RealizeCursor*/
 #ifdef XFIXES
     CARD32 serialNumber;
     Atom name;
diff --git a/nx-X11/programs/Xserver/include/dix.h b/nx-X11/programs/Xserver/include/dix.h
index 9fe575e53..25260e46c 100644
--- a/nx-X11/programs/Xserver/include/dix.h
+++ b/nx-X11/programs/Xserver/include/dix.h
@@ -330,7 +330,7 @@ extern void InitSelections(void);
 extern void FlushClientCaches(XID /*id*/);
 
 extern int dixDestroyPixmap(
-    pointer /*value*/,
+    void * /*value*/,
     XID /*pid*/);
 
 extern void CloseDownRetainedResources(void);
@@ -338,10 +338,10 @@ extern void CloseDownRetainedResources(void);
 extern void InitClient(
     ClientPtr /*client*/,
     int /*i*/,
-    pointer /*ospriv*/);
+    void * /*ospriv*/);
 
 extern ClientPtr NextAvailableClient(
-    pointer /*ospriv*/);
+    void * /*ospriv*/);
 
 extern void SendErrorToClient(
     ClientPtr /*client*/,
@@ -403,7 +403,7 @@ extern WindowPtr SecurityLookupWindow(
     ClientPtr /*client*/,
     Mask /*access_mode*/);
 
-extern pointer SecurityLookupDrawable(
+extern void * SecurityLookupDrawable(
     XID /*rid*/,
     ClientPtr /*client*/,
     Mask /*access_mode*/);
@@ -412,7 +412,7 @@ extern WindowPtr LookupWindow(
     XID /*rid*/,
     ClientPtr /*client*/);
 
-extern pointer LookupDrawable(
+extern void * LookupDrawable(
     XID /*rid*/,
     ClientPtr /*client*/);
 
@@ -422,7 +422,7 @@ extern WindowPtr LookupWindow(
     XID /*rid*/,
     ClientPtr /*client*/);
 
-extern pointer LookupDrawable(
+extern void * LookupDrawable(
     XID /*rid*/,
     ClientPtr /*client*/);
 
@@ -451,27 +451,27 @@ extern void DeleteWindowFromAnySaveSet(
     WindowPtr /*pWin*/);
 
 extern void BlockHandler(
-    pointer /*pTimeout*/,
-    pointer /*pReadmask*/);
+    void * /*pTimeout*/,
+    void * /*pReadmask*/);
 
 extern void WakeupHandler(
     int /*result*/,
-    pointer /*pReadmask*/);
+    void * /*pReadmask*/);
 
 typedef void (* WakeupHandlerProcPtr)(
-    pointer /* blockData */,
+    void * /* blockData */,
     int /* result */,
-    pointer /* pReadmask */);
+    void * /* pReadmask */);
 
 extern Bool RegisterBlockAndWakeupHandlers(
     BlockHandlerProcPtr /*blockHandler*/,
     WakeupHandlerProcPtr /*wakeupHandler*/,
-    pointer /*blockData*/);
+    void * /*blockData*/);
 
 extern void RemoveBlockAndWakeupHandlers(
     BlockHandlerProcPtr /*blockHandler*/,
     WakeupHandlerProcPtr /*wakeupHandler*/,
-    pointer /*blockData*/);
+    void * /*blockData*/);
 
 extern void InitBlockAndWakeupHandlers(void);
 
@@ -482,19 +482,19 @@ extern void ProcessWorkQueueZombies(void);
 extern Bool QueueWorkProc(
     Bool (* /*function*/)(
         ClientPtr /*clientUnused*/,
-        pointer /*closure*/),
+        void * /*closure*/),
     ClientPtr /*client*/,
-    pointer /*closure*/
+    void * /*closure*/
 );
 
 typedef Bool (* ClientSleepProcPtr)(
     ClientPtr /*client*/,
-    pointer /*closure*/);
+    void * /*closure*/);
 
 extern Bool ClientSleep(
     ClientPtr /*client*/,
     ClientSleepProcPtr /* function */,
-    pointer /*closure*/);
+    void * /*closure*/);
 
 #ifndef ___CLIENTSIGNAL_DEFINED___
 #define ___CLIENTSIGNAL_DEFINED___
@@ -634,7 +634,7 @@ extern void RecalculateDeliverableEvents(
     WindowPtr /* pWin */);
 
 extern int OtherClientGone(
-    pointer /* value */,
+    void * /* value */,
     XID /* id */);
 
 extern void DoFocusEvents(
@@ -723,16 +723,16 @@ typedef struct _CallbackList *CallbackListPtr; /* also in misc.h */
 #endif
 
 typedef void (*CallbackProcPtr) (
-    CallbackListPtr *, pointer, pointer);
+    CallbackListPtr *, void *, void *);
 
 typedef Bool (*AddCallbackProcPtr) (
-    CallbackListPtr *, CallbackProcPtr, pointer);
+    CallbackListPtr *, CallbackProcPtr, void *);
 
 typedef Bool (*DeleteCallbackProcPtr) (
-    CallbackListPtr *, CallbackProcPtr, pointer);
+    CallbackListPtr *, CallbackProcPtr, void *);
 
 typedef void (*CallCallbacksProcPtr) (
-    CallbackListPtr *, pointer);
+    CallbackListPtr *, void *);
 
 typedef void (*DeleteCallbackListProcPtr) (
     CallbackListPtr *);
@@ -751,16 +751,16 @@ extern Bool CreateCallbackList(
 extern Bool AddCallback(
     CallbackListPtr * /*pcbl*/,
     CallbackProcPtr /*callback*/,
-    pointer /*data*/);
+    void * /*data*/);
 
 extern Bool DeleteCallback(
     CallbackListPtr * /*pcbl*/,
     CallbackProcPtr /*callback*/,
-    pointer /*data*/);
+    void * /*data*/);
 
 extern void CallCallbacks(
     CallbackListPtr * /*pcbl*/,
-    pointer /*call_data*/);
+    void * /*call_data*/);
 
 extern void DeleteCallbackList(
     CallbackListPtr * /*pcbl*/);
diff --git a/nx-X11/programs/Xserver/include/dixfont.h b/nx-X11/programs/Xserver/include/dixfont.h
index c6b8676da..9fcf0d585 100644
--- a/nx-X11/programs/Xserver/include/dixfont.h
+++ b/nx-X11/programs/Xserver/include/dixfont.h
@@ -45,9 +45,9 @@ extern void QueueFontWakeup(FontPathElementPtr /*fpe*/);
 
 extern void RemoveFontWakeup(FontPathElementPtr /*fpe*/);
 
-extern void FontWakeup(pointer /*data*/,
+extern void FontWakeup(void * /*data*/,
 		       int /*count*/,
-		       pointer /*LastSelectMask*/);
+		       void * /*LastSelectMask*/);
 
 extern int OpenFont(ClientPtr /*client*/,
 		    XID /*fid*/,
@@ -55,7 +55,7 @@ extern int OpenFont(ClientPtr /*client*/,
 		    unsigned /*lenfname*/,
 		    char * /*pfontname*/);
 
-extern int CloseFont(pointer /*pfont*/,
+extern int CloseFont(void * /*pfont*/,
 		     XID /*fid*/);
 
 typedef struct _xQueryFontReply *xQueryFontReplyPtr;
diff --git a/nx-X11/programs/Xserver/include/dixgrabs.h b/nx-X11/programs/Xserver/include/dixgrabs.h
index 042e063db..c05447c71 100644
--- a/nx-X11/programs/Xserver/include/dixgrabs.h
+++ b/nx-X11/programs/Xserver/include/dixgrabs.h
@@ -43,7 +43,7 @@ extern GrabPtr CreateGrab(
 	CursorPtr /* cursor */);
 
 extern int DeletePassiveGrab(
-	pointer /* value */,
+	void * /* value */,
 	XID /* id */);
 
 extern Bool GrabMatchesSecond(
diff --git a/nx-X11/programs/Xserver/include/dixstruct.h b/nx-X11/programs/Xserver/include/dixstruct.h
index 6266ec9f8..53c78d2de 100644
--- a/nx-X11/programs/Xserver/include/dixstruct.h
+++ b/nx-X11/programs/Xserver/include/dixstruct.h
@@ -93,8 +93,8 @@ typedef struct _Window *SaveSetElt;
 typedef struct _Client {
     int         index;
     Mask        clientAsMask;
-    pointer     requestBuffer;
-    pointer     osPrivate;	/* for OS layer, including scheduler */
+    void        *requestBuffer;
+    void        *osPrivate;	/* for OS layer, including scheduler */
     Bool        swapped;
     ReplySwapPtr pSwapReplyFunc;
     XID         errorValue;
@@ -109,7 +109,7 @@ typedef struct _Client {
     GContext    lastGCID;
     SaveSetElt	*saveSet;
     int         numSaved;
-    pointer     screenPrivate[MAXSCREENS];
+    void        *screenPrivate[MAXSCREENS];
     int         (**requestVector) (
 		ClientPtr /* pClient */);
     CARD32	req_len;		/* length of current request */
@@ -136,12 +136,12 @@ typedef struct _Client {
 #ifdef XCSECURITY
     XID		authId;
     unsigned int trustLevel;
-    pointer (* CheckAccess)(
+    void * (* CheckAccess)(
 	    ClientPtr /*pClient*/,
 	    XID /*id*/,
 	    RESTYPE /*classes*/,
 	    Mask /*access_mode*/,
-	    pointer /*resourceval*/);
+	    void * /*resourceval*/);
 #endif
 #ifdef XAPPGROUP
     struct _AppGroupRec*	appgroup;
@@ -187,10 +187,10 @@ typedef struct _WorkQueue {
     struct _WorkQueue *next;
     Bool        (*function) (
 		ClientPtr	/* pClient */,
-		pointer		/* closure */
+		void *		/* closure */
 );
     ClientPtr   client;
-    pointer     closure;
+    void        *closure;
 }           WorkQueueRec;
 
 extern TimeStamp currentTime;
@@ -204,7 +204,7 @@ extern TimeStamp ClientTimeToServerTime(CARD32 /*c*/);
 
 typedef struct _CallbackRec {
   CallbackProcPtr proc;
-  pointer data;
+  void * data;
   Bool deleted;
   struct _CallbackRec *next;
 } CallbackRec, *CallbackPtr;
diff --git a/nx-X11/programs/Xserver/include/extnsionst.h b/nx-X11/programs/Xserver/include/extnsionst.h
index daf37bf43..218ce8a7a 100644
--- a/nx-X11/programs/Xserver/include/extnsionst.h
+++ b/nx-X11/programs/Xserver/include/extnsionst.h
@@ -67,7 +67,7 @@ typedef struct _ExtensionEntry {
     int errorLast;
     int num_aliases;
     char **aliases;
-    pointer extPrivate;
+    void * extPrivate;
     unsigned short (* MinorOpcode)(	/* called for errors */
 	ClientPtr /* client */);
 #ifdef XCSECURITY
diff --git a/nx-X11/programs/Xserver/include/gc.h b/nx-X11/programs/Xserver/include/gc.h
index 77c2f20c6..1c0c90d3e 100644
--- a/nx-X11/programs/Xserver/include/gc.h
+++ b/nx-X11/programs/Xserver/include/gc.h
@@ -51,7 +51,13 @@ SOFTWARE.
 #define GC_H 
 
 #include <X11/X.h>	/* for GContext, Mask */
+
+#ifndef _XTYPEDEF_POINTER
+/* Don't let Xdefs.h define 'pointer' */
+#define _XTYPEDEF_POINTER       1
+#endif /* _XTYPEDEF_POINTER */
 #include <X11/Xdefs.h>	/* for Bool */
+
 #include <X11/Xproto.h>
 #include "screenint.h"	/* for ScreenPtr */
 #include "pixmap.h"	/* for DrawablePtr */
@@ -103,7 +109,7 @@ extern int DoChangeGC(
 
 typedef union {
     CARD32 val;
-    pointer ptr;
+    void * ptr;
 } ChangeGCVal, *ChangeGCValPtr;
 
 extern int dixChangeGC(
@@ -125,7 +131,7 @@ extern int CopyGC(
     BITS32 /*mask*/);
 
 extern int FreeGC(
-    pointer /*pGC*/,
+    void * /*pGC*/,
     XID /*gid*/);
 
 extern void SetGCMask(
diff --git a/nx-X11/programs/Xserver/include/gcstruct.h b/nx-X11/programs/Xserver/include/gcstruct.h
index c2226ba17..16779f692 100644
--- a/nx-X11/programs/Xserver/include/gcstruct.h
+++ b/nx-X11/programs/Xserver/include/gcstruct.h
@@ -85,7 +85,7 @@ typedef struct _GCFuncs {
     void	(* ChangeClip)(
 		GCPtr /*pGC*/,
 		int /*type*/,
-		pointer /*pvalue*/,
+		void * /*pvalue*/,
 		int /*nrects*/);
 
     void	(* DestroyClip)(
@@ -244,7 +244,7 @@ typedef struct _GCOps {
 		int /*y*/,
 		unsigned int /*nglyph*/,
 		CharInfoPtr * /*ppci*/,
-		pointer /*pglyphBase*/);
+		void * /*pglyphBase*/);
 
     void	(* PolyGlyphBlt)(
 		DrawablePtr /*pDrawable*/,
@@ -253,7 +253,7 @@ typedef struct _GCOps {
 		int /*y*/,
 		unsigned int /*nglyph*/,
 		CharInfoPtr * /*ppci*/,
-		pointer /*pglyphBase*/);
+		void * /*pglyphBase*/);
 
     void	(* PushPixels)(
 		GCPtr /*pGC*/,
@@ -309,7 +309,7 @@ typedef struct _GC {
     struct _Font	*font;
     DDXPointRec		clipOrg;
     DDXPointRec		lastWinOrg;	/* position of window last validated */
-    pointer		clientClip;
+    void *		clientClip;
     unsigned long	stateChanges;	/* masked with GC_<kind> */
     unsigned long       serialNumber;
     GCFuncs		*funcs;
diff --git a/nx-X11/programs/Xserver/include/input.h b/nx-X11/programs/Xserver/include/input.h
index bcaa01e6f..88cc98050 100644
--- a/nx-X11/programs/Xserver/include/input.h
+++ b/nx-X11/programs/Xserver/include/input.h
@@ -104,7 +104,7 @@ typedef void (*DeviceUnwrapProc)(
     );
 
 typedef struct _DeviceRec {
-    pointer	devicePrivate;
+    void *	devicePrivate;
     ProcessInputProc processInputProc;	/* current */
     ProcessInputProc realInputProc;	/* deliver */
     ProcessInputProc enqueueInputProc;	/* enqueue */
@@ -255,7 +255,7 @@ extern Bool InitFocusClassDeviceStruct(
 typedef void (*BellProcPtr)(
     int /*percent*/,
     DeviceIntPtr /*device*/,
-    pointer /*ctrl*/,
+    void * /*ctrl*/,
     int);
 
 typedef void (*KbdCtrlProcPtr)(
diff --git a/nx-X11/programs/Xserver/include/misc.h b/nx-X11/programs/Xserver/include/misc.h
index 849f1b5cc..1576f1433 100644
--- a/nx-X11/programs/Xserver/include/misc.h
+++ b/nx-X11/programs/Xserver/include/misc.h
@@ -81,6 +81,11 @@ extern unsigned long serverGeneration;
 #include <X11/Xfuncproto.h>
 #include <X11/Xmd.h>
 #include <X11/X.h>
+
+#ifndef _XTYPEDEF_POINTER
+/* Don't let Xdefs.h define 'pointer' */
+#define _XTYPEDEF_POINTER       1
+#endif /* _XTYPEDEF_POINTER */
 #include <X11/Xdefs.h>
 
 #ifndef IN_MODULE
diff --git a/nx-X11/programs/Xserver/include/miscstruct.h b/nx-X11/programs/Xserver/include/miscstruct.h
index 6a16007b7..87874aae4 100644
--- a/nx-X11/programs/Xserver/include/miscstruct.h
+++ b/nx-X11/programs/Xserver/include/miscstruct.h
@@ -61,7 +61,7 @@ typedef struct _Box {
 } BoxRec;
 
 typedef union _DevUnion {
-    pointer		ptr;
+    void *		ptr;
     long		val;
     unsigned long	uval;
     RegionPtr   	(*fptr)(
diff --git a/nx-X11/programs/Xserver/include/os.h b/nx-X11/programs/Xserver/include/os.h
index 0b3354eec..551b35097 100644
--- a/nx-X11/programs/Xserver/include/os.h
+++ b/nx-X11/programs/Xserver/include/os.h
@@ -53,7 +53,7 @@ SOFTWARE.
 
 #include "misc.h"
 #define ALLOCATE_LOCAL_FALLBACK(_size) Xalloc((unsigned long)(_size))
-#define DEALLOCATE_LOCAL_FALLBACK(_ptr) Xfree((pointer)(_ptr))
+#define DEALLOCATE_LOCAL_FALLBACK(_ptr) Xfree((void *)(_ptr))
 #include <X11/Xalloca.h>
 #ifndef IN_MODULE
 #include <stdarg.h>
@@ -75,19 +75,19 @@ SOFTWARE.
 #define MAX_BIG_REQUEST_SIZE 4194303
 #endif
 
-typedef pointer	FID;
+typedef void *	FID;
 typedef struct _FontPathRec *FontPathPtr;
 typedef struct _NewClientRec *NewClientPtr;
 
 #ifndef xalloc
 #define xnfalloc(size) XNFalloc((unsigned long)(size))
 #define xnfcalloc(_num, _size) XNFcalloc((unsigned long)(_num)*(unsigned long)(_size))
-#define xnfrealloc(ptr, size) XNFrealloc((pointer)(ptr), (unsigned long)(size))
+#define xnfrealloc(ptr, size) XNFrealloc((void *)(ptr), (unsigned long)(size))
 
 #define xalloc(size) Xalloc((unsigned long)(size))
 #define xcalloc(_num, _size) Xcalloc((unsigned long)(_num)*(unsigned long)(_size))
-#define xrealloc(ptr, size) Xrealloc((pointer)(ptr), (unsigned long)(size))
-#define xfree(ptr) Xfree((pointer)(ptr))
+#define xrealloc(ptr, size) Xrealloc((void *)(ptr), (unsigned long)(size))
+#define xfree(ptr) Xfree((void *)(ptr))
 #define xstrdup(s) Xstrdup(s)
 #define xnfstrdup(s) XNFstrdup(s)
 #endif
@@ -158,7 +158,7 @@ extern char *ClientAuthorized(
 
 extern Bool EstablishNewConnections(
     ClientPtr /*clientUnused*/,
-    pointer /*closure*/);
+    void * /*closure*/);
 
 extern void CheckConnections(void);
 
@@ -189,7 +189,7 @@ extern void AvailableClientInput(ClientPtr /* client */);
 extern CARD32 GetTimeInMillis(void);
 
 extern void AdjustWaitForDelay(
-    pointer /*waitTime*/,
+    void * /*waitTime*/,
     unsigned long /*newdelay*/);
 
 typedef	struct _OsTimerRec *OsTimerPtr;
@@ -197,7 +197,7 @@ typedef	struct _OsTimerRec *OsTimerPtr;
 typedef CARD32 (*OsTimerCallback)(
     OsTimerPtr /* timer */,
     CARD32 /* time */,
-    pointer /* arg */);
+    void * /* arg */);
 
 extern void TimerInit(void);
 
@@ -211,7 +211,7 @@ extern OsTimerPtr TimerSet(
     int /* flags */,
     CARD32 /* millis */,
     OsTimerCallback /* func */,
-    pointer /* arg */);
+    void * /* arg */);
 
 extern void TimerCheck(void);
 extern void TimerCancel(OsTimerPtr /* pTimer */);
@@ -238,19 +238,19 @@ extern void ProcessCommandLine(int /*argc*/, char* /*argv*/[]);
 extern int set_font_authorizations(
     char ** /* authorizations */, 
     int * /*authlen */, 
-    pointer /* client */);
+    void * /* client */);
 
 #ifndef _HAVE_XALLOC_DECLS
 #define _HAVE_XALLOC_DECLS
-extern pointer Xalloc(unsigned long /*amount*/);
-extern pointer Xcalloc(unsigned long /*amount*/);
-extern pointer Xrealloc(pointer /*ptr*/, unsigned long /*amount*/);
-extern void Xfree(pointer /*ptr*/);
+extern void * Xalloc(unsigned long /*amount*/);
+extern void * Xcalloc(unsigned long /*amount*/);
+extern void * Xrealloc(void * /*ptr*/, unsigned long /*amount*/);
+extern void Xfree(void * /*ptr*/);
 #endif
 
-extern pointer XNFalloc(unsigned long /*amount*/);
-extern pointer XNFcalloc(unsigned long /*amount*/);
-extern pointer XNFrealloc(pointer /*ptr*/, unsigned long /*amount*/);
+extern void * XNFalloc(unsigned long /*amount*/);
+extern void * XNFcalloc(unsigned long /*amount*/);
+extern void * XNFrealloc(void * /*ptr*/, unsigned long /*amount*/);
 
 extern void OsInitAllocator(void);
 
@@ -296,10 +296,10 @@ void OsReleaseSignals (void);
 
 #if !defined(WIN32) && !defined(__UNIXOS2__)
 extern int System(char *);
-extern pointer Popen(char *, char *);
-extern int Pclose(pointer);
-extern pointer Fopen(char *, char *);
-extern int Fclose(pointer);
+extern void * Popen(char *, char *);
+extern int Pclose(void *);
+extern void * Fopen(char *, char *);
+extern int Fclose(void *);
 #else
 #define System(a) system(a)
 #define Popen(a,b) popen(a,b)
@@ -315,24 +315,24 @@ extern int AddHost(
     ClientPtr	/*client*/,
     int         /*family*/,
     unsigned    /*length*/,
-    pointer     /*pAddr*/);
+    void *     /*pAddr*/);
 
 extern Bool ForEachHostInFamily (
     int	    /*family*/,
     Bool    (* /*func*/ )(
             unsigned char * /* addr */,
             short           /* len */,
-            pointer         /* closure */),
-    pointer /*closure*/);
+            void *         /* closure */),
+    void * /*closure*/);
 
 extern int RemoveHost(
     ClientPtr	/*client*/,
     int         /*family*/,
     unsigned    /*length*/,
-    pointer     /*pAddr*/);
+    void *     /*pAddr*/);
 
 extern int GetHosts(
-    pointer * /*data*/,
+    void ** /*data*/,
     int	    * /*pnHosts*/,
     int	    * /*pLen*/,
     BOOL    * /*pEnabled*/);
@@ -362,7 +362,7 @@ extern void AccessUsingXdmcp(void);
 
 extern void DefineSelf(int /*fd*/);
 
-extern void AugmentSelf(pointer /*from*/, int /*len*/);
+extern void AugmentSelf(void * /*from*/, int /*len*/);
 
 extern void InitAuthorization(char * /*filename*/);
 
@@ -467,7 +467,7 @@ typedef struct {
 extern CallbackListPtr ReplyCallback;
 typedef struct {
     ClientPtr client;
-    pointer replyData;
+    void * replyData;
     unsigned long dataLenBytes;
     unsigned long bytesRemaining;
     Bool startOfReply;
diff --git a/nx-X11/programs/Xserver/include/pixmap.h b/nx-X11/programs/Xserver/include/pixmap.h
index 6cea329ec..3c9f91a00 100644
--- a/nx-X11/programs/Xserver/include/pixmap.h
+++ b/nx-X11/programs/Xserver/include/pixmap.h
@@ -92,7 +92,7 @@ extern PixmapPtr GetScratchPixmapHeader(
     int /*depth*/,
     int /*bitsPerPixel*/,
     int /*devKind*/,
-    pointer /*pPixData*/);
+    void * /*pPixData*/);
 
 extern void FreeScratchPixmapHeader(
     PixmapPtr /*pPixmap*/);
diff --git a/nx-X11/programs/Xserver/include/property.h b/nx-X11/programs/Xserver/include/property.h
index 21a38d51c..080d52937 100644
--- a/nx-X11/programs/Xserver/include/property.h
+++ b/nx-X11/programs/Xserver/include/property.h
@@ -61,7 +61,7 @@ extern int ChangeWindowProperty(
     int /*format*/,
     int /*mode*/,
     unsigned long /*len*/,
-    pointer /*value*/,
+    void * /*value*/,
     Bool /*sendevent*/);
 
 extern int DeleteProperty(
diff --git a/nx-X11/programs/Xserver/include/propertyst.h b/nx-X11/programs/Xserver/include/propertyst.h
index 177fca171..8f9abd5f8 100644
--- a/nx-X11/programs/Xserver/include/propertyst.h
+++ b/nx-X11/programs/Xserver/include/propertyst.h
@@ -61,7 +61,7 @@ typedef struct _Property {
 	ATOM		type;       /* ignored by server */
 	short		format;     /* format of data for swapping - 8,16,32 */
 	long		size;       /* size of data in (format/8) bytes */
-	pointer         data;       /* private to client */
+	void            *data;       /* private to client */
 #if defined(LBX) || defined(LBX_COMPAT)
 	/*  If space is at a premium and binary compatibility is not
 	 *  an issue, you may want to put the owner_pid next to format
diff --git a/nx-X11/programs/Xserver/include/resource.h b/nx-X11/programs/Xserver/include/resource.h
index 49c189869..3aac8bb00 100644
--- a/nx-X11/programs/Xserver/include/resource.h
+++ b/nx-X11/programs/Xserver/include/resource.h
@@ -123,24 +123,24 @@ typedef unsigned long RESTYPE;
 #define BAD_RESOURCE 0xe0000000
 
 typedef int (*DeleteType)(
-    pointer /*value*/,
+    void * /*value*/,
     XID /*id*/);
 
 typedef void (*FindResType)(
-    pointer /*value*/,
+    void * /*value*/,
     XID /*id*/,
-    pointer /*cdata*/);
+    void * /*cdata*/);
 
 typedef void (*FindAllRes)(
-    pointer /*value*/,
+    void * /*value*/,
     XID /*id*/,
     RESTYPE /*type*/,
-    pointer /*cdata*/);
+    void * /*cdata*/);
 
 typedef Bool (*FindComplexResType)(
-    pointer /*value*/,
+    void * /*value*/,
     XID /*id*/,
-    pointer /*cdata*/);
+    void * /*cdata*/);
 
 extern RESTYPE CreateNewResourceType(
     DeleteType /*deleteFunc*/);
@@ -161,7 +161,7 @@ extern XID FakeClientID(
 extern Bool AddResource(
     XID /*id*/,
     RESTYPE /*type*/,
-    pointer /*value*/);
+    void * /*value*/);
 
 extern void FreeResource(
     XID /*id*/,
@@ -175,18 +175,18 @@ extern void FreeResourceByType(
 extern Bool ChangeResourceValue(
     XID /*id*/,
     RESTYPE /*rtype*/,
-    pointer /*value*/);
+    void * /*value*/);
 
 extern void FindClientResourcesByType(
     ClientPtr /*client*/,
     RESTYPE /*type*/,
     FindResType /*func*/,
-    pointer /*cdata*/);
+    void * /*cdata*/);
 
 extern void FindAllClientResources(
     ClientPtr /*client*/,
     FindAllRes /*func*/,
-    pointer /*cdata*/);
+    void * /*cdata*/);
 
 extern void FreeClientNeverRetainResources(
     ClientPtr /*client*/);
@@ -200,19 +200,19 @@ extern Bool LegalNewID(
     XID /*id*/,
     ClientPtr /*client*/);
 
-extern pointer LookupIDByType(
+extern void * LookupIDByType(
     XID /*id*/,
     RESTYPE /*rtype*/);
 
-extern pointer LookupIDByClass(
+extern void * LookupIDByClass(
     XID /*id*/,
     RESTYPE /*classes*/);
 
-extern pointer LookupClientResourceComplex(
+extern void * LookupClientResourceComplex(
     ClientPtr client,
     RESTYPE type,
     FindComplexResType func,
-    pointer cdata);
+    void * cdata);
 
 /* These are the access modes that can be passed in the last parameter
  * to SecurityLookupIDByType/Class.  The Security extension doesn't
@@ -229,13 +229,13 @@ extern pointer LookupClientResourceComplex(
 
 #ifdef XCSECURITY
 
-extern pointer SecurityLookupIDByType(
+extern void * SecurityLookupIDByType(
     ClientPtr /*client*/,
     XID /*id*/,
     RESTYPE /*rtype*/,
     Mask /*access_mode*/);
 
-extern pointer SecurityLookupIDByClass(
+extern void * SecurityLookupIDByClass(
     ClientPtr /*client*/,
     XID /*id*/,
     RESTYPE /*classes*/,
diff --git a/nx-X11/programs/Xserver/include/scrnintstr.h b/nx-X11/programs/Xserver/include/scrnintstr.h
index ef9358689..297227493 100644
--- a/nx-X11/programs/Xserver/include/scrnintstr.h
+++ b/nx-X11/programs/Xserver/include/scrnintstr.h
@@ -85,8 +85,8 @@ typedef struct _Depth {
 
 
 /*
- *  There is a typedef for each screen function pointer so that code that
- *  needs to declare a screen function pointer (e.g. in a screen private
+ *  There is a typedef for each screen function void * so that code that
+ *  needs to declare a screen function void * (e.g. in a screen private
  *  or as a local variable) can easily do so and retain full type checking.
  */
 
@@ -431,15 +431,15 @@ typedef    void (* SendGraphicsExposeProcPtr)(
 
 typedef    void (* ScreenBlockHandlerProcPtr)(
 	int /*screenNum*/,
-	pointer /*blockData*/,
-	pointer /*pTimeout*/,
-	pointer /*pReadmask*/);
+	void * /*blockData*/,
+	void * /*pTimeout*/,
+	void * /*pReadmask*/);
 
 typedef    void (* ScreenWakeupHandlerProcPtr)(
 	 int /*screenNum*/,
-	 pointer /*wakeupData*/,
+	 void * /*wakeupData*/,
 	 unsigned long /*result*/,
-	 pointer /*pReadMask*/);
+	 void * /*pReadMask*/);
 
 typedef    Bool (* CreateScreenResourcesProcPtr)(
 	ScreenPtr /*pScreen*/);
@@ -451,7 +451,7 @@ typedef    Bool (* ModifyPixmapHeaderProcPtr)(
 	int /*depth*/,
 	int /*bitsPerPixel*/,
 	int /*devKind*/,
-	pointer /*pPixData*/);
+	void * /*pPixData*/);
 
 typedef    PixmapPtr (* GetWindowPixmapProcPtr)(
 	WindowPtr /*pWin*/);
@@ -546,7 +546,7 @@ typedef struct _Screen {
 			   a standard one.
 			*/
     PixmapPtr		PixmapPerDepth[1];
-    pointer		devPrivate;
+    void *		devPrivate;
     short       	numVisuals;
     VisualPtr		visuals;
     int			WindowPrivateLen;
@@ -668,8 +668,8 @@ typedef struct _Screen {
     ScreenBlockHandlerProcPtr	BlockHandler;
     ScreenWakeupHandlerProcPtr	WakeupHandler;
 
-    pointer blockData;
-    pointer wakeupData;
+    void * blockData;
+    void * wakeupData;
 
     /* anybody can get a piece of this array */
     DevUnion	*devPrivates;
diff --git a/nx-X11/programs/Xserver/include/window.h b/nx-X11/programs/Xserver/include/window.h
index 7c3fce092..cbfed645f 100644
--- a/nx-X11/programs/Xserver/include/window.h
+++ b/nx-X11/programs/Xserver/include/window.h
@@ -73,17 +73,17 @@ typedef struct _Window *WindowPtr;
 
 typedef int (*VisitWindowProcPtr)(
     WindowPtr /*pWin*/,
-    pointer /*data*/);
+    void * /*data*/);
 
 extern int TraverseTree(
     WindowPtr /*pWin*/,
     VisitWindowProcPtr /*func*/,
-    pointer /*data*/);
+    void * /*data*/);
 
 extern int WalkTree(
     ScreenPtr /*pScreen*/,
     VisitWindowProcPtr /*func*/,
-    pointer /*data*/);
+    void * /*data*/);
 
 extern WindowPtr AllocateWindow(
     ScreenPtr /*pScreen*/);
@@ -122,7 +122,7 @@ extern WindowPtr CreateWindow(
     int* /*error*/);
 
 extern int DeleteWindow(
-    pointer /*pWin*/,
+    void * /*pWin*/,
     XID /*wid*/);
 
 extern void DestroySubwindows(
diff --git a/nx-X11/programs/Xserver/include/windowstr.h b/nx-X11/programs/Xserver/include/windowstr.h
index 89e3ee10b..dab6fcf71 100644
--- a/nx-X11/programs/Xserver/include/windowstr.h
+++ b/nx-X11/programs/Xserver/include/windowstr.h
@@ -114,7 +114,7 @@ typedef struct _Window {
     Mask		eventMask;
     PixUnion		background;
     PixUnion		border;
-    pointer		backStorage;	/* null when BS disabled */
+    void *		backStorage;	/* null when BS disabled */
     WindowOptPtr	optional;
     unsigned		backgroundState:2; /* None, Relative, Pixel, Pixmap */
     unsigned		borderIsPixel:1;
diff --git a/nx-X11/programs/Xserver/mfb/maskbits.h b/nx-X11/programs/Xserver/mfb/maskbits.h
index ed5cc2687..7e2b74a18 100644
--- a/nx-X11/programs/Xserver/mfb/maskbits.h
+++ b/nx-X11/programs/Xserver/mfb/maskbits.h
@@ -534,7 +534,7 @@ extern PixelType mfbGetmask(int);
 #endif
 
 #if GETLEFTBITS_ALIGNMENT == 1
-#define getleftbits(psrc, w, dst)	dst = *((CARD32 *)(pointer) psrc)
+#define getleftbits(psrc, w, dst)	dst = *((CARD32 *)(void *) psrc)
 #endif /* GETLEFTBITS_ALIGNMENT == 1 */
 
 #if GETLEFTBITS_ALIGNMENT == 2
diff --git a/nx-X11/programs/Xserver/mi/mi.h b/nx-X11/programs/Xserver/mi/mi.h
index 3c85693dc..0f3f5778f 100644
--- a/nx-X11/programs/Xserver/mi/mi.h
+++ b/nx-X11/programs/Xserver/mi/mi.h
@@ -263,7 +263,7 @@ extern void miPolyGlyphBlt(
     int /*y*/,
     unsigned int /*nglyph*/,
     CharInfoPtr * /*ppci*/,
-    pointer /*pglyphBase*/
+    void * /*pglyphBase*/
 );
 
 extern void miImageGlyphBlt(
@@ -273,7 +273,7 @@ extern void miImageGlyphBlt(
     int /*y*/,
     unsigned int /*nglyph*/,
     CharInfoPtr * /*ppci*/,
-    pointer /*pglyphBase*/
+    void * /*pglyphBase*/
 );
 
 /* mipoly.c */
@@ -438,7 +438,7 @@ extern Bool miModifyPixmapHeader(
     int /*depth*/,
     int /*bitsPerPixel*/,
     int /*devKind*/,
-    pointer /*pPixData*/
+    void * /*pPixData*/
 );
 
 extern Bool miCloseScreen(
@@ -453,12 +453,12 @@ extern Bool miCreateScreenResources(
 extern Bool miScreenDevPrivateInit(
     ScreenPtr /*pScreen*/,
     int /*width*/,
-    pointer /*pbits*/
+    void * /*pbits*/
 );
 
 extern Bool miScreenInit(
     ScreenPtr /*pScreen*/,
-    pointer /*pbits*/,
+    void * /*pbits*/,
     int /*xsize*/,
     int /*ysize*/,
     int /*dpix*/,
diff --git a/nx-X11/programs/Xserver/mi/miarc.c b/nx-X11/programs/Xserver/mi/miarc.c
index 08f09b628..f06c4b51d 100644
--- a/nx-X11/programs/Xserver/mi/miarc.c
+++ b/nx-X11/programs/Xserver/mi/miarc.c
@@ -435,7 +435,7 @@ static RESTYPE cacheType;
 /*ARGSUSED*/
 int
 miFreeArcCache (data, id)
-    pointer	    data;
+    void *	    data;
     XID		    id;
 {
     int k;
@@ -1691,7 +1691,7 @@ miGetArcPts(
     count++;
 
     cdt = 2 * miDcos(dt);
-    if (!(poly = (SppPointPtr) xrealloc((pointer)*ppPts,
+    if (!(poly = (SppPointPtr) xrealloc((void *)*ppPts,
 					(cpt + count) * sizeof(SppPointRec))))
 	return(0);
     *ppPts = poly;
diff --git a/nx-X11/programs/Xserver/mi/mibank.c b/nx-X11/programs/Xserver/mi/mibank.c
index b09f9fd7c..b5da2267f 100644
--- a/nx-X11/programs/Xserver/mi/mibank.c
+++ b/nx-X11/programs/Xserver/mi/mibank.c
@@ -111,7 +111,7 @@ typedef struct _miBankScreen
     int           nBanks, maxRects;
     RegionPtr     *pBanks;
 
-    pointer       pbits;
+    void          *pbits;
 
     /*
      * Screen Wrappers
@@ -192,11 +192,11 @@ static unsigned long miBankGeneration = 0;
 #define BANK_GCPRIVATE(pGC) ((miBankGCPtr)(BANK_GCPRIVLVAL(pGC)))
 
 #define PIXMAP_STATUS(_pPix) \
-    pointer pbits = (_pPix)->devPrivate.ptr
+    void * pbits = (_pPix)->devPrivate.ptr
 
 #define PIXMAP_SAVE(_pPix) \
     PIXMAP_STATUS(_pPix); \
-    if (pbits == (pointer)pScreenPriv) \
+    if (pbits == (void *)pScreenPriv) \
         (_pPix)->devPrivate.ptr = pScreenPriv->pbits
 
 #define PIXMAP_RESTORE(_pPix) \
@@ -247,7 +247,7 @@ static unsigned long miBankGeneration = 0;
     (pGC)->funcs          = pGCPriv->unwrappedFuncs
 
 #define IS_BANKED(pDrawable) \
-    ((pbits == (pointer)pScreenPriv) && \
+    ((pbits == (void *)pScreenPriv) && \
      (((DrawablePtr)(pDrawable))->type == DRAWABLE_WINDOW))
 
 #define CLIP_SAVE \
@@ -1267,7 +1267,7 @@ miBankImageGlyphBlt(
     int          y,
     unsigned int nArray,
     CharInfoPtr  *ppci,
-    pointer      pglyphBase
+    void         *pglyphBase
 )
 {
     GCOP_SIMPLE((*pGC->ops->ImageGlyphBlt)(pDrawable, pGC,
@@ -1282,7 +1282,7 @@ miBankPolyGlyphBlt(
     int          y,
     unsigned int nArray,
     CharInfoPtr  *ppci,
-    pointer      pglyphBase
+    void         *pglyphBase
 )
 {
     GCOP_SIMPLE((*pGC->ops->PolyGlyphBlt)(pDrawable, pGC,
@@ -1539,7 +1539,7 @@ static void
 miBankChangeClip(
     GCPtr   pGC,
     int     type,
-    pointer pvalue,
+    void * pvalue,
     int     nrects
 )
 {
@@ -1608,7 +1608,7 @@ miBankCreateScreenResources(
         /* Set screen buffer address to something recognizable */
         pScreenPriv->pScreenPixmap = (*pScreen->GetScreenPixmap)(pScreen);
         pScreenPriv->pbits = pScreenPriv->pScreenPixmap->devPrivate.ptr;
-        pScreenPriv->pScreenPixmap->devPrivate.ptr = (pointer)pScreenPriv;
+        pScreenPriv->pScreenPixmap->devPrivate.ptr = (void *)pScreenPriv;
 
         /* Get shadow pixmap;  width & height of 0 means no pixmap data */
         pScreenPriv->pBankPixmap = (*pScreen->CreatePixmap)(pScreen, 0, 0,
@@ -1657,7 +1657,7 @@ miBankModifyPixmapHeader(
     int       depth,
     int       bitsPerPixel,
     int       devKind,
-    pointer   pPixData
+    void      *pPixData
 )
 {
     Bool retval = FALSE;
@@ -1675,7 +1675,7 @@ miBankModifyPixmapHeader(
 
         SCREEN_WRAP(ModifyPixmapHeader, miBankModifyPixmapHeader);
 
-        if (pbits == (pointer)pScreenPriv)
+        if (pbits == (void *)pScreenPriv)
         {
             pScreenPriv->pbits = pPixmap->devPrivate.ptr;
             pPixmap->devPrivate.ptr = pbits;
@@ -2395,7 +2395,7 @@ miInitializeBanking(
     pScreen->BackingStoreFuncs.SetClipmaskRgn = miBankSetClipmaskRgn;
     ?????????????????????????????????????????????????????????????? */
 
-    BANK_SCRPRIVLVAL = (pointer)pScreenPriv;
+    BANK_SCRPRIVLVAL = (void *)pScreenPriv;
 
     return TRUE;
 }
@@ -2405,7 +2405,7 @@ miInitializeBanking(
 static int
 miBankNewSerialNumber(
     WindowPtr pWin,
-    pointer   unused
+    void      *unused
 )
 {
     pWin->drawable.serialNumber = NEXT_SERIAL_NUMBER;
diff --git a/nx-X11/programs/Xserver/mi/mibank.h b/nx-X11/programs/Xserver/mi/mibank.h
index cf27d1fae..26b33305a 100644
--- a/nx-X11/programs/Xserver/mi/mibank.h
+++ b/nx-X11/programs/Xserver/mi/mibank.h
@@ -70,8 +70,8 @@ typedef struct _miBankInfo
     miBankProcPtr SetDestinationBank;           /* Set pBankB bank number */
     miBankProcPtr SetSourceAndDestinationBanks; /* Set both bank numbers */
 
-    pointer pBankA;     /* First aperture location */
-    pointer pBankB;     /* First or second aperture location */
+    void * pBankA;     /* First aperture location */
+    void * pBankB;     /* First or second aperture location */
 
     /*
      * BankSize is in units of sizeof(char) and is the size of each bank.
diff --git a/nx-X11/programs/Xserver/mi/mibstore.c b/nx-X11/programs/Xserver/mi/mibstore.c
index 98947217c..f18648f66 100644
--- a/nx-X11/programs/Xserver/mi/mibstore.c
+++ b/nx-X11/programs/Xserver/mi/mibstore.c
@@ -228,7 +228,7 @@ static void miBSValidateGC(GCPtr pGC, unsigned long stateChanges,
 static void miBSCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst);
 static void miBSDestroyGC(GCPtr pGC);
 static void miBSChangeGC(GCPtr pGC, unsigned long mask);
-static void miBSChangeClip(GCPtr pGC, int type, pointer pvalue, int nrects);
+static void miBSChangeClip(GCPtr pGC, int type, void * pvalue, int nrects);
 static void miBSDestroyClip(GCPtr pGC);
 static void miBSCopyClip(GCPtr pgcDst, GCPtr pgcSrc);
 
@@ -286,10 +286,10 @@ static void	    miBSImageText16(DrawablePtr pDrawable, GCPtr pGC,
 				    unsigned short *chars);
 static void	    miBSImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
 				      int x, int y, unsigned int nglyph,
-				      CharInfoPtr *ppci, pointer pglyphBase);
+				      CharInfoPtr *ppci, void * pglyphBase);
 static void	    miBSPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
 				     int x, int y, unsigned int nglyph,
-				     CharInfoPtr *ppci, pointer pglyphBase);
+				     CharInfoPtr *ppci, void * pglyphBase);
 static void	    miBSPushPixels(GCPtr pGC, PixmapPtr pBitMap,
 				   DrawablePtr pDst, int w, int h,
 				   int x, int y);
@@ -330,7 +330,7 @@ static void miBSCheapValidateGC(GCPtr pGC, unsigned long stateChanges,
 static void miBSCheapCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst);
 static void miBSCheapDestroyGC(GCPtr pGC);
 static void miBSCheapChangeGC(GCPtr pGC, unsigned long mask);
-static void miBSCheapChangeClip(GCPtr pGC, int type, pointer pvalue,
+static void miBSCheapChangeClip(GCPtr pGC, int type, void * pvalue,
 				int nrects);
 static void miBSCheapDestroyClip(GCPtr pGC);
 static void miBSCheapCopyClip(GCPtr pgcDst, GCPtr pgcSrc);
@@ -398,7 +398,7 @@ miInitializeBackingStore (pScreen)
     pScreen->ClearBackingStore = miBSClearBackingStore;
     pScreen->DrawGuarantee = miBSDrawGuarantee;
 
-    pScreen->devPrivates[miBSScreenIndex].ptr = (pointer) pScreenPriv;
+    pScreen->devPrivates[miBSScreenIndex].ptr = (void *) pScreenPriv;
 }
 
 /*
@@ -433,7 +433,7 @@ miBSCloseScreen (i, pScreen)
     pScreen->ChangeWindowAttributes = pScreenPriv->ChangeWindowAttributes;
     pScreen->CreateGC = pScreenPriv->CreateGC;
 
-    xfree ((pointer) pScreenPriv);
+    xfree ((void *) pScreenPriv);
 
     return (*pScreen->CloseScreen) (i, pScreen);
 }
@@ -765,7 +765,7 @@ miBSCreateGC (pGC)
     
     if ( (ret = (*pScreen->CreateGC) (pGC)) )
     {
-    	pGC->devPrivates[miBSGCIndex].ptr = (pointer) pGC->funcs;
+	pGC->devPrivates[miBSGCIndex].ptr = (void *) pGC->funcs;
     	pGC->funcs = &miBSCheapGCFuncs;
     }
 
@@ -816,7 +816,7 @@ miBSCheapValidateGC (pGC, stateChanges, pDrawable)
 	(*pGC->funcs->ValidateGC) (pGC, stateChanges, pDrawable);
 
 	/* rewrap funcs as Validate may have changed them */
-	pGC->devPrivates[miBSGCIndex].ptr = (pointer) pGC->funcs;
+	pGC->devPrivates[miBSGCIndex].ptr = (void *) pGC->funcs;
 
 	CHEAP_FUNC_EPILOGUE (pGC);
     }
@@ -861,7 +861,7 @@ static void
 miBSCheapChangeClip (pGC, type, pvalue, nrects)
     GCPtr   pGC;
     int		type;
-    pointer	pvalue;
+    void *	pvalue;
     int		nrects;
 {
     CHEAP_FUNC_PROLOGUE (pGC);
@@ -914,7 +914,7 @@ miBSCreateGCPrivate (pGC)
     pPriv->wrapFuncs = pGC->funcs;
     pGC->funcs = &miBSGCFuncs;
     pGC->ops = &miBSGCOps;
-    pGC->devPrivates[miBSGCIndex].ptr = (pointer) pPriv;
+    pGC->devPrivates[miBSGCIndex].ptr = (void *) pPriv;
     return TRUE;
 }
 
@@ -926,12 +926,12 @@ miBSDestroyGCPrivate (GCPtr pGC)
     pPriv = (miBSGCRec *) pGC->devPrivates[miBSGCIndex].ptr;
     if (pPriv)
     {
-	pGC->devPrivates[miBSGCIndex].ptr = (pointer) pPriv->wrapFuncs;
+	pGC->devPrivates[miBSGCIndex].ptr = (void *) pPriv->wrapFuncs;
 	pGC->funcs = &miBSCheapGCFuncs;
 	pGC->ops = pPriv->wrapOps;
 	if (pPriv->pBackingGC)
 	    FreeGC (pPriv->pBackingGC, (GContext) 0);
-	xfree ((pointer) pPriv);
+	xfree ((void *) pPriv);
     }
 }
 
@@ -2157,7 +2157,7 @@ miBSImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
     int 	x, y;
     unsigned int nglyph;
     CharInfoPtr *ppci;		/* array of character info */
-    pointer 	pglyphBase;	/* start of array of glyphs */
+    void * 	pglyphBase;	/* start of array of glyphs */
 {
     SETUP_BACKING (pDrawable, pGC);
     PROLOGUE(pGC);
@@ -2189,7 +2189,7 @@ miBSPolyGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
     int 	x, y;
     unsigned int nglyph;
     CharInfoPtr *ppci;		/* array of character info */
-    pointer	pglyphBase;	/* start of array of glyphs */
+    void *	pglyphBase;	/* start of array of glyphs */
 {
     SETUP_BACKING (pDrawable, pGC);
     PROLOGUE(pGC);
@@ -2287,7 +2287,7 @@ miBSClearBackingStore(pWin, x, y, w, h, generateExposures)
     GCPtr   	  	pGC;
     int	    	  	ts_x_origin,
 			ts_y_origin;
-    pointer    	  	gcvalues[4];
+    void    	  	*gcvalues[4];
     unsigned long 	gcmask;
     xRectangle	  	*rects;
     BoxPtr  	  	pBox;
@@ -2373,18 +2373,18 @@ miBSClearBackingStore(pWin, x, y, w, h, generateExposures)
 	    
 		if (backgroundState == BackgroundPixel)
 		{
-		    gcvalues[0] = (pointer) background.pixel;
-		    gcvalues[1] = (pointer)FillSolid;
+		    gcvalues[0] = (void *) background.pixel;
+		    gcvalues[1] = (void *)FillSolid;
 		    gcmask = GCForeground|GCFillStyle;
 		}
 		else
 		{
-		    gcvalues[0] = (pointer)FillTiled;
-		    gcvalues[1] = (pointer) background.pixmap;
+		    gcvalues[0] = (void *)FillTiled;
+		    gcvalues[1] = (void *) background.pixmap;
 		    gcmask = GCFillStyle|GCTile;
 		}
-		gcvalues[2] = (pointer)(long)(ts_x_origin - pBackingStore->x);
-		gcvalues[3] = (pointer)(long)(ts_y_origin - pBackingStore->y);
+		gcvalues[2] = (void *)(long)(ts_x_origin - pBackingStore->x);
+		gcvalues[3] = (void *)(long)(ts_y_origin - pBackingStore->y);
 		gcmask |= GCTileStipXOrigin|GCTileStipYOrigin;
 		DoChangeGC(pGC, gcmask, (XID *)gcvalues, TRUE);
 		ValidateGC((DrawablePtr)pBackingStore->pBackingPixmap, pGC);
@@ -2477,7 +2477,7 @@ miBSFillVirtualBits (pDrawable, pGC, pRgn, x, y, state, pixunion, planeMask)
 {
     int		i;
     BITS32	gcmask;
-    pointer	gcval[5];
+    void *	gcval[5];
     xRectangle	*pRect;
     BoxPtr	pBox;
     WindowPtr	pWin;
@@ -2498,18 +2498,18 @@ miBSFillVirtualBits (pDrawable, pGC, pRgn, x, y, state, pixunion, planeMask)
     }
     i = 0;
     gcmask = 0;
-    gcval[i++] = (pointer)planeMask;
+    gcval[i++] = (void *)planeMask;
     gcmask |= GCPlaneMask;
     if (state == BackgroundPixel)
     {
 	if (pGC->fgPixel != pixunion.pixel)
 	{
-	    gcval[i++] = (pointer)pixunion.pixel;
+	    gcval[i++] = (void *)pixunion.pixel;
 	    gcmask |= GCForeground;
 	}
 	if (pGC->fillStyle != FillSolid)
 	{
-	    gcval[i++] = (pointer)FillSolid;
+	    gcval[i++] = (void *)FillSolid;
 	    gcmask |= GCFillStyle;
 	}
     }
@@ -2517,22 +2517,22 @@ miBSFillVirtualBits (pDrawable, pGC, pRgn, x, y, state, pixunion, planeMask)
     {
 	if (pGC->fillStyle != FillTiled)
 	{
-	    gcval[i++] = (pointer)FillTiled;
+	    gcval[i++] = (void *)FillTiled;
 	    gcmask |= GCFillStyle;
 	}
 	if (pGC->tileIsPixel || pGC->tile.pixmap != pixunion.pixmap)
 	{
-	    gcval[i++] = (pointer)pixunion.pixmap;
+	    gcval[i++] = (void *)pixunion.pixmap;
 	    gcmask |= GCTile;
 	}
 	if (pGC->patOrg.x != x)
 	{
-	    gcval[i++] = (pointer)(long)x;
+	    gcval[i++] = (void *)(long)x;
 	    gcmask |= GCTileStipXOrigin;
 	}
 	if (pGC->patOrg.y != y)
 	{
-	    gcval[i++] = (pointer)(long)y;
+	    gcval[i++] = (void *)(long)y;
 	    gcmask |= GCTileStipYOrigin;
 	}
     }
@@ -2592,7 +2592,7 @@ miBSAllocate(pWin)
 	pBackingStore->viewable = (char)pWin->viewable;
 	pBackingStore->status = StatusNoPixmap;
 	pBackingStore->backgroundState = None;
-	pWin->backStorage = (pointer) pBackingStore;
+	pWin->backStorage = (void *) pBackingStore;
     }
 	
     /*
@@ -3622,7 +3622,7 @@ static void
 miBSChangeClip(pGC, type, pvalue, nrects)
     GCPtr	pGC;
     int		type;
-    pointer	pvalue;
+    void *	pvalue;
     int		nrects;
 {
     miBSGCPtr	pPriv = (miBSGCPtr) (pGC)->devPrivates[miBSGCIndex].ptr;
diff --git a/nx-X11/programs/Xserver/mi/midispcur.c b/nx-X11/programs/Xserver/mi/midispcur.c
index 080ac1c59..d71234ffe 100644
--- a/nx-X11/programs/Xserver/mi/midispcur.c
+++ b/nx-X11/programs/Xserver/mi/midispcur.c
@@ -151,11 +151,11 @@ miDCInitialize (pScreen, screenFuncs)
     pScreenPriv->CloseScreen = pScreen->CloseScreen;
     pScreen->CloseScreen = miDCCloseScreen;
     
-    pScreen->devPrivates[miDCScreenIndex].ptr = (pointer) pScreenPriv;
+    pScreen->devPrivates[miDCScreenIndex].ptr = (void *) pScreenPriv;
 
     if (!miSpriteInitialize (pScreen, &miDCFuncs, screenFuncs))
     {
-	xfree ((pointer) pScreenPriv);
+	xfree ((void *) pScreenPriv);
 	return FALSE;
     }
     return TRUE;
@@ -187,7 +187,7 @@ miDCCloseScreen (index, pScreen)
     tossPict (pScreenPriv->pRootPicture);
     tossPict (pScreenPriv->pTempPicture);
 #endif
-    xfree ((pointer) pScreenPriv);
+    xfree ((void *) pScreenPriv);
     return (*pScreen->CloseScreen) (index, pScreen);
 }
 
@@ -197,7 +197,7 @@ miDCRealizeCursor (pScreen, pCursor)
     CursorPtr	pCursor;
 {
     if (pCursor->bits->refcnt <= 1)
-	pCursor->bits->devPriv[pScreen->myNum] = (pointer)NULL;
+	pCursor->bits->devPriv[pScreen->myNum] = (void *)NULL;
     return TRUE;
 }
 
@@ -263,7 +263,7 @@ miDCRealize (
 	pFormat = PictureMatchFormat (pScreen, 32, PICT_a8r8g8b8);
 	if (!pFormat)
 	{
-	    xfree ((pointer) pPriv);
+	    xfree ((void *) pPriv);
 	    return (miDCCursorPtr)NULL;
 	}
 	
@@ -273,14 +273,14 @@ miDCRealize (
 					    pCursor->bits->height, 32);
 	if (!pPixmap)
 	{
-	    xfree ((pointer) pPriv);
+	    xfree ((void *) pPriv);
 	    return (miDCCursorPtr)NULL;
 	}
 	pGC = GetScratchGC (32, pScreen);
 	if (!pGC)
 	{
 	    (*pScreen->DestroyPixmap) (pPixmap);
-	    xfree ((pointer) pPriv);
+	    xfree ((void *) pPriv);
 	    return (miDCCursorPtr)NULL;
 	}
 	ValidateGC (&pPixmap->drawable, pGC);
@@ -294,10 +294,10 @@ miDCRealize (
         (*pScreen->DestroyPixmap) (pPixmap);
 	if (!pPriv->pPicture)
 	{
-	    xfree ((pointer) pPriv);
+	    xfree ((void *) pPriv);
 	    return (miDCCursorPtr)NULL;
 	}
-	pCursor->bits->devPriv[pScreen->myNum] = (pointer) pPriv;
+	pCursor->bits->devPriv[pScreen->myNum] = (void *) pPriv;
 	return pPriv;
     }
     pPriv->pPicture = 0;
@@ -305,17 +305,17 @@ miDCRealize (
     pPriv->sourceBits = (*pScreen->CreatePixmap) (pScreen, pCursor->bits->width, pCursor->bits->height, 1);
     if (!pPriv->sourceBits)
     {
-	xfree ((pointer) pPriv);
+	xfree ((void *) pPriv);
 	return (miDCCursorPtr)NULL;
     }
     pPriv->maskBits =  (*pScreen->CreatePixmap) (pScreen, pCursor->bits->width, pCursor->bits->height, 1);
     if (!pPriv->maskBits)
     {
 	(*pScreen->DestroyPixmap) (pPriv->sourceBits);
-	xfree ((pointer) pPriv);
+	xfree ((void *) pPriv);
 	return (miDCCursorPtr)NULL;
     }
-    pCursor->bits->devPriv[pScreen->myNum] = (pointer) pPriv;
+    pCursor->bits->devPriv[pScreen->myNum] = (void *) pPriv;
 
     /* create the two sets of bits, clipping as appropriate */
 
@@ -372,8 +372,8 @@ miDCUnrealizeCursor (pScreen, pCursor)
 	if (pPriv->pPicture)
 	    FreePicture (pPriv->pPicture, 0);
 #endif
-	xfree ((pointer) pPriv);
-	pCursor->bits->devPriv[pScreen->myNum] = (pointer)NULL;
+	xfree ((void *) pPriv);
+	pCursor->bits->devPriv[pScreen->myNum] = (void *)NULL;
     }
     return TRUE;
 }
diff --git a/nx-X11/programs/Xserver/mi/miexpose.c b/nx-X11/programs/Xserver/mi/miexpose.c
index 2be6b2264..f3dae5768 100644
--- a/nx-X11/programs/Xserver/mi/miexpose.c
+++ b/nx-X11/programs/Xserver/mi/miexpose.c
@@ -618,7 +618,7 @@ static GCPtr	screenContext[MAXSCREENS];
 /*ARGSUSED*/
 static int
 tossGC (
-    pointer value,
+    void * value,
     XID id)
 {
     GCPtr pGC = (GCPtr)value;
@@ -684,7 +684,7 @@ int what;
 	    gcmask |= GCForeground | GCFillStyle;
 	    break;
 	case BackgroundPixmap:
-	    newValues[TILE].ptr = (pointer)pWin->background.pixmap;
+	    newValues[TILE].ptr = (void *)pWin->background.pixmap;
 	    newValues[FILLSTYLE].val = FillTiled;
 	    gcmask |= GCTile | GCFillStyle | GCTileStipXOrigin | GCTileStipYOrigin;
 	    break;
@@ -700,7 +700,7 @@ int what;
 	}
 	else
 	{
-	    newValues[TILE].ptr = (pointer)pWin->border.pixmap;
+	    newValues[TILE].ptr = (void *)pWin->border.pixmap;
 	    newValues[FILLSTYLE].val = FillTiled;
 	    gcmask |= GCTile | GCFillStyle | GCTileStipXOrigin | GCTileStipYOrigin;
 	}
@@ -773,7 +773,7 @@ int what;
 		return;
 	    numGCs++;
 	    if (!AddResource(FakeClientID(0), ResType,
-			     (pointer)screenContext[i]))
+			     (void *)screenContext[i]))
 	        return;
 	}
 	pGC = screenContext[i];
diff --git a/nx-X11/programs/Xserver/mi/mifillarc.h b/nx-X11/programs/Xserver/mi/mifillarc.h
index ff39bac1d..2d6904121 100644
--- a/nx-X11/programs/Xserver/mi/mifillarc.h
+++ b/nx-X11/programs/Xserver/mi/mifillarc.h
@@ -179,7 +179,7 @@ typedef struct _miArcSlice {
 			       ((slw > 1) || (ine != inxk)))
 
 extern int miFreeArcCache(
-    pointer /*data*/,
+    void * /*data*/,
     XID /*id*/
 );
 
diff --git a/nx-X11/programs/Xserver/mi/migc.c b/nx-X11/programs/Xserver/mi/migc.c
index 0cffe98a4..2b38b257d 100644
--- a/nx-X11/programs/Xserver/mi/migc.c
+++ b/nx-X11/programs/Xserver/mi/migc.c
@@ -114,14 +114,14 @@ void
 miChangeClip(pGC, type, pvalue, nrects)
     GCPtr           pGC;
     int             type;
-    pointer         pvalue;
+    void            *pvalue;
     int             nrects;
 {
     (*pGC->funcs->DestroyClip) (pGC);
     if (type == CT_PIXMAP)
     {
 	/* convert the pixmap to a region */
-	pGC->clientClip = (pointer) BITMAP_TO_REGION(pGC->pScreen,
+	pGC->clientClip = (void *) BITMAP_TO_REGION(pGC->pScreen,
 							(PixmapPtr) pvalue);
 	(*pGC->pScreen->DestroyPixmap) (pvalue);
     }
@@ -132,7 +132,7 @@ miChangeClip(pGC, type, pvalue, nrects)
     }
     else if (type != CT_NONE)
     {
-	pGC->clientClip = (pointer) RECTS_TO_REGION(pGC->pScreen, nrects,
+	pGC->clientClip = (void *) RECTS_TO_REGION(pGC->pScreen, nrects,
 						      (xRectangle *) pvalue,
 								    type);
 	xfree(pvalue);
@@ -160,7 +160,7 @@ miCopyClip(pgcDst, pgcSrc)
 	prgnNew = REGION_CREATE(pgcSrc->pScreen, NULL, 1);
 	REGION_COPY(pgcDst->pScreen, prgnNew,
 					(RegionPtr) (pgcSrc->clientClip));
-	(*pgcDst->funcs->ChangeClip) (pgcDst, CT_REGION, (pointer) prgnNew, 0);
+	(*pgcDst->funcs->ChangeClip) (pgcDst, CT_REGION, (void *) prgnNew, 0);
 	break;
     }
 }
diff --git a/nx-X11/programs/Xserver/mi/migc.h b/nx-X11/programs/Xserver/mi/migc.h
index d906c6334..039448b5f 100644
--- a/nx-X11/programs/Xserver/mi/migc.h
+++ b/nx-X11/programs/Xserver/mi/migc.h
@@ -53,7 +53,7 @@ extern void miDestroyClip(
 extern void miChangeClip(
     GCPtr   /*pGC*/,
     int     /*type*/,
-    pointer /*pvalue*/,
+    void * /*pvalue*/,
     int     /*nrects*/
 );
 
diff --git a/nx-X11/programs/Xserver/mi/miglblt.c b/nx-X11/programs/Xserver/mi/miglblt.c
index 12d0aa932..3960fc212 100644
--- a/nx-X11/programs/Xserver/mi/miglblt.c
+++ b/nx-X11/programs/Xserver/mi/miglblt.c
@@ -90,7 +90,7 @@ miPolyGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
     int 	 x, y;
     unsigned int nglyph;
     CharInfoPtr *ppci;		/* array of character info */
-    pointer      pglyphBase;	/* start of array of glyphs */
+    void        *pglyphBase;	/* start of array of glyphs */
 {
     int width, height;
     PixmapPtr pPixmap;
@@ -203,7 +203,7 @@ miImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
     int 	 x, y;
     unsigned int nglyph;
     CharInfoPtr *ppci;		/* array of character info */
-    pointer      pglyphBase;	/* start of array of glyphs */
+    void        *pglyphBase;	/* start of array of glyphs */
 {
     ExtentInfoRec info;		/* used by QueryGlyphExtents() */
     XID gcvals[3];
diff --git a/nx-X11/programs/Xserver/mi/mioverlay.c b/nx-X11/programs/Xserver/mi/mioverlay.c
index 545927b53..732e47af0 100644
--- a/nx-X11/programs/Xserver/mi/mioverlay.c
+++ b/nx-X11/programs/Xserver/mi/mioverlay.c
@@ -128,7 +128,7 @@ miInitOverlay(
     if(!(pScreenPriv = xalloc(sizeof(miOverlayScreenRec))))
 	return FALSE;
 
-    pScreen->devPrivates[miOverlayScreenIndex].ptr = (pointer)pScreenPriv;
+    pScreen->devPrivates[miOverlayScreenIndex].ptr = (void *)pScreenPriv;
 
     pScreenPriv->InOverlay = inOverlayFunc;
     pScreenPriv->MakeTransparent = transFunc;
@@ -1105,7 +1105,7 @@ typedef struct {
 static int
 miOverlayRecomputeExposures (
     WindowPtr	pWin,
-    pointer	value 
+    void *	value 
 ){
     register ScreenPtr pScreen;
     miOverlayTwoRegions	*pValid = (miOverlayTwoRegions*)value;
@@ -1503,7 +1503,7 @@ miOverlayResizeWindow(
 		TwoRegions.under = gravitate2[g];
 
 		TraverseTree (pChild, miOverlayRecomputeExposures, 
-					(pointer)(&TwoRegions));
+					(void *)(&TwoRegions));
 	    }
 
 	    /*
diff --git a/nx-X11/programs/Xserver/mi/mipointer.c b/nx-X11/programs/Xserver/mi/mipointer.c
index 432cc1606..869e74349 100644
--- a/nx-X11/programs/Xserver/mi/mipointer.c
+++ b/nx-X11/programs/Xserver/mi/mipointer.c
@@ -103,7 +103,7 @@ miPointerInitialize (pScreen, spriteFuncs, screenFuncs, waitForUpdate)
     pScreenPriv->showTransparent = FALSE;
     pScreenPriv->CloseScreen = pScreen->CloseScreen;
     pScreen->CloseScreen = miPointerCloseScreen;
-    pScreen->devPrivates[miPointerScreenIndex].ptr = (pointer) pScreenPriv;
+    pScreen->devPrivates[miPointerScreenIndex].ptr = (void *) pScreenPriv;
     /*
      * set up screen cursor method table
      */
@@ -145,7 +145,7 @@ miPointerCloseScreen (index, pScreen)
     if (pScreen == miPointer.pSpriteScreen)
 	miPointer.pSpriteScreen = 0;
     pScreen->CloseScreen = pScreenPriv->CloseScreen;
-    xfree ((pointer) pScreenPriv);
+    xfree ((void *) pScreenPriv);
     return (*pScreen->CloseScreen) (index, pScreen);
 }
 
@@ -373,7 +373,7 @@ miPointerUpdate ()
 }
 
 /*
- * miPointerDeltaCursor.  The pointer has moved dx,dy from it's previous
+ * miPointerDeltaCursor.  The void * has moved dx,dy from it's previous
  * position.
  */
 
@@ -406,7 +406,7 @@ miPointerCurrentScreen ()
 }
 
 /*
- * miPointerAbsoluteCursor.  The pointer has moved to x,y
+ * miPointerAbsoluteCursor.  The void * has moved to x,y
  */
 
 void
@@ -465,7 +465,7 @@ miPointerPosition (x, y)
 }
 
 /*
- * miPointerMove.  The pointer has moved to x,y on current screen
+ * miPointerMove.  The void * has moved to x,y on current screen
  */
 
 static void
diff --git a/nx-X11/programs/Xserver/mi/mipolyrect.c b/nx-X11/programs/Xserver/mi/mipolyrect.c
index 6740ea8f6..98e467f9f 100644
--- a/nx-X11/programs/Xserver/mi/mipolyrect.c
+++ b/nx-X11/programs/Xserver/mi/mipolyrect.c
@@ -164,7 +164,7 @@ miPolyRectangle(pDraw, pGC, nrects, pRects)
 	    }
 	}
 	(*pGC->ops->PolyFillRect) (pDraw, pGC, t - tmp, tmp);
-	DEALLOCATE_LOCAL ((pointer) tmp);
+	DEALLOCATE_LOCAL ((void *) tmp);
     }
     else
     {
diff --git a/nx-X11/programs/Xserver/mi/miscrinit.c b/nx-X11/programs/Xserver/mi/miscrinit.c
index ae9b6c2ee..78e2af5a4 100644
--- a/nx-X11/programs/Xserver/mi/miscrinit.c
+++ b/nx-X11/programs/Xserver/mi/miscrinit.c
@@ -56,7 +56,7 @@ from The Open Group.
 
 typedef struct
 {
-    pointer pbits; /* pointer to framebuffer */
+    void * pbits; /* pointer to framebuffer */
     int width;    /* delta to add to a framebuffer addr to move one row down */
 } miScreenInitParmsRec, *miScreenInitParmsPtr;
 
@@ -71,7 +71,7 @@ miModifyPixmapHeader(pPixmap, width, height, depth, bitsPerPixel, devKind,
     int		depth;
     int		bitsPerPixel;
     int		devKind;
-    pointer     pPixData;
+    void        *pPixData;
 {
     if (!pPixmap)
 	return FALSE;
@@ -150,7 +150,7 @@ miCreateScreenResources(pScreen)
     ScreenPtr pScreen;
 {
     miScreenInitParmsPtr pScrInitParms;
-    pointer value;
+    void * value;
 
     pScrInitParms = (miScreenInitParmsPtr)pScreen->devPrivate;
 
@@ -174,7 +174,7 @@ miCreateScreenResources(pScreen)
 		    PixmapBytePad(pScrInitParms->width, pScreen->rootDepth),
 		    pScrInitParms->pbits))
 	    return FALSE;
-	value = (pointer)pPixmap;
+	value = (void *)pPixmap;
     }
     else
     {
@@ -189,7 +189,7 @@ Bool
 miScreenDevPrivateInit(pScreen, width, pbits)
     register ScreenPtr pScreen;
     int width;
-    pointer pbits;
+    void * pbits;
 {
     miScreenInitParmsPtr pScrInitParms;
 
@@ -202,7 +202,7 @@ miScreenDevPrivateInit(pScreen, width, pbits)
 	return FALSE;
     pScrInitParms->pbits = pbits;
     pScrInitParms->width = width;
-    pScreen->devPrivate = (pointer)pScrInitParms;
+    pScreen->devPrivate = (void *)pScrInitParms;
     return TRUE;
 }
 
@@ -210,7 +210,7 @@ Bool
 miScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width,
 	     rootDepth, numDepths, depths, rootVisual, numVisuals, visuals)
     register ScreenPtr pScreen;
-    pointer pbits;		/* pointer to screen bits */
+    void * pbits;		/* pointer to screen bits */
     int xsize, ysize;		/* in pixels */
     int dpix, dpiy;		/* dots per inch */
     int width;			/* pixel width of frame buffer */
@@ -296,8 +296,8 @@ miScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width,
     pScreen->SendGraphicsExpose = miSendGraphicsExpose;
     pScreen->BlockHandler = (ScreenBlockHandlerProcPtr)NoopDDA;
     pScreen->WakeupHandler = (ScreenWakeupHandlerProcPtr)NoopDDA;
-    pScreen->blockData = (pointer)0;
-    pScreen->wakeupData = (pointer)0;
+    pScreen->blockData = (void *)0;
+    pScreen->wakeupData = (void *)0;
     pScreen->MarkWindow = miMarkWindow;
     pScreen->MarkOverlappedWindows = miMarkOverlappedWindows;
     pScreen->ChangeSaveUnder = miChangeSaveUnder;
@@ -368,5 +368,5 @@ miSetScreenPixmap(pPix)
     PixmapPtr pPix;
 {
     if (pPix)
-	pPix->drawable.pScreen->devPrivate = (pointer)pPix;
+	pPix->drawable.pScreen->devPrivate = (void *)pPix;
 }
diff --git a/nx-X11/programs/Xserver/mi/misprite.c b/nx-X11/programs/Xserver/mi/misprite.c
index b76542774..0ff6dacd6 100644
--- a/nx-X11/programs/Xserver/mi/misprite.c
+++ b/nx-X11/programs/Xserver/mi/misprite.c
@@ -84,9 +84,9 @@ static void	    miSpriteSourceValidate(DrawablePtr pDrawable, int x, int y,
 static void	    miSpriteCopyWindow (WindowPtr pWindow,
 					DDXPointRec ptOldOrg,
 					RegionPtr prgnSrc);
-static void	    miSpriteBlockHandler(int i, pointer blockData,
-					 pointer pTimeout,
-					 pointer pReadMask);
+static void	    miSpriteBlockHandler(int i, void * blockData,
+					 void * pTimeout,
+					 void * pReadMask);
 static void	    miSpriteInstallColormap(ColormapPtr pMap);
 static void	    miSpriteStoreColors(ColormapPtr pMap, int ndef,
 					xColorItem *pdef);
@@ -104,7 +104,7 @@ static void	    miSpriteComputeSaved(ScreenPtr pScreen);
     ((pScreen)->field = wrapper)
 
 /*
- * pointer-sprite method table
+ * void *-sprite method table
  */
 
 static Bool miSpriteRealizeCursor(ScreenPtr pScreen, CursorPtr pCursor);
@@ -182,7 +182,7 @@ miSpriteInitialize (pScreen, cursorFuncs, screenFuncs)
 
     if (!miPointerInitialize (pScreen, &miSpritePointerFuncs, screenFuncs,TRUE))
     {
-	xfree ((pointer) pScreenPriv);
+	xfree ((void *) pScreenPriv);
 	return FALSE;
     }
     for (pVisual = pScreen->visuals;
@@ -221,7 +221,7 @@ miSpriteInitialize (pScreen, cursorFuncs, screenFuncs)
     pScreenPriv->colors[MASK_COLOR].red = 0;
     pScreenPriv->colors[MASK_COLOR].green = 0;
     pScreenPriv->colors[MASK_COLOR].blue = 0;
-    pScreen->devPrivates[miSpriteScreenIndex].ptr = (pointer) pScreenPriv;
+    pScreen->devPrivates[miSpriteScreenIndex].ptr = (void *) pScreenPriv;
     
     pScreen->CloseScreen = miSpriteCloseScreen;
     pScreen->GetImage = miSpriteGetImage;
@@ -270,7 +270,7 @@ miSpriteCloseScreen (i, pScreen)
     miSpriteIsUpFALSE (pScreen, pScreenPriv);
     DamageDestroy (pScreenPriv->pDamage);
     
-    xfree ((pointer) pScreenPriv);
+    xfree ((void *) pScreenPriv);
 
     return (*pScreen->CloseScreen) (i, pScreen);
 }
@@ -402,9 +402,9 @@ miSpriteCopyWindow (WindowPtr pWindow, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
 static void
 miSpriteBlockHandler (i, blockData, pTimeout, pReadmask)
     int	i;
-    pointer	blockData;
-    pointer	pTimeout;
-    pointer	pReadmask;
+    void *	blockData;
+    void *	pTimeout;
+    void *	pReadmask;
 {
     ScreenPtr		pScreen = screenInfo.screens[i];
     miSpriteScreenPtr	pPriv;
diff --git a/nx-X11/programs/Xserver/mi/miwindow.c b/nx-X11/programs/Xserver/mi/miwindow.c
index 280d0f8eb..179c6e31e 100644
--- a/nx-X11/programs/Xserver/mi/miwindow.c
+++ b/nx-X11/programs/Xserver/mi/miwindow.c
@@ -579,7 +579,7 @@ miMoveWindow(pWin, x, y, pNextSib, kind)
 static int
 miRecomputeExposures (
     register WindowPtr	pWin,
-    pointer		value) /* must conform to VisitWindowProcPtr */
+    void *		value) /* must conform to VisitWindowProcPtr */
 {
     register ScreenPtr	pScreen;
     RegionPtr	pValid = (RegionPtr)value;
@@ -910,7 +910,7 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
 		    continue;
 		REGION_INTERSECT(pScreen, pRegion,
 				       &pChild->borderClip, gravitate[g]);
-		TraverseTree (pChild, miRecomputeExposures, (pointer)pRegion);
+		TraverseTree (pChild, miRecomputeExposures, (void *)pRegion);
 	    }
 
 	    /*
diff --git a/nx-X11/programs/Xserver/miext/cw/cw.c b/nx-X11/programs/Xserver/miext/cw/cw.c
index 0fdd6547e..8079a0009 100644
--- a/nx-X11/programs/Xserver/miext/cw/cw.c
+++ b/nx-X11/programs/Xserver/miext/cw/cw.c
@@ -64,7 +64,7 @@ cwCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst);
 static void
 cwDestroyGC(GCPtr pGC);
 static void
-cwChangeClip(GCPtr pGC, int type, pointer pvalue, int nrects);
+cwChangeClip(GCPtr pGC, int type, void * pvalue, int nrects);
 static void
 cwCopyClip(GCPtr pgcDst, GCPtr pgcSrc);
 static void
@@ -199,7 +199,7 @@ cwValidateGC(GCPtr pGC, unsigned long stateChanges, DrawablePtr pDrawable)
 	 */
 	
 	(*pBackingGC->funcs->ChangeClip) (pBackingGC, CT_REGION,
-					  (pointer) pCompositeClip, 0);
+					  (void *) pCompositeClip, 0);
 	
 	vals[0] = x_off - pDrawable->x;
 	vals[1] = y_off - pDrawable->y;
@@ -273,7 +273,7 @@ cwDestroyGC(GCPtr pGC)
 }
 
 static void
-cwChangeClip(GCPtr pGC, int type, pointer pvalue, int nrects)
+cwChangeClip(GCPtr pGC, int type, void * pvalue, int nrects)
 {
     cwGCPtr	pPriv = (cwGCPtr)(pGC)->devPrivates[cwGCIndex].ptr;
 
@@ -425,7 +425,7 @@ cwFillRegionTiled(DrawablePtr pDrawable, RegionPtr pRegion, PixmapPtr pTile,
     pGC = GetScratchGC(pDrawable->depth, pScreen);
     v[0].val = GXcopy;
     v[1].val = FillTiled;
-    v[2].ptr = (pointer) pTile;
+    v[2].ptr = (void *) pTile;
     v[3].val = x_off;
     v[4].val = y_off;
     dixChangeGC(NullClient, pGC, (GCFunction | GCFillStyle | GCTile |
@@ -645,7 +645,7 @@ miInitializeCompositeWrapper(ScreenPtr pScreen)
     if (!pScreenPriv)
 	return;
 
-    pScreen->devPrivates[cwScreenIndex].ptr = (pointer)pScreenPriv;
+    pScreen->devPrivates[cwScreenIndex].ptr = (void *)pScreenPriv;
     
     SCREEN_EPILOGUE(pScreen, CloseScreen, cwCloseScreen);
     SCREEN_EPILOGUE(pScreen, GetImage, cwGetImage);
@@ -693,7 +693,7 @@ cwCloseScreen (int i, ScreenPtr pScreen)
 	cwFiniRender(pScreen);
 #endif
 
-    xfree((pointer)pScreenPriv);
+    xfree((void *)pScreenPriv);
 
     return (*pScreen->CloseScreen)(i, pScreen);
 }
diff --git a/nx-X11/programs/Xserver/miext/cw/cw.h b/nx-X11/programs/Xserver/miext/cw/cw.h
index 2563aed5e..42d8db381 100644
--- a/nx-X11/programs/Xserver/miext/cw/cw.h
+++ b/nx-X11/programs/Xserver/miext/cw/cw.h
@@ -47,7 +47,7 @@ typedef struct {
 extern int cwGCIndex;
 
 #define getCwGC(pGC)	((cwGCPtr)(pGC)->devPrivates[cwGCIndex].ptr)
-#define setCwGC(pGC,p)	((pGC)->devPrivates[cwGCIndex].ptr = (pointer) (p))
+#define setCwGC(pGC,p)	((pGC)->devPrivates[cwGCIndex].ptr = (void *) (p))
 
 /*
  * One of these structures is allocated per Picture that gets used with a
@@ -61,7 +61,7 @@ typedef struct {
 } cwPictureRec, *cwPicturePtr;
 
 #define getCwPicture(pPicture)	((cwPicturePtr)(pPicture)->devPrivates[cwPictureIndex].ptr)
-#define setCwPicture(pPicture,p) ((pPicture)->devPrivates[cwPictureIndex].ptr = (pointer) (p))
+#define setCwPicture(pPicture,p) ((pPicture)->devPrivates[cwPictureIndex].ptr = (void *) (p))
 
 extern int  cwPictureIndex;
 
@@ -69,7 +69,7 @@ extern int cwWindowIndex;
 
 #define cwWindowPrivate(pWindow)    ((pWindow)->devPrivates[cwWindowIndex].ptr)
 #define getCwPixmap(pWindow)	    ((PixmapPtr) cwWindowPrivate(pWindow))
-#define setCwPixmap(pWindow,pPixmap) (cwWindowPrivate(pWindow) = (pointer) (pPixmap))
+#define setCwPixmap(pWindow,pPixmap) (cwWindowPrivate(pWindow) = (void *) (pPixmap))
 
 #define cwDrawableIsRedirWindow(pDraw)					\
 	((pDraw)->type == DRAWABLE_WINDOW &&				\
diff --git a/nx-X11/programs/Xserver/miext/cw/cw_ops.c b/nx-X11/programs/Xserver/miext/cw/cw_ops.c
index 567a8c93c..9e09d0532 100644
--- a/nx-X11/programs/Xserver/miext/cw/cw_ops.c
+++ b/nx-X11/programs/Xserver/miext/cw/cw_ops.c
@@ -96,10 +96,10 @@ static void cwImageText16(DrawablePtr pDst, GCPtr pGC, int x, int y,
 			  int count, unsigned short *chars);
 static void cwImageGlyphBlt(DrawablePtr pDst, GCPtr pGC, int x, int y,
 			    unsigned int nglyph, CharInfoPtr *ppci,
-			    pointer pglyphBase);
+			    void * pglyphBase);
 static void cwPolyGlyphBlt(DrawablePtr pDst, GCPtr pGC, int x, int y,
 			   unsigned int nglyph, CharInfoPtr *ppci,
-			   pointer pglyphBase);
+			   void * pglyphBase);
 static void cwPushPixels(GCPtr pGC, PixmapPtr pBitMap, DrawablePtr pDst,
 			 int w, int h, int x, int y);
 
@@ -422,7 +422,7 @@ cwImageText16(DrawablePtr pDst, GCPtr pGC, int x, int y, int count,
 
 static void
 cwImageGlyphBlt(DrawablePtr pDst, GCPtr pGC, int x, int y, unsigned int nglyph,
-		CharInfoPtr *ppci, pointer pglyphBase)
+		CharInfoPtr *ppci, void * pglyphBase)
 {
     SETUP_BACKING_DST(pDst, pGC);
 
@@ -438,7 +438,7 @@ cwImageGlyphBlt(DrawablePtr pDst, GCPtr pGC, int x, int y, unsigned int nglyph,
 
 static void
 cwPolyGlyphBlt(DrawablePtr pDst, GCPtr pGC, int x, int y, unsigned int nglyph,
-	       CharInfoPtr *ppci, pointer pglyphBase)
+	       CharInfoPtr *ppci, void * pglyphBase)
 {
     SETUP_BACKING_DST(pDst, pGC);
 
diff --git a/nx-X11/programs/Xserver/miext/damage/damage.c b/nx-X11/programs/Xserver/miext/damage/damage.c
index 286728cd1..c2a98d422 100755
--- a/nx-X11/programs/Xserver/miext/damage/damage.c
+++ b/nx-X11/programs/Xserver/miext/damage/damage.c
@@ -327,7 +327,7 @@ static void damageValidateGC(GCPtr, unsigned long, DrawablePtr);
 static void damageChangeGC(GCPtr, unsigned long);
 static void damageCopyGC(GCPtr, unsigned long, GCPtr);
 static void damageDestroyGC(GCPtr);
-static void damageChangeClip(GCPtr, int, pointer, int);
+static void damageChangeClip(GCPtr, int, void *, int);
 static void damageDestroyClip(GCPtr);
 static void damageCopyClip(GCPtr, GCPtr);
 
@@ -440,7 +440,7 @@ damageCopyGC (GCPtr	    pGCSrc,
 static void
 damageChangeClip (GCPtr	    pGC,
 		  int	    type,
-		  pointer   pvalue,
+		  void      *pvalue,
 		  int	    nrects)
 {
     DAMAGE_GC_FUNC_PROLOGUE (pGC);
@@ -1453,7 +1453,7 @@ damageImageGlyphBlt(DrawablePtr	    pDrawable,
 		    int		    y,
 		    unsigned int    nglyph,
 		    CharInfoPtr	    *ppci,
-		    pointer	    pglyphBase)
+		    void *	    pglyphBase)
 {
     DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
     damageDamageChars (pDrawable, pGC->font, x + pDrawable->x, y + pDrawable->y,
@@ -1470,7 +1470,7 @@ damagePolyGlyphBlt(DrawablePtr	pDrawable,
 		   int		y,
 		   unsigned int	nglyph,
 		   CharInfoPtr	*ppci,
-		   pointer	pglyphBase)
+		   void *	pglyphBase)
 {
     DAMAGE_GC_OP_PROLOGUE(pGC, pDrawable);
     damageDamageChars (pDrawable, pGC->font, x + pDrawable->x, y + pDrawable->y,
@@ -1801,7 +1801,7 @@ DamageSetup (ScreenPtr pScreen)
     }
 #endif
 
-    pScreen->devPrivates[damageScrPrivateIndex].ptr = (pointer) pScrPriv;
+    pScreen->devPrivates[damageScrPrivateIndex].ptr = (void *) pScrPriv;
     return TRUE;
 }
 
diff --git a/nx-X11/programs/Xserver/miext/damage/damagestr.h b/nx-X11/programs/Xserver/miext/damage/damagestr.h
index d7dd11d92..62b384167 100755
--- a/nx-X11/programs/Xserver/miext/damage/damagestr.h
+++ b/nx-X11/programs/Xserver/miext/damage/damagestr.h
@@ -93,7 +93,7 @@ extern int damageWinPrivateIndex;
     ((DamagePtr) (pPix)->devPrivates[damagePixPrivateIndex].ptr)
 
 #define damgeSetPixPriv(pPix,v) \
-    ((pPix)->devPrivates[damagePixPrivateIndex].ptr = (pointer ) (v))
+    ((pPix)->devPrivates[damagePixPrivateIndex].ptr = (void * ) (v))
 
 #define damagePixPriv(pPix) \
     DamagePtr	    pDamage = damageGetPixPriv(pPix)
diff --git a/nx-X11/programs/Xserver/os/WaitFor.c b/nx-X11/programs/Xserver/os/WaitFor.c
index 2ef474229..d97d44ab6 100644
--- a/nx-X11/programs/Xserver/os/WaitFor.c
+++ b/nx-X11/programs/Xserver/os/WaitFor.c
@@ -152,7 +152,7 @@ struct _OsTimerRec {
     OsTimerPtr		next;
     CARD32		expires;
     OsTimerCallback	callback;
-    pointer		arg;
+    void *		arg;
 };
 
 static void DoTimer(OsTimerPtr timer, CARD32 now, OsTimerPtr *prev);
@@ -254,7 +254,7 @@ WaitForSomething(int *pClientsReady)
 	}
 	SmartScheduleIdle = TRUE;
 #endif
-	BlockHandler((pointer)&wt, (pointer)&LastSelectMask);
+	BlockHandler((void *)&wt, (void *)&LastSelectMask);
 	if (NewOutputPending)
 	    FlushAllOutput();
 #ifdef XTESTEXT1
@@ -386,7 +386,7 @@ WaitForSomething(int *pClientsReady)
         }
 #endif
 	selecterr = GetErrno();
-	WakeupHandler(i, (pointer)&LastSelectMask);
+	WakeupHandler(i, (void *)&LastSelectMask);
 #ifdef XTESTEXT1
 	if (playback_on) {
 	    i = XTestProcessInputAction (i, &waittime);
@@ -515,7 +515,7 @@ WaitForSomething(int *pClientsReady)
 	    XFD_ANDSET(&tmp_set, &LastSelectMask, &WellKnownConnections);
 	    if (XFD_ANYSET(&tmp_set))
 		QueueWorkProc(EstablishNewConnections, NULL,
-			      (pointer)&LastSelectMask);
+		              (void *)&LastSelectMask);
 #ifdef DPMSExtension
 	    if (XFD_ANYSET (&devicesReadable) && (DPMSPowerLevel != DPMSModeOn))
 		DPMSSet(DPMSModeOn);
@@ -643,7 +643,7 @@ DoTimer(OsTimerPtr timer, CARD32 now, OsTimerPtr *prev)
 
 OsTimerPtr
 TimerSet(OsTimerPtr timer, int flags, CARD32 millis, 
-    OsTimerCallback func, pointer arg)
+    OsTimerCallback func, void * arg)
 {
     register OsTimerPtr *prev;
     CARD32 now = GetTimeInMillis();
@@ -755,7 +755,7 @@ TimerInit(void)
 }
 
 static CARD32
-ScreenSaverTimeoutExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+ScreenSaverTimeoutExpire(OsTimerPtr timer,CARD32 now,void * arg)
 {
     INT32 timeout = now - lastDeviceEventTime.milliseconds;
 
@@ -805,7 +805,7 @@ static OsTimerPtr DPMSSuspendTimer = NULL;
 static OsTimerPtr DPMSOffTimer = NULL;
 
 static CARD32
-DPMSStandbyTimerExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+DPMSStandbyTimerExpire(OsTimerPtr timer,CARD32 now,void * arg)
 {
     INT32 timeout = now - lastDeviceEventTime.milliseconds;
 
@@ -820,7 +820,7 @@ DPMSStandbyTimerExpire(OsTimerPtr timer,CARD32 now,pointer arg)
 }
 
 static CARD32
-DPMSSuspendTimerExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+DPMSSuspendTimerExpire(OsTimerPtr timer,CARD32 now,void * arg)
 {
     INT32 timeout = now - lastDeviceEventTime.milliseconds;
 
@@ -835,7 +835,7 @@ DPMSSuspendTimerExpire(OsTimerPtr timer,CARD32 now,pointer arg)
 }
 
 static CARD32
-DPMSOffTimerExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+DPMSOffTimerExpire(OsTimerPtr timer,CARD32 now,void * arg)
 {
     INT32 timeout = now - lastDeviceEventTime.milliseconds;
 
diff --git a/nx-X11/programs/Xserver/os/access.c b/nx-X11/programs/Xserver/os/access.c
index 532a2f82e..07b460f40 100644
--- a/nx-X11/programs/Xserver/os/access.c
+++ b/nx-X11/programs/Xserver/os/access.c
@@ -226,14 +226,14 @@ Bool defeatAccessControl = FALSE;
 
 static int ConvertAddr(struct sockaddr * /*saddr*/,
 		       int * /*len*/,
-		       pointer * /*addr*/);
+		       void ** /*addr*/);
 
 static int CheckAddr(int /*family*/,
-		     pointer /*pAddr*/,
+		     void * /*pAddr*/,
 		     unsigned /*length*/);
 
 static Bool NewHost(int /*family*/,
-		    pointer /*addr*/,
+		    void * /*addr*/,
 		    int /*len*/,
 		    int /* addingLocalHosts */);
 
@@ -270,7 +270,7 @@ static int LocalHostRequested = FALSE;
 static int UsingXdmcp = FALSE;
 
 /* FamilyServerInterpreted implementation */
-static Bool siAddrMatch(int family, pointer addr, int len, HOST *host, 
+static Bool siAddrMatch(int family, void * addr, int len, HOST *host, 
 	ClientPtr client);
 static int  siCheckAddr(const char *addrString, int length);
 static void siTypesInitialize(void);
@@ -302,7 +302,7 @@ DisableLocalHost (void)
 	LocalHostEnabled = FALSE;
     for (self = selfhosts; self; self = self->next) {
       if (!self->requested)		/* Fix for XFree86 bug #156 */
-	(void) RemoveHost ((ClientPtr)NULL, self->family, self->len, (pointer)self->addr);
+	(void) RemoveHost ((ClientPtr)NULL, self->family, self->len, (void *)self->addr);
     }
 }
 
@@ -441,7 +441,7 @@ DefineSelf (int fd)
 	}
 
 	len = sizeof(struct sockaddr_in);
-	family = ConvertAddr (IA_SIN(&ifaddr), &len, (pointer *)&addr);
+	family = ConvertAddr (IA_SIN(&ifaddr), &len, (void **)&addr);
         if (family == -1 || family == FamilyLocal)
 	    continue;
         for (host = selfhosts;
@@ -602,7 +602,7 @@ DefineSelf (int fd)
 	default:
 	    goto DefineLocalHost;
 	}
-	family = ConvertAddr ( &(saddr.sa), &len, (pointer *)&addr);
+	family = ConvertAddr ( &(saddr.sa), &len, (void **)&addr);
 	if ( family != -1 && family != FamilyLocal )
 	{
 	    for (host = selfhosts;
@@ -812,7 +812,7 @@ DefineSelf (int fd)
 #define IFR_IFR_NAME ifr->ifr_name
 #endif
 
-    if (ifioctl (fd, IFC_IOCTL_REQ, (pointer) &ifc) < 0)
+    if (ifioctl (fd, IFC_IOCTL_REQ, (void *) &ifc) < 0)
         Error ("Getting interface configuration (4)");
 
     cplim = (char *) IFC_IFC_REQ + IFC_IFC_LEN;
@@ -822,7 +822,7 @@ DefineSelf (int fd)
 	ifr = (ifr_type *) cp;
 	len = ifraddr_size (IFR_IFR_ADDR);
 	family = ConvertAddr ((struct sockaddr *) &IFR_IFR_ADDR, 
-	  			&len, (pointer *)&addr);
+	  			&len, (void **)&addr);
 #ifdef DNETCONN
 	/*
 	 * DECnet was handled up above.
@@ -943,13 +943,13 @@ DefineSelf (int fd)
 	    	struct ifreq    broad_req;
     
 	    	broad_req = *ifr;
-		if (ifioctl (fd, SIOCGIFFLAGS, (pointer) &broad_req) != -1 &&
+		if (ifioctl (fd, SIOCGIFFLAGS, (void *) &broad_req) != -1 &&
 		    (broad_req.ifr_flags & IFF_BROADCAST) &&
 		    (broad_req.ifr_flags & IFF_UP)
 		    )
 		{
 		    broad_req = *ifr;
-		    if (ifioctl (fd, SIOCGIFBRDADDR, (pointer) &broad_req) != -1)
+		    if (ifioctl (fd, SIOCGIFBRDADDR, (void *) &broad_req) != -1)
 			broad_addr = broad_req.ifr_addr;
 		    else
 			continue;
@@ -980,7 +980,7 @@ DefineSelf (int fd)
 	    continue;
 #endif /* DNETCONN */
 	len = sizeof(*(ifr->ifa_addr));
-	family = ConvertAddr(ifr->ifa_addr, &len, (pointer *)&addr);
+	family = ConvertAddr(ifr->ifa_addr, &len, (void **)&addr);
 	if (family == -1 || family == FamilyLocal) 
 	    continue;
 #if defined(IPv6) && defined(AF_INET6)
@@ -1104,13 +1104,13 @@ DefineSelf (int fd)
 
 #ifdef XDMCP
 void
-AugmentSelf(pointer from, int len)
+AugmentSelf(void * from, int len)
 {
     int family;
-    pointer addr;
+    void * addr;
     register HOST *host;
 
-    family = ConvertAddr(from, &len, (pointer *)&addr);
+    family = ConvertAddr(from, &len, (void **)&addr);
     if (family == -1 || family == FamilyLocal)
 	return;
     for (host = selfhosts; host; host = host->next)
@@ -1175,7 +1175,7 @@ ResetHosts (char *display)
     krb5_data		kbuf;
 #endif
     int			family = 0;
-    pointer		addr;
+    void		*addr;
     int 		len;
 
     siTypesInitialize();
@@ -1284,7 +1284,7 @@ ResetHosts (char *display)
 		/* node was specified by name */
 		saddr.sa.sa_family = np->n_addrtype;
 		len = sizeof(saddr.sa);
-		if (ConvertAddr (&saddr.sa, &len, (pointer *)&addr) == FamilyDECnet)
+		if (ConvertAddr (&saddr.sa, &len, (void **)&addr) == FamilyDECnet)
 		{
 		    bzero ((char *) &dnaddr, sizeof (dnaddr));
 		    dnaddr.a_len = np->n_length;
@@ -1293,7 +1293,7 @@ ResetHosts (char *display)
 		}
     	    }
 	    if (dnaddrp)
-		(void) NewHost(FamilyDECnet, (pointer)dnaddrp,
+		(void) NewHost(FamilyDECnet, (void *)dnaddrp,
 			(int)(dnaddrp->a_len + sizeof(dnaddrp->a_len)), FALSE);
     	}
 	else
@@ -1329,7 +1329,7 @@ ResetHosts (char *display)
 		if (getaddrinfo(hostname, NULL, NULL, &addresses) == 0) {
 		    for (a = addresses ; a != NULL ; a = a->ai_next) {
 			len = a->ai_addrlen;
-			f = ConvertAddr(a->ai_addr,&len,(pointer *)&addr);
+			f = ConvertAddr(a->ai_addr,&len,(void **)&addr);
 			if ( (family == f) || 
 			     ((family == FamilyWild) && (f != -1)) ) {
 			    NewHost(f, addr, len, FALSE);
@@ -1351,16 +1351,16 @@ ResetHosts (char *display)
 	    {
     		saddr.sa.sa_family = hp->h_addrtype;
 		len = sizeof(saddr.sa);
-    		if ((family = ConvertAddr (&saddr.sa, &len, (pointer *)&addr)) != -1)
+		if ((family = ConvertAddr (&saddr.sa, &len, (void **)&addr)) != -1)
 		{
 #ifdef h_addr				/* new 4.3bsd version of gethostent */
 		    char **list;
 
 		    /* iterate over the addresses */
 		    for (list = hp->h_addr_list; *list; list++)
-			(void) NewHost (family, (pointer)*list, len, FALSE);
+			(void) NewHost (family, (void *)*list, len, FALSE);
 #else
-    		    (void) NewHost (family, (pointer)hp->h_addr, len, FALSE);
+		    (void) NewHost (family, (void *)hp->h_addr, len, FALSE);
 #endif
 		}
     	    }
@@ -1378,7 +1378,7 @@ Bool LocalClient(ClientPtr client)
 {
     int    		alen, family, notused;
     Xtransaddr		*from = NULL;
-    pointer		addr;
+    void		*addr;
     register HOST	*host;
 
 #ifdef XCSECURITY
@@ -1398,7 +1398,7 @@ Bool LocalClient(ClientPtr client)
 	&notused, &alen, &from))
     {
 	family = ConvertAddr ((struct sockaddr *) from,
-	    &alen, (pointer *)&addr);
+	    &alen, (void **)&addr);
 	if (family == -1)
 	{
 	    xfree ((char *) from);
@@ -1546,7 +1546,7 @@ int
 AddHost (ClientPtr	client,
 	 int            family,
 	 unsigned       length,        /* of bytes in pAddr */
-	 pointer        pAddr)
+	 void           *pAddr)
 {
     int			len;
 
@@ -1596,8 +1596,8 @@ ForEachHostInFamily (int	    family,
 		     Bool    (*func)(
 			 unsigned char * /* addr */,
 			 short           /* len */,
-			 pointer         /* closure */),
-		     pointer closure)
+			 void *         /* closure */),
+		     void * closure)
 {
     HOST    *host;
 
@@ -1611,7 +1611,7 @@ ForEachHostInFamily (int	    family,
  * called when starting or resetting the server */
 static Bool
 NewHost (int		family,
-	 pointer	addr,
+	 void		*addr,
 	 int		len,
 	 int		addingLocalHosts)
 {
@@ -1648,7 +1648,7 @@ RemoveHost (
     ClientPtr		client,
     int                 family,
     unsigned            length,        /* of bytes in pAddr */
-    pointer             pAddr)
+    void                *pAddr)
 {
     int			len;
     register HOST	*host, **prev;
@@ -1703,7 +1703,7 @@ RemoveHost (
 /* Get all hosts in the access control list */
 int
 GetHosts (
-    pointer		*data,
+    void *		*data,
     int			*pnHosts,
     int			*pLen,
     BOOL		*pEnabled)
@@ -1726,7 +1726,7 @@ GetHosts (
     }
     if (n)
     {
-        *data = ptr = (pointer) xalloc (n);
+        *data = ptr = (void *) xalloc (n);
 	if (!ptr)
 	{
 	    return(BadAlloc);
@@ -1756,7 +1756,7 @@ GetHosts (
 static int
 CheckAddr (
     int			family,
-    pointer		pAddr,
+    void *		pAddr,
     unsigned		length)
 {
     int	len;
@@ -1813,12 +1813,12 @@ InvalidHost (
     ClientPtr			client)
 {
     int 			family;
-    pointer			addr;
+    void			*addr;
     register HOST 		*selfhost, *host;
 
     if (!AccessEnabled)   /* just let them in */
         return(0);    
-    family = ConvertAddr (saddr, &len, (pointer *)&addr);
+    family = ConvertAddr (saddr, &len, (void **)&addr);
     if (family == -1)
         return 1;
     if (family == FamilyLocal)
@@ -1860,7 +1860,7 @@ static int
 ConvertAddr (
     register struct sockaddr	*saddr,
     int				*len,
-    pointer			*addr)
+    void			**addr)
 {
     if (*len == 0)
         return (FamilyLocal);
@@ -1878,7 +1878,7 @@ ConvertAddr (
             return FamilyLocal;
 #endif
         *len = sizeof (struct in_addr);
-        *addr = (pointer) &(((struct sockaddr_in *) saddr)->sin_addr);
+        *addr = (void *) &(((struct sockaddr_in *) saddr)->sin_addr);
         return FamilyInternet;
 #if defined(IPv6) && defined(AF_INET6)
     case AF_INET6: 
@@ -1886,11 +1886,11 @@ ConvertAddr (
 	struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *) saddr;
 	if (IN6_IS_ADDR_V4MAPPED(&(saddr6->sin6_addr))) {
 	    *len = sizeof (struct in_addr);
-	    *addr = (pointer) &(saddr6->sin6_addr.s6_addr[12]);
+	    *addr = (void *) &(saddr6->sin6_addr.s6_addr[12]);
 	    return FamilyInternet;
 	} else {
 	    *len = sizeof (struct in6_addr);
-	    *addr = (pointer) &(saddr6->sin6_addr);
+	    *addr = (void *) &(saddr6->sin6_addr);
 	    return FamilyInternet6;
 	}
     }
@@ -1901,7 +1901,7 @@ ConvertAddr (
 	{
 	    struct sockaddr_dn *sdn = (struct sockaddr_dn *) saddr;
 	    *len = sdn->sdn_nodeaddrl + sizeof(sdn->sdn_nodeaddrl);
-	    *addr = (pointer) &(sdn->sdn_add);
+	    *addr = (void *) &(sdn->sdn_add);
 	}
         return FamilyDECnet;
 #endif
@@ -1953,7 +1953,7 @@ GetAccessControl(void)
  * future to enable loading additional host types, but that was not done for
  * the initial implementation.
  */
-typedef Bool (*siAddrMatchFunc)(int family, pointer addr, int len, 
+typedef Bool (*siAddrMatchFunc)(int family, void * addr, int len, 
   const char *siAddr, int siAddrlen, ClientPtr client, void *siTypePriv);
 typedef int  (*siCheckAddrFunc)(const char *addrString, int length, 
   void *siTypePriv);
@@ -2005,7 +2005,7 @@ siTypeAdd(const char *typeName, siAddrMatchFunc addrMatch,
 
 /* Checks to see if a host matches a server-interpreted host entry */
 static Bool 
-siAddrMatch(int family, pointer addr, int len, HOST *host, ClientPtr client)
+siAddrMatch(int family, void * addr, int len, HOST *host, ClientPtr client)
 {
     Bool matches = FALSE;
     struct siType *s;
@@ -2105,7 +2105,7 @@ siCheckAddr(const char *addrString, int length)
 #endif
 
 static Bool 
-siHostnameAddrMatch(int family, pointer addr, int len,
+siHostnameAddrMatch(int family, void * addr, int len,
   const char *siAddr, int siAddrLen, ClientPtr client, void *typePriv)
 {
     Bool res = FALSE;
@@ -2120,7 +2120,7 @@ siHostnameAddrMatch(int family, pointer addr, int len,
 	struct addrinfo *addresses;
 	struct addrinfo *a;
 	int f, hostaddrlen;
-	pointer hostaddr;
+	void * hostaddr;
 
 	if (siAddrLen >= sizeof(hostname)) 
 	    return FALSE;
@@ -2149,7 +2149,7 @@ siHostnameAddrMatch(int family, pointer addr, int len,
 #endif
 	char hostname[SI_HOSTNAME_MAXLEN];
 	int f, hostaddrlen;
-	pointer hostaddr;
+	void * hostaddr;
 	const char **addrlist;
 
 	if (siAddrLen >= sizeof(hostname)) 
@@ -2249,7 +2249,7 @@ siHostnameCheckAddr(const char *valueString, int length, void *typePriv)
 #define SI_IPv6_MAXLEN INET6_ADDRSTRLEN
 
 static Bool 
-siIPv6AddrMatch(int family, pointer addr, int len,
+siIPv6AddrMatch(int family, void * addr, int len,
   const char *siAddr, int siAddrlen, ClientPtr client, void *typePriv)
 {
     struct in6_addr addr6;
@@ -2367,7 +2367,7 @@ siLocalCredGetId(const char *addr, int len, siLocalCredPrivPtr lcPriv, int *id)
 }
 
 static Bool 
-siLocalCredAddrMatch(int family, pointer addr, int len,
+siLocalCredAddrMatch(int family, void * addr, int len,
   const char *siAddr, int siAddrlen, ClientPtr client, void *typePriv)
 {
     int connUid, connGid, *connSuppGids, connNumSuppGids, siAddrId;
diff --git a/nx-X11/programs/Xserver/os/connection.c b/nx-X11/programs/Xserver/os/connection.c
index e3319b338..0f846d084 100644
--- a/nx-X11/programs/Xserver/os/connection.c
+++ b/nx-X11/programs/Xserver/os/connection.c
@@ -142,7 +142,7 @@ extern __const__ int _nfiles;
 #endif
 #endif
 #endif /* WIN32 */
-#include "misc.h"		/* for typedef of pointer */
+#include "misc.h"
 #include "osdep.h"
 #include <X11/Xpoll.h>
 #include "opaque.h"
@@ -874,7 +874,7 @@ AllocNewConnection (XtransConnInfo trans_conn, int fd, CARD32 conn_time)
     oc->Close = Close;
     oc->largereq = (ConnectionInputPtr) NULL;
 #endif
-    if (!(client = NextAvailableClient((pointer)oc)))
+    if (!(client = NextAvailableClient((void *)oc)))
     {
 	xfree (oc);
 	return NullClient;
@@ -950,7 +950,7 @@ LbxProxyConnection (ClientPtr client, LbxProxyPtr proxy)
 
 /*ARGSUSED*/
 Bool
-EstablishNewConnections(ClientPtr clientUnused, pointer closure)
+EstablishNewConnections(ClientPtr clientUnused, void * closure)
 {
     fd_set  readyconnections;     /* set of listeners that are ready */
     int curconn;                  /* fd of listener that's ready */
@@ -1215,7 +1215,7 @@ CloseDownConnection(ClientPtr client)
     FreeOsBuffers(oc);
     xfree(oc);
 #endif
-    client->osPrivate = (pointer)NULL;
+    client->osPrivate = (void *)NULL;
     if (auditTrailLevel > 1)
 	AuditF("client %d disconnected\n", client->index);
 }
diff --git a/nx-X11/programs/Xserver/os/io.c b/nx-X11/programs/Xserver/os/io.c
index 76edbaeee..b92e7c4ae 100644
--- a/nx-X11/programs/Xserver/os/io.c
+++ b/nx-X11/programs/Xserver/os/io.c
@@ -511,7 +511,7 @@ ReadRequestFromClient(ClientPtr client)
 	client->req_len -= (sizeof(xBigReq) - sizeof(xReq)) >> 2;
     }
 #endif
-    client->requestBuffer = (pointer)oci->bufptr;
+    client->requestBuffer = (void *)oci->bufptr;
 #ifdef DEBUG_COMMUNICATION
     {
 	xReq *req = client->requestBuffer;
@@ -998,7 +998,7 @@ WriteToClient (ClientPtr who, int count, char *buf)
 	    who->replyBytesRemaining -= count + padBytes;
 	    replyinfo.startOfReply = FALSE;
 	    replyinfo.bytesRemaining = who->replyBytesRemaining;
-	    CallCallbacks((&ReplyCallback), (pointer)&replyinfo);
+	    CallCallbacks((&ReplyCallback), (void *)&replyinfo);
 	}
 	else if (who->clientState == ClientStateRunning
 		 && buf[0] == X_Reply)
@@ -1013,7 +1013,7 @@ WriteToClient (ClientPtr who, int count, char *buf)
 	    bytesleft = (replylen * 4) + SIZEOF(xReply) - count - padBytes;
 	    replyinfo.startOfReply = TRUE;
 	    replyinfo.bytesRemaining = who->replyBytesRemaining = bytesleft;
-	    CallCallbacks((&ReplyCallback), (pointer)&replyinfo);
+	    CallCallbacks((&ReplyCallback), (void *)&replyinfo);
 	} 	                      
     }
 #ifdef DEBUG_COMMUNICATION
diff --git a/nx-X11/programs/Xserver/os/k5auth.c b/nx-X11/programs/Xserver/os/k5auth.c
index 78301ad10..3c50de032 100644
--- a/nx-X11/programs/Xserver/os/k5auth.c
+++ b/nx-X11/programs/Xserver/os/k5auth.c
@@ -79,7 +79,7 @@ static char kerror[256];
  * extract session key from a credentials struct
  */
 krb5_error_code tgt_keyproc(keyprocarg, principal, vno, key)
-    krb5_pointer keyprocarg;
+    krb5_void * keyprocarg;
     krb5_principal principal;
     krb5_kvno vno;
     krb5_keyblock **key;
@@ -237,15 +237,15 @@ XID K5Check(data_length, data, client, reason)
     client->clientState = ClientStateAuthenticating;
     if (ccname)
     {
-	((OsCommPtr)client->osPrivate)->authstate.srvcreds = (pointer)creds; /* save tgt creds */
+	((OsCommPtr)client->osPrivate)->authstate.srvcreds = (void *)creds; /* save tgt creds */
 	((OsCommPtr)client->osPrivate)->authstate.ktname = NULL;
 	((OsCommPtr)client->osPrivate)->authstate.srvname = NULL;
     }
     if (srvname)
     {
 	((OsCommPtr)client->osPrivate)->authstate.srvcreds = NULL;
-	((OsCommPtr)client->osPrivate)->authstate.ktname = (pointer)ktname;
-	((OsCommPtr)client->osPrivate)->authstate.srvname = (pointer)srvname;
+	((OsCommPtr)client->osPrivate)->authstate.ktname = (void *)ktname;
+	((OsCommPtr)client->osPrivate)->authstate.srvname = (void *)srvname;
     }
     ((OsCommPtr)client->osPrivate)->authstate.stageno = 1; /* next stage is 1 */
     return krb5_id;
@@ -476,7 +476,7 @@ int k5_stage1(client)
     /*
      * Now check to see if the principal we got is one that we want to let in
      */
-    if (ForEachHostInFamily(FamilyKrb5Principal, k5_cmpenc, (pointer)&buf))
+    if (ForEachHostInFamily(FamilyKrb5Principal, k5_cmpenc, (void *)&buf))
     {
 	free(buf.data);
 	/*
diff --git a/nx-X11/programs/Xserver/os/log.c b/nx-X11/programs/Xserver/os/log.c
index 1b28bb141..9af39800f 100644
--- a/nx-X11/programs/Xserver/os/log.c
+++ b/nx-X11/programs/Xserver/os/log.c
@@ -531,7 +531,7 @@ AuditF(const char * f, ...)
 }
 
 static CARD32
-AuditFlush(OsTimerPtr timer, CARD32 now, pointer arg)
+AuditFlush(OsTimerPtr timer, CARD32 now, void * arg)
 {
     char *prefix;
 
diff --git a/nx-X11/programs/Xserver/os/osdep.h b/nx-X11/programs/Xserver/os/osdep.h
index b837d7605..e8c2d5959 100644
--- a/nx-X11/programs/Xserver/os/osdep.h
+++ b/nx-X11/programs/Xserver/os/osdep.h
@@ -151,10 +151,10 @@ typedef struct _connectionOutput {
 #ifdef K5AUTH
 typedef struct _k5_state {
     int		stageno;	/* current stage of auth protocol */
-    pointer	srvcreds;	/* server credentials */
-    pointer	srvname;	/* server principal name */
-    pointer	ktname;		/* key table: principal-key pairs */
-    pointer	skey;		/* session key */
+    void	*srvcreds;	/* server credentials */
+    void	*srvname;	/* server principal name */
+    void	*ktname;	/* key table: principal-key pairs */
+    void	*skey;		/* session key */
 }           k5_state;
 #endif
 
diff --git a/nx-X11/programs/Xserver/os/rpcauth.c b/nx-X11/programs/Xserver/os/rpcauth.c
index a12931eb0..896291e59 100644
--- a/nx-X11/programs/Xserver/os/rpcauth.c
+++ b/nx-X11/programs/Xserver/os/rpcauth.c
@@ -132,7 +132,7 @@ static Bool
 CheckNetName (
     unsigned char    *addr,
     short	    len,
-    pointer	    closure
+    void *	    closure
 )
 {
     return (len == strlen ((char *) closure) &&
@@ -176,7 +176,7 @@ int
 SecureRPCAdd (unsigned short data_length, char *data, XID id)
 {
     if (data_length)
-	AddHost ((pointer) 0, FamilyNetname, data_length, data);
+	AddHost ((void *) 0, FamilyNetname, data_length, data);
     rpc_id = id;
     return 1;
 }
diff --git a/nx-X11/programs/Xserver/os/utils.c b/nx-X11/programs/Xserver/os/utils.c
index 5f189c949..b09190c4e 100644
--- a/nx-X11/programs/Xserver/os/utils.c
+++ b/nx-X11/programs/Xserver/os/utils.c
@@ -598,7 +598,7 @@ GetTimeInMillis(void)
 #endif
 
 void
-AdjustWaitForDelay (pointer waitTime, unsigned long newdelay)
+AdjustWaitForDelay (void * waitTime, unsigned long newdelay)
 {
     static struct timeval   delay_val;
     struct timeval	    **wt = (struct timeval **) waitTime;
@@ -1299,7 +1299,7 @@ ExpandCommandLine(int *pargc, char ***pargv)
 /* Implement a simple-minded font authorization scheme.  The authorization
    name is "hp-hostname-1", the contents are simply the host name. */
 int
-set_font_authorizations(char **authorizations, int *authlen, pointer client)
+set_font_authorizations(char **authorizations, int *authlen, void * client)
 {
 #define AUTHORIZATION_NAME "hp-hostname-1"
 #if defined(TCPCONN) || defined(STREAMSCONN)
@@ -1380,7 +1380,7 @@ set_font_authorizations(char **authorizations, int *authlen, pointer client)
 void * 
 Xalloc(unsigned long amount)
 {
-    register pointer  ptr;
+    register void *  ptr;
 	
     if ((long)amount <= 0) {
 	return (unsigned long *)NULL;
@@ -1392,7 +1392,7 @@ Xalloc(unsigned long amount)
 	((random() % MEM_FAIL_SCALE) < Memory_fail))
 	return (unsigned long *)NULL;
 #endif
-    if ((ptr = (pointer)malloc(amount))) {
+    if ((ptr = (void *)malloc(amount))) {
 	return (unsigned long *)ptr;
     }
     if (Must_have_memory)
@@ -1408,7 +1408,7 @@ Xalloc(unsigned long amount)
 void *
 XNFalloc(unsigned long amount)
 {
-    register pointer ptr;
+    register void * ptr;
 
     if ((long)amount <= 0)
     {
@@ -1416,7 +1416,7 @@ XNFalloc(unsigned long amount)
     }
     /* aligned extra on long word boundary */
     amount = (amount + (sizeof(long) - 1)) & ~(sizeof(long) - 1);
-    ptr = (pointer)malloc(amount);
+    ptr = (void *)malloc(amount);
     if (!ptr)
     {
         FatalError("Out of memory");
@@ -1461,7 +1461,7 @@ XNFcalloc(unsigned long amount)
  *****************/
 
 void *
-Xrealloc(pointer ptr, unsigned long amount)
+Xrealloc(void * ptr, unsigned long amount)
 {
 #ifdef MEMBUG
     if (!Must_have_memory && Memory_fail &&
@@ -1476,9 +1476,9 @@ Xrealloc(pointer ptr, unsigned long amount)
     }
     amount = (amount + (sizeof(long) - 1)) & ~(sizeof(long) - 1);
     if (ptr)
-        ptr = (pointer)realloc((char *)ptr, amount);
+        ptr = (void *)realloc((char *)ptr, amount);
     else
-	ptr = (pointer)malloc(amount);
+	ptr = (void *)malloc(amount);
     if (ptr)
         return (unsigned long *)ptr;
     if (Must_have_memory)
@@ -1492,9 +1492,9 @@ Xrealloc(pointer ptr, unsigned long amount)
  *****************/
 
 void *
-XNFrealloc(pointer ptr, unsigned long amount)
+XNFrealloc(void * ptr, unsigned long amount)
 {
-    if (( ptr = (pointer)Xrealloc( ptr, amount ) ) == NULL)
+    if (( ptr = (void *)Xrealloc( ptr, amount ) ) == NULL)
     {
 	if ((long)amount > 0)
             FatalError( "Out of memory" );
@@ -1508,7 +1508,7 @@ XNFrealloc(pointer ptr, unsigned long amount)
  *****************/    
 
 void
-Xfree(pointer ptr)
+Xfree(void * ptr)
 {
     if (ptr)
 	free((char *)ptr); 
@@ -1816,7 +1816,7 @@ static struct pid {
     int pid;
 } *pidlist;
 
-pointer
+void *
 Popen(char *command, char *type)
 {
     struct pid *cur;
@@ -1953,7 +1953,7 @@ Popen(char *command, char *type)
 }
 
 /* fopen that drops privileges */
-pointer
+void *
 Fopen(char *file, char *type)
 {
     FILE *iop;
@@ -2047,7 +2047,7 @@ Fopen(char *file, char *type)
 }
 
 int
-Pclose(pointer iop)
+Pclose(void * iop)
 {
     struct pid *cur, *last;
     int pstat;
@@ -2087,7 +2087,7 @@ Pclose(pointer iop)
 }
 
 int 
-Fclose(pointer iop)
+Fclose(void * iop)
 {
 #ifdef HAS_SAVED_IDS_AND_SETEUID
     return fclose(iop);
diff --git a/nx-X11/programs/Xserver/os/xalloc.c b/nx-X11/programs/Xserver/os/xalloc.c
index e1cdbfc5b..a2487d4bc 100644
--- a/nx-X11/programs/Xserver/os/xalloc.c
+++ b/nx-X11/programs/Xserver/os/xalloc.c
@@ -466,10 +466,10 @@ Xalloc (unsigned long amount)
  * "no failure" realloc, alternate interface to Xalloc w/o Must_have_memory
  *****************/
 
-pointer
+void *
 XNFalloc (unsigned long amount)
 {
-    register pointer ptr;
+    register void * ptr;
 
     /* zero size requested */
     if (amount == 0) {
@@ -499,10 +499,10 @@ XNFalloc (unsigned long amount)
  * Xcalloc
  *****************/
 
-pointer
+void *
 Xcalloc (unsigned long amount)
 {
-    pointer ret;
+    void * ret;
 
     ret = Xalloc (amount);
     if (ret != 0
@@ -520,7 +520,7 @@ Xcalloc (unsigned long amount)
 void *
 XNFcalloc (unsigned long amount)
 {
-    pointer ret;
+    void * ret;
 
     ret = XNFalloc (amount);
     if (ret != 0
@@ -537,7 +537,7 @@ XNFcalloc (unsigned long amount)
  *****************/
 
 void *
-Xrealloc (pointer ptr, unsigned long amount)
+Xrealloc (void * ptr, unsigned long amount)
 {
     register unsigned long *new_ptr;
 
@@ -614,9 +614,9 @@ Xrealloc (pointer ptr, unsigned long amount)
  *****************/
 
 void *
-XNFrealloc (pointer ptr, unsigned long amount)
+XNFrealloc (void * ptr, unsigned long amount)
 {
-    if (( ptr = (pointer)Xrealloc( ptr, amount ) ) == NULL)
+    if (( ptr = (void *)Xrealloc( ptr, amount ) ) == NULL)
     {
         FatalError( "Out of memory" );
     }
@@ -629,7 +629,7 @@ XNFrealloc (pointer ptr, unsigned long amount)
  *****************/    
 
 void
-Xfree(pointer ptr)
+Xfree(void * ptr)
 {
     unsigned long size;
     unsigned long *pheader;
diff --git a/nx-X11/programs/Xserver/os/xdmcp.c b/nx-X11/programs/Xserver/os/xdmcp.c
index 032d58f15..675e9c456 100644
--- a/nx-X11/programs/Xserver/os/xdmcp.c
+++ b/nx-X11/programs/Xserver/os/xdmcp.c
@@ -223,14 +223,14 @@ static void timeout(void);
 static void restart(void);
 
 static void XdmcpBlockHandler(
-    pointer /*data*/,
+    void * /*data*/,
     struct timeval ** /*wt*/,
-    pointer /*LastSelectMask*/);
+    void * /*LastSelectMask*/);
 
 static void XdmcpWakeupHandler(
-    pointer /*data*/,
+    void * /*data*/,
     int /*i*/,
-    pointer /*LastSelectMask*/);
+    void * /*LastSelectMask*/);
 
 void XdmcpRegisterManufacturerDisplayID(
     char    * /*name*/,
@@ -623,7 +623,7 @@ XdmcpInit(void)
 	XdmcpRegisterDisplayClass (defaultDisplayClass, strlen (defaultDisplayClass));
 	AccessUsingXdmcp();
 	RegisterBlockAndWakeupHandlers (XdmcpBlockHandler, XdmcpWakeupHandler,
-				        (pointer) 0);
+				        (void *) 0);
     	timeOutRtx = 0;
     	DisplayNumber = (CARD16) atoi(display);
     	get_xdmcp_sock();
@@ -638,7 +638,7 @@ XdmcpReset (void)
     if (state != XDM_OFF)
     {
 	RegisterBlockAndWakeupHandlers (XdmcpBlockHandler, XdmcpWakeupHandler,
-				        (pointer) 0);
+				        (void *) 0);
     	timeOutRtx = 0;
     	send_packet();
     }
@@ -683,9 +683,9 @@ XdmcpCloseDisplay(int sock)
 /*ARGSUSED*/
 static void
 XdmcpBlockHandler(
-    pointer	    data,   /* unused */
+    void *	    data,   /* unused */
     struct timeval  **wt,
-    pointer	    pReadmask)
+    void *	    pReadmask)
 {
     fd_set *LastSelectMask = (fd_set*)pReadmask;
     CARD32 millisToGo;
@@ -714,9 +714,9 @@ XdmcpBlockHandler(
 /*ARGSUSED*/
 static void
 XdmcpWakeupHandler(
-    pointer data,   /* unused */
+    void * data,   /* unused */
     int	    i,
-    pointer pReadmask)
+    void * pReadmask)
 {
     fd_set* LastSelectMask = (fd_set*)pReadmask;
     fd_set   devicesReadable;
diff --git a/nx-X11/programs/Xserver/randr/randr.c b/nx-X11/programs/Xserver/randr/randr.c
index f565617e6..eb50aeb3d 100644
--- a/nx-X11/programs/Xserver/randr/randr.c
+++ b/nx-X11/programs/Xserver/randr/randr.c
@@ -84,8 +84,8 @@ int	rrPrivIndex = -1;
 
 static void
 RRClientCallback (CallbackListPtr	*list,
-		  pointer		closure,
-		  pointer		data)
+		  void *		closure,
+		  void *		data)
 {
     NewClientInfoRec	*clientinfo = (NewClientInfoRec *) data;
     ClientPtr		pClient = clientinfo->client;
@@ -304,7 +304,7 @@ Bool RRScreenInit(ScreenPtr pScreen)
 
 /*ARGSUSED*/
 static int
-RRFreeClient (pointer data, XID id)
+RRFreeClient (void * data, XID id)
 {
     RREventPtr   pRREvent;
     WindowPtr	    pWin;
@@ -325,13 +325,13 @@ RRFreeClient (pointer data, XID id)
 	    	*pHead = pRREvent->next;
 	}
     }
-    xfree ((pointer) pRREvent);
+    xfree ((void *) pRREvent);
     return 1;
 }
 
 /*ARGSUSED*/
 static int
-RRFreeEvents (pointer data, XID id)
+RRFreeEvents (void * data, XID id)
 {
     RREventPtr   *pHead, pCur, pNext;
 
@@ -339,9 +339,9 @@ RRFreeEvents (pointer data, XID id)
     for (pCur = *pHead; pCur; pCur = pNext) {
 	pNext = pCur->next;
 	FreeResource (pCur->clientResource, RRClientType);
-	xfree ((pointer) pCur);
+	xfree ((void *) pCur);
     }
-    xfree ((pointer) pHead);
+    xfree ((void *) pHead);
     return 1;
 }
 
@@ -390,7 +390,7 @@ RRExtensionInit (void)
 }
 
 static int
-TellChanged (WindowPtr pWin, pointer value)
+TellChanged (WindowPtr pWin, void * value)
 {
     RREventPtr			*pHead, pRREvent;
     ClientPtr			client;
@@ -452,7 +452,7 @@ RRTellChanged (ScreenPtr pScreen)
 	    pScrPriv->configChanged = FALSE;
 	}
 	pScrPriv->changed = FALSE;
-	WalkTree (pScreen, TellChanged, (pointer) pScreen);
+	WalkTree (pScreen, TellChanged, (void *) pScreen);
 	for (i = 0; i < pScrPriv->numOutputs; i++)
 	    pScrPriv->outputs[i]->changed = FALSE;
 	for (i = 0; i < pScrPriv->numCrtcs; i++)
diff --git a/nx-X11/programs/Xserver/randr/randrstr.h b/nx-X11/programs/Xserver/randr/randrstr.h
index 52067b51e..3c3db2c13 100644
--- a/nx-X11/programs/Xserver/randr/randrstr.h
+++ b/nx-X11/programs/Xserver/randr/randrstr.h
@@ -91,7 +91,7 @@ struct _rrPropertyValue {
     Atom	    type;       /* ignored by server */
     short	    format;     /* format of data for swapping - 8,16,32 */
     long	    size;	/* size of data in (format/8) bytes */
-    pointer         data;	/* private to client */
+    void            *data;	/* private to client */
 };
 
 struct _rrProperty {
@@ -283,7 +283,7 @@ extern int rrPrivIndex;
 
 #define rrGetScrPriv(pScr)  ((rrScrPrivPtr) (pScr)->devPrivates[rrPrivIndex].ptr)
 #define rrScrPriv(pScr)	rrScrPrivPtr    pScrPriv = rrGetScrPriv(pScr)
-#define SetRRScreen(s,p) ((s)->devPrivates[rrPrivIndex].ptr = (pointer) (p))
+#define SetRRScreen(s,p) ((s)->devPrivates[rrPrivIndex].ptr = (void *) (p))
 
 #endif
 
@@ -785,7 +785,7 @@ RRPostPendingProperties (RROutputPtr output);
 int
 RRChangeOutputProperty (RROutputPtr output, Atom property, Atom type,
 			int format, int mode, unsigned long len,
-			pointer value, Bool sendevent, Bool pending);
+			void * value, Bool sendevent, Bool pending);
 
 int
 RRConfigureOutputProperty (RROutputPtr output, Atom property,
diff --git a/nx-X11/programs/Xserver/randr/rrcrtc.c b/nx-X11/programs/Xserver/randr/rrcrtc.c
index bc1040c9f..fdf063901 100644
--- a/nx-X11/programs/Xserver/randr/rrcrtc.c
+++ b/nx-X11/programs/Xserver/randr/rrcrtc.c
@@ -107,7 +107,7 @@ RRCrtcCreate (ScreenPtr pScreen, void *devPrivate)
     crtc->changed = FALSE;
     crtc->devPrivate = devPrivate;
 
-    if (!AddResource (crtc->id, RRCrtcType, (pointer) crtc))
+    if (!AddResource (crtc->id, RRCrtcType, (void *) crtc))
 	return NULL;
 
     /* attach the screen and crtc together */
@@ -385,7 +385,7 @@ RRCrtcDestroy (RRCrtcPtr crtc)
 }
 
 static int
-RRCrtcDestroyResource (pointer value, XID pid)
+RRCrtcDestroyResource (void * value, XID pid)
 {
     RRCrtcPtr	crtc = (RRCrtcPtr) value;
     ScreenPtr	pScreen = crtc->pScreen;
diff --git a/nx-X11/programs/Xserver/randr/rrdispatch.c b/nx-X11/programs/Xserver/randr/rrdispatch.c
index 3d52b3879..4c6a5ff48 100644
--- a/nx-X11/programs/Xserver/randr/rrdispatch.c
+++ b/nx-X11/programs/Xserver/randr/rrdispatch.c
@@ -120,7 +120,7 @@ ProcRRSelectInput (ClientPtr client)
 	     */
 	    clientResource = FakeClientID (client->index);
 	    pRREvent->clientResource = clientResource;
-	    if (!AddResource (clientResource, RRClientType, (pointer)pRREvent))
+	    if (!AddResource (clientResource, RRClientType, (void *)pRREvent))
 		return BadAlloc;
 	    /*
 	     * create a resource to contain a pointer to the list
@@ -132,7 +132,7 @@ ProcRRSelectInput (ClientPtr client)
 	    {
 		pHead = (RREventPtr *) xalloc (sizeof (RREventPtr));
 		if (!pHead ||
-		    !AddResource (pWin->drawable.id, RREventType, (pointer)pHead))
+		    !AddResource (pWin->drawable.id, RREventType, (void *)pHead))
 		{
 		    FreeResource (clientResource, RT_NONE);
 		    return BadAlloc;
diff --git a/nx-X11/programs/Xserver/randr/rrmode.c b/nx-X11/programs/Xserver/randr/rrmode.c
index de51bec81..cb45bf74a 100644
--- a/nx-X11/programs/Xserver/randr/rrmode.c
+++ b/nx-X11/programs/Xserver/randr/rrmode.c
@@ -98,7 +98,7 @@ RRModeCreate (xRRModeInfo   *modeInfo,
     }
 
     mode->mode.id = FakeClientID(0);
-    if (!AddResource(mode->mode.id, RRModeType, (pointer) mode)) {
+    if (!AddResource(mode->mode.id, RRModeType, (void *) mode)) {
         xfree(newModes);
         return NULL;
     }
@@ -274,7 +274,7 @@ RRModeDestroy (RRModePtr mode)
 }
 
 static int
-RRModeDestroyResource (pointer value, XID pid)
+RRModeDestroyResource (void * value, XID pid)
 {
     RRModeDestroy ((RRModePtr) value);
     return 1;
diff --git a/nx-X11/programs/Xserver/randr/rroutput.c b/nx-X11/programs/Xserver/randr/rroutput.c
index 693f5a5d3..06f8024e4 100644
--- a/nx-X11/programs/Xserver/randr/rroutput.c
+++ b/nx-X11/programs/Xserver/randr/rroutput.c
@@ -100,7 +100,7 @@ RROutputCreate (ScreenPtr   pScreen,
     output->changed = FALSE;
     output->devPrivate = devPrivate;
     
-    if (!AddResource (output->id, RROutputType, (pointer) output))
+    if (!AddResource (output->id, RROutputType, (void *) output))
 	return NULL;
 
     pScrPriv->outputs[pScrPriv->numOutputs++] = output;
@@ -369,7 +369,7 @@ RROutputDestroy (RROutputPtr output)
 }
 
 static int
-RROutputDestroyResource (pointer value, XID pid)
+RROutputDestroyResource (void * value, XID pid)
 {
     RROutputPtr	output = (RROutputPtr) value;
     ScreenPtr	pScreen = output->pScreen;
diff --git a/nx-X11/programs/Xserver/randr/rrproperty.c b/nx-X11/programs/Xserver/randr/rrproperty.c
index 429246c68..4b73336e8 100644
--- a/nx-X11/programs/Xserver/randr/rrproperty.c
+++ b/nx-X11/programs/Xserver/randr/rrproperty.c
@@ -121,7 +121,7 @@ RRDeleteOutputProperty (RROutputPtr output, Atom property)
 int
 RRChangeOutputProperty (RROutputPtr output, Atom property, Atom type,
 			int format, int mode, unsigned long len,
-			pointer value, Bool sendevent, Bool pending)
+			void * value, Bool sendevent, Bool pending)
 {
     RRPropertyPtr		    prop;
     xRROutputPropertyNotifyEvent    event;
@@ -167,10 +167,10 @@ RRChangeOutputProperty (RROutputPtr output, Atom property, Atom type,
 
     if (mode == PropModeReplace || len > 0)
     {
-	pointer	    new_data = NULL, old_data = NULL;
+	void *new_data = NULL, *old_data = NULL;
 
 	total_size = total_len * size_in_bytes;
-	new_value.data = (pointer)xalloc (total_size);
+	new_value.data = (void *)xalloc (total_size);
 	if (!new_value.data && total_size)
 	{
 	    if (add)
@@ -187,13 +187,13 @@ RRChangeOutputProperty (RROutputPtr output, Atom property, Atom type,
 	    old_data = NULL;
 	    break;
 	case PropModeAppend:
-	    new_data = (pointer) (((char *) new_value.data) + 
+	    new_data = (void *) (((char *) new_value.data) + 
 				  (prop_value->size * size_in_bytes));
 	    old_data = new_value.data;
 	    break;
 	case PropModePrepend:
 	    new_data = new_value.data;
-	    old_data = (pointer) (((char *) new_value.data) + 
+	    old_data = (void *) (((char *) new_value.data) + 
 				  (prop_value->size * size_in_bytes));
 	    break;
 	}
@@ -534,7 +534,7 @@ ProcRRChangeOutputProperty (ClientPtr client)
 
     err = RRChangeOutputProperty(output, stuff->property,
 				 stuff->type, (int)format,
-				 (int)mode, len, (pointer)&stuff[1], TRUE, TRUE);
+				 (int)mode, len, (void *)&stuff[1], TRUE, TRUE);
     if (err != Success)
 	return err;
     else
diff --git a/nx-X11/programs/Xserver/record/record.c b/nx-X11/programs/Xserver/record/record.c
index fd5e5db1d..aa1cd7543 100644
--- a/nx-X11/programs/Xserver/record/record.c
+++ b/nx-X11/programs/Xserver/record/record.c
@@ -141,7 +141,7 @@ static int numEnabledRCAPs;
 }
 
 static int RecordDeleteContext(
-    pointer /*value*/,
+    void * /*value*/,
     XID /*id*/
 );
 
@@ -242,9 +242,9 @@ RecordFindContextOnAllContexts(pContext)
 static void
 RecordFlushReplyBuffer(
     RecordContextPtr pContext,
-    pointer data1,
+    void * data1,
     int len1,
-    pointer data2,
+    void * data2,
     int len2
 )
 {
@@ -290,7 +290,7 @@ RecordFlushReplyBuffer(
  */
 static void
 RecordAProtocolElement(RecordContextPtr pContext, ClientPtr pClient,
-		       int category, pointer data, int datalen, int futurelen)
+		       int category, void * data, int datalen, int futurelen)
 {
     CARD32 elemHeaderData[2];
     int numElemHeaders = 0;
@@ -404,8 +404,8 @@ RecordAProtocolElement(RecordContextPtr pContext, ClientPtr pClient,
 	}
     }
     else
-	RecordFlushReplyBuffer(pContext, (pointer)elemHeaderData,
-			       numElemHeaders, (pointer)data, datalen);
+	RecordFlushReplyBuffer(pContext, (void *)elemHeaderData,
+			       numElemHeaders, (void *)data, datalen);
 
 } /* RecordAProtocolElement */
 
@@ -487,19 +487,19 @@ RecordABigRequest(pContext, client, stuff)
     /* record the request header */
     bytesLeft = client->req_len << 2;
     RecordAProtocolElement(pContext, client, XRecordFromClient,
-			   (pointer)stuff, SIZEOF(xReq), bytesLeft);
+			   (void *)stuff, SIZEOF(xReq), bytesLeft);
 
     /* reinsert the extended length field that was squished out */
     bigLength = client->req_len + (sizeof(bigLength) >> 2);
     if (client->swapped)
 	swapl(&bigLength, n);
     RecordAProtocolElement(pContext, client, XRecordFromClient,
-		(pointer)&bigLength, sizeof(bigLength), /* continuation */ -1);
+		(void *)&bigLength, sizeof(bigLength), /* continuation */ -1);
     bytesLeft -= sizeof(bigLength);
 
     /* record the rest of the request after the length */
     RecordAProtocolElement(pContext, client, XRecordFromClient,
-		(pointer)(stuff + 1), bytesLeft, /* continuation */ -1);
+		(void *)(stuff + 1), bytesLeft, /* continuation */ -1);
 } /* RecordABigRequest */
 
 
@@ -547,7 +547,7 @@ RecordARequest(client)
 		    RecordABigRequest(pContext, client, stuff);
 		else
 		    RecordAProtocolElement(pContext, client, XRecordFromClient,
-				(pointer)stuff, client->req_len << 2, 0);
+				(void *)stuff, client->req_len << 2, 0);
 	    }
 	    else /* extension, check minor opcode */
 	    {
@@ -570,7 +570,7 @@ RecordARequest(client)
 			    RecordABigRequest(pContext, client, stuff);
 			else
 			    RecordAProtocolElement(pContext, client, 
-					XRecordFromClient, (pointer)stuff,
+					XRecordFromClient, (void *)stuff,
 					client->req_len << 2, 0);
 			break;
 		    }			    
@@ -607,8 +607,8 @@ RecordARequest(client)
 static void
 RecordASkippedRequest(pcbl , nulldata, calldata)
     CallbackListPtr *pcbl;
-    pointer nulldata;
-    pointer calldata;
+    void * nulldata;
+    void * calldata;
 {
     SkippedRequestInfoRec *psi = (SkippedRequestInfoRec *)calldata;
     RecordContextPtr pContext;
@@ -639,7 +639,7 @@ RecordASkippedRequest(pcbl , nulldata, calldata)
 		{ /* core request */
 
 		    RecordAProtocolElement(pContext, client, XRecordFromClient,
-				(pointer)stuff, reqlen, 0);
+				(void *)stuff, reqlen, 0);
 		}
 		else /* extension, check minor opcode */
 		{
@@ -659,7 +659,7 @@ RecordASkippedRequest(pcbl , nulldata, calldata)
 						minorop))
 			{
 			    RecordAProtocolElement(pContext, client, 
-				    XRecordFromClient, (pointer)stuff,
+				    XRecordFromClient, (void *)stuff,
 				    reqlen, 0);
 			    break;
 			}			    
@@ -697,8 +697,8 @@ RecordASkippedRequest(pcbl , nulldata, calldata)
 static void
 RecordAReply(pcbl, nulldata, calldata)
     CallbackListPtr *pcbl;
-    pointer nulldata;
-    pointer calldata;
+    void * nulldata;
+    void * calldata;
 {
     RecordContextPtr pContext;
     RecordClientsAndProtocolPtr pRCAP;
@@ -782,8 +782,8 @@ RecordAReply(pcbl, nulldata, calldata)
 static void
 RecordADeliveredEventOrError(pcbl, nulldata, calldata)
     CallbackListPtr *pcbl;
-    pointer nulldata;
-    pointer calldata;
+    void * nulldata;
+    void * calldata;
 {
     EventInfoRec *pei = (EventInfoRec *)calldata;
     RecordContextPtr pContext;
@@ -851,8 +851,8 @@ RecordADeliveredEventOrError(pcbl, nulldata, calldata)
 static void
 RecordADeviceEvent(pcbl, nulldata, calldata)
     CallbackListPtr *pcbl;
-    pointer nulldata;
-    pointer calldata;
+    void * nulldata;
+    void * calldata;
 {
     DeviceEventInfoRec *pei = (DeviceEventInfoRec *)calldata;
     RecordContextPtr pContext;
@@ -932,8 +932,8 @@ RecordADeviceEvent(pcbl, nulldata, calldata)
 static void
 RecordFlushAllContexts(
     CallbackListPtr *pcbl,
-    pointer nulldata,
-    pointer calldata
+    void * nulldata,
+    void * calldata
 )
 {
     int eci; /* enabled context index */
@@ -1008,7 +1008,7 @@ RecordInstallHooks(pRCAP, oneclient)
 			   sizeof (pClientPriv->recordVector));
 		    pClientPriv->originalVector = pClient->requestVector;
 		    pClient->devPrivates[RecordClientPrivateIndex].ptr =
-			(pointer)pClientPriv;
+			(void *)pClientPriv;
 		    pClient->requestVector = pClientPriv->recordVector;
 		}
 		while ((pIter = RecordIterateSet(pRCAP->pRequestMajorOpSet,
@@ -2061,7 +2061,7 @@ ProcRecordCreateContext(client)
     }
     else
     {
-	RecordDeleteContext((pointer)pContext, pContext->id);
+	RecordDeleteContext((void *)pContext, pContext->id);
 	err = BadAlloc;
     }
 bailout:
@@ -2621,7 +2621,7 @@ ProcRecordDisableContext(client)
  */
 static int
 RecordDeleteContext(value, id)
-    pointer value;
+    void * value;
     XID id;
 {
     int i;
@@ -2755,7 +2755,7 @@ SProcRecordCreateContext(client)
 
     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xRecordCreateContextReq);
-    if ((status = SwapCreateRegister((pointer)stuff)) != Success)
+    if ((status = SwapCreateRegister((void *)stuff)) != Success)
 	return status;
     return ProcRecordCreateContext(client);
 } /* SProcRecordCreateContext */
@@ -2771,7 +2771,7 @@ SProcRecordRegisterClients(client)
 
     swaps(&stuff->length, n);
     REQUEST_AT_LEAST_SIZE(xRecordRegisterClientsReq);
-    if ((status = SwapCreateRegister((pointer)stuff)) != Success)
+    if ((status = SwapCreateRegister((void *)stuff)) != Success)
 	return status;
     return ProcRecordRegisterClients(client);
 } /* SProcRecordRegisterClients */
@@ -2908,7 +2908,7 @@ RecordConnectionSetupInfo(pContext, pci)
 	SwapConnSetupPrefix(pci->prefix, pConnSetup);
 	SwapConnSetupInfo(pci->setup, pConnSetup + prefixsize);
 	RecordAProtocolElement(pContext, pci->client, XRecordClientStarted,
-			       (pointer)pConnSetup, prefixsize + restsize, 0);
+			       (void *)pConnSetup, prefixsize + restsize, 0);
 	DEALLOCATE_LOCAL(pConnSetup);
     }
     else
@@ -2917,9 +2917,9 @@ RecordConnectionSetupInfo(pContext, pci)
 	 * data in two pieces
 	 */
 	RecordAProtocolElement(pContext, pci->client, XRecordClientStarted,
-			(pointer)pci->prefix, prefixsize, restsize);
+			(void *)pci->prefix, prefixsize, restsize);
 	RecordAProtocolElement(pContext, pci->client, XRecordClientStarted,
-			(pointer)pci->setup, restsize, /* continuation */ -1);
+			(void *)pci->setup, restsize, /* continuation */ -1);
     }
 } /* RecordConnectionSetupInfo */
 
@@ -2950,8 +2950,8 @@ RecordConnectionSetupInfo(pContext, pci)
 static void
 RecordAClientStateChange(pcbl, nulldata, calldata)
     CallbackListPtr *pcbl;
-    pointer nulldata;
-    pointer calldata;
+    void * nulldata;
+    void * calldata;
 {
     NewClientInfoRec *pci = (NewClientInfoRec *)calldata;
     int i;
diff --git a/nx-X11/programs/Xserver/record/recordmod.c b/nx-X11/programs/Xserver/record/recordmod.c
index 5afb1d379..5a74f0f1a 100644
--- a/nx-X11/programs/Xserver/record/recordmod.c
+++ b/nx-X11/programs/Xserver/record/recordmod.c
@@ -35,12 +35,12 @@ static XF86ModuleVersionInfo VersRec = {
 
 XF86ModuleData recordModuleData = { &VersRec, recordSetup, NULL };
 
-static pointer
-recordSetup(pointer module, pointer opts, int *errmaj, int *errmin)
+static void *
+recordSetup(void * module, void * opts, int *errmaj, int *errmin)
 {
     LoadExtension(&recordExt, FALSE);
 
     /* Need a non-NULL return value to indicate success */
-    return (pointer)1;
+    return (void *)1;
 }
 
diff --git a/nx-X11/programs/Xserver/render/animcur.c b/nx-X11/programs/Xserver/render/animcur.c
index e3915b2b8..15293af64 100644
--- a/nx-X11/programs/Xserver/render/animcur.c
+++ b/nx-X11/programs/Xserver/render/animcur.c
@@ -95,7 +95,7 @@ int	AnimCurGeneration;
 #define GetAnimCur(c)	    ((AnimCurPtr) ((c) + 1))
 #define GetAnimCurScreen(s) ((AnimCurScreenPtr) ((s)->devPrivates[AnimCurScreenPrivateIndex].ptr))
 #define GetAnimCurScreenIfSet(s) ((AnimCurScreenPrivateIndex != -1) ? GetAnimCurScreen(s) : NULL)
-#define SetAnimCurScreen(s,p) ((s)->devPrivates[AnimCurScreenPrivateIndex].ptr = (pointer) (p))
+#define SetAnimCurScreen(s,p) ((s)->devPrivates[AnimCurScreenPrivateIndex].ptr = (void *) (p))
 
 #define Wrap(as,s,elt,func) (((as)->elt = (s)->elt), (s)->elt = func)
 #define Unwrap(as,s,elt)    ((s)->elt = (as)->elt)
@@ -164,9 +164,9 @@ AnimCurCursorLimits (ScreenPtr pScreen,
 
 static void
 AnimCurScreenBlockHandler (int screenNum,
-			   pointer blockData,
-			   pointer pTimeout,
-			   pointer pReadmask)
+			   void * blockData,
+			   void * pTimeout,
+			   void * pReadmask)
 {
     ScreenPtr		pScreen = screenInfo.screens[screenNum];
     AnimCurScreenPtr    as = GetAnimCurScreen(pScreen);
diff --git a/nx-X11/programs/Xserver/render/glyph.c b/nx-X11/programs/Xserver/render/glyph.c
index 9f4d1c87b..900cf9844 100644
--- a/nx-X11/programs/Xserver/render/glyph.c
+++ b/nx-X11/programs/Xserver/render/glyph.c
@@ -114,30 +114,30 @@ ResetGlyphSetPrivateIndex (void)
 }
 
 Bool
-_GlyphSetSetNewPrivate (GlyphSetPtr glyphSet, int n, pointer ptr)
+_GlyphSetSetNewPrivate (GlyphSetPtr glyphSet, int n, void * ptr)
 {
-    pointer *new;
+    void **new;
 
     if (n > glyphSet->maxPrivate) {
 	if (glyphSet->devPrivates &&
-	    glyphSet->devPrivates != (pointer)(&glyphSet[1])) {
-	    new = (pointer *) xrealloc (glyphSet->devPrivates,
-					(n + 1) * sizeof (pointer));
+	    glyphSet->devPrivates != (void *)(&glyphSet[1])) {
+	    new = (void **) xrealloc (glyphSet->devPrivates,
+					(n + 1) * sizeof (void *));
 	    if (!new)
 		return FALSE;
 	} else {
-	    new = (pointer *) xalloc ((n + 1) * sizeof (pointer));
+	    new = (void **) xalloc ((n + 1) * sizeof (void *));
 	    if (!new)
 		return FALSE;
 	    if (glyphSet->devPrivates)
 		memcpy (new,
 			glyphSet->devPrivates,
-			(glyphSet->maxPrivate + 1) * sizeof (pointer));
+			(glyphSet->maxPrivate + 1) * sizeof (void *));
 	}
 	glyphSet->devPrivates = new;
 	/* Zero out new, uninitialize privates */
 	while (++glyphSet->maxPrivate < n)
-	    glyphSet->devPrivates[glyphSet->maxPrivate] = (pointer)0;
+	    glyphSet->devPrivates[glyphSet->maxPrivate] = (void *)0;
     }
     glyphSet->devPrivates[n] = ptr;
     return TRUE;
@@ -430,14 +430,14 @@ AllocateGlyphSet (int fdepth, PictFormatPtr format)
     }
 
     size = (sizeof (GlyphSetRec) +
-	    (sizeof (pointer) * _GlyphSetPrivateAllocateIndex));
+	    (sizeof (void *) * _GlyphSetPrivateAllocateIndex));
     glyphSet = xalloc (size);
     if (!glyphSet)
 	return FALSE;
     bzero((char *)glyphSet, size);
     glyphSet->maxPrivate = _GlyphSetPrivateAllocateIndex - 1;
     if (_GlyphSetPrivateAllocateIndex)
-	glyphSet->devPrivates = (pointer)(&glyphSet[1]);
+	glyphSet->devPrivates = (void *)(&glyphSet[1]);
 
     if (!AllocateGlyphHash (&glyphSet->hash, &glyphHashSets[0]))
     {
@@ -451,7 +451,7 @@ AllocateGlyphSet (int fdepth, PictFormatPtr format)
 }
 
 int
-FreeGlyphSet (pointer	value,
+FreeGlyphSet (void	*value,
 	      XID       gid)
 {
     GlyphSetPtr	glyphSet = (GlyphSetPtr) value;
@@ -479,7 +479,7 @@ FreeGlyphSet (pointer	value,
 	xfree (table);
 
 	if (glyphSet->devPrivates &&
-	    glyphSet->devPrivates != (pointer)(&glyphSet[1]))
+	    glyphSet->devPrivates != (void *)(&glyphSet[1]))
 	    xfree(glyphSet->devPrivates);
 
 	xfree (glyphSet);
diff --git a/nx-X11/programs/Xserver/render/glyphstr.h b/nx-X11/programs/Xserver/render/glyphstr.h
index f4777a248..e9bbd19b0 100644
--- a/nx-X11/programs/Xserver/render/glyphstr.h
+++ b/nx-X11/programs/Xserver/render/glyphstr.h
@@ -69,12 +69,12 @@ typedef struct _GlyphSet {
     int		    fdepth;
     GlyphHashRec    hash;
     int             maxPrivate;
-    pointer         *devPrivates;
+    void            **devPrivates;
 } GlyphSetRec, *GlyphSetPtr;
 
 #define GlyphSetGetPrivate(pGlyphSet,n)					\
 	((n) > (pGlyphSet)->maxPrivate ?				\
-	 (pointer) 0 :							\
+	 (void *) 0 :							\
 	 (pGlyphSet)->devPrivates[n])
 
 #define GlyphSetSetPrivate(pGlyphSet,n,ptr)				\
@@ -101,7 +101,7 @@ void
 ResetGlyphSetPrivateIndex (void);
 
 Bool
-_GlyphSetSetNewPrivate (GlyphSetPtr glyphSet, int n, pointer ptr);
+_GlyphSetSetNewPrivate (GlyphSetPtr glyphSet, int n, void * ptr);
 
 Bool
 GlyphInit (ScreenPtr pScreen);
@@ -140,7 +140,7 @@ GlyphSetPtr
 AllocateGlyphSet (int fdepth, PictFormatPtr format);
 
 int
-FreeGlyphSet (pointer   value,
+FreeGlyphSet (void      *value,
 	      XID       gid);
 
 
diff --git a/nx-X11/programs/Xserver/render/miglyph.c b/nx-X11/programs/Xserver/render/miglyph.c
index 237ec13a4..8b046bd46 100644
--- a/nx-X11/programs/Xserver/render/miglyph.c
+++ b/nx-X11/programs/Xserver/render/miglyph.c
@@ -168,7 +168,7 @@ miGlyphs (CARD8		op,
 		pPixmap = GetScratchPixmapHeader (pScreen, glyph->info.width, glyph->info.height, 
 						  list->format->depth,
 						  list->format->depth, 
-						  0, (pointer) (glyph + 1));
+						  0, (void *) (glyph + 1));
 		if (!pPixmap)
 		    return;
 		component_alpha = NeedsComponent(list->format->format);
@@ -183,7 +183,7 @@ miGlyphs (CARD8		op,
 	    }
 	    (*pScreen->ModifyPixmapHeader) (pPixmap, 
 					    glyph->info.width, glyph->info.height,
-					    0, 0, -1, (pointer) (glyph + 1));
+					    0, 0, -1, (void *) (glyph + 1));
 	    pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
 	    if (maskFormat)
 	    {
@@ -219,7 +219,7 @@ miGlyphs (CARD8		op,
 	if (pPicture)
 	{
 	    FreeScratchPixmapHeader (pPixmap);
-	    FreePicture ((pointer) pPicture, 0);
+	    FreePicture ((void *) pPicture, 0);
 	    pPicture = 0;
 	    pPixmap = 0;
 	}
@@ -237,7 +237,7 @@ miGlyphs (CARD8		op,
 			  0, 0,
 			  x, y,
 			  width, height);
-	FreePicture ((pointer) pMask, (XID) 0);
+	FreePicture ((void *) pMask, (XID) 0);
 	(*pScreen->DestroyPixmap) (pMaskPixmap);
     }
 }
diff --git a/nx-X11/programs/Xserver/render/mipict.c b/nx-X11/programs/Xserver/render/mipict.c
index 59707ea70..cf9c27f01 100644
--- a/nx-X11/programs/Xserver/render/mipict.c
+++ b/nx-X11/programs/Xserver/render/mipict.c
@@ -75,18 +75,18 @@ miDestroyPictureClip (PicturePtr pPicture)
 int
 miChangePictureClip (PicturePtr    pPicture,
 		     int	   type,
-		     pointer	   value,
+		     void *	   value,
 		     int	   n)
 {
     ScreenPtr		pScreen = pPicture->pDrawable->pScreen;
     PictureScreenPtr    ps = GetPictureScreen(pScreen);
-    pointer		clientClip;
+    void *		clientClip;
     int			clientClipType;
     
     switch (type) {
     case CT_PIXMAP:
 	/* convert the pixmap to a region */
-	clientClip = (pointer) BITMAP_TO_REGION(pScreen, (PixmapPtr) value);
+	clientClip = (void *) BITMAP_TO_REGION(pScreen, (PixmapPtr) value);
 	if (!clientClip)
 	    return BadAlloc;
 	clientClipType = CT_REGION;
@@ -101,7 +101,7 @@ miChangePictureClip (PicturePtr    pPicture,
 	clientClipType = CT_NONE;
 	break;
     default:
-	clientClip = (pointer) RECTS_TO_REGION(pScreen, n,
+	clientClip = (void *) RECTS_TO_REGION(pScreen, n,
 					       (xRectangle *) value,
 					       type);
 	if (!clientClip)
diff --git a/nx-X11/programs/Xserver/render/mipict.h b/nx-X11/programs/Xserver/render/mipict.h
index 0c2ed04d5..726d8be65 100644
--- a/nx-X11/programs/Xserver/render/mipict.h
+++ b/nx-X11/programs/Xserver/render/mipict.h
@@ -60,7 +60,7 @@ miDestroyPictureClip (PicturePtr pPicture);
 int
 miChangePictureClip (PicturePtr    pPicture,
 		     int	   type,
-		     pointer	   value,
+		     void *	   value,
 		     int	   n);
 
 void
diff --git a/nx-X11/programs/Xserver/render/mirect.c b/nx-X11/programs/Xserver/render/mirect.c
index 096bb5cb2..c4aeb9aba 100644
--- a/nx-X11/programs/Xserver/render/mirect.c
+++ b/nx-X11/programs/Xserver/render/mirect.c
@@ -174,7 +174,7 @@ miCompositeRects (CARD8		op,
 	    rects++;
 	}
 
-	FreePicture ((pointer) pSrc, 0);
+	FreePicture ((void *) pSrc, 0);
 bail4:
 	FreeScratchGC (pGC);
 bail3:
diff --git a/nx-X11/programs/Xserver/render/picture.c b/nx-X11/programs/Xserver/render/picture.c
index 3ed60310e..754d468bb 100644
--- a/nx-X11/programs/Xserver/render/picture.c
+++ b/nx-X11/programs/Xserver/render/picture.c
@@ -114,7 +114,7 @@ PictureDestroyWindow (WindowPtr pWindow)
 	SetPictureWindow(pWindow, pPicture->pNext);
 	if (pPicture->id)
 	    FreeResource (pPicture->id, PictureType);
-	FreePicture ((pointer) pPicture, pPicture->id);
+	FreePicture ((void *) pPicture, pPicture->id);
     }
     pScreen->DestroyWindow = ps->DestroyWindow;
     ret = (*pScreen->DestroyWindow) (pWindow);
@@ -653,7 +653,7 @@ PictureInit (ScreenPtr pScreen, PictFormatPtr formats, int nformats)
     }
     for (n = 0; n < nformats; n++)
     {
-	if (!AddResource (formats[n].id, PictFormatType, (pointer) (formats+n)))
+	if (!AddResource (formats[n].id, PictFormatType, (void *) (formats+n)))
 	{
 	    xfree (formats);
 	    return FALSE;
@@ -789,11 +789,11 @@ AllocatePicture (ScreenPtr  pScreen)
     {
 	if ( (size = *sizes) )
 	{
-	    ppriv->ptr = (pointer)ptr;
+	    ppriv->ptr = (void *)ptr;
 	    ptr += size;
 	}
 	else
-	    ppriv->ptr = (pointer)NULL;
+	    ppriv->ptr = (void *)NULL;
     }
     return pPicture;
 }
@@ -1223,7 +1223,7 @@ ChangePicture (PicturePtr	pPicture,
 		    if (pAlpha && pAlpha->pDrawable->type == DRAWABLE_PIXMAP)
 			pAlpha->refcnt++;
 		    if (pPicture->alphaMap)
-			FreePicture ((pointer) pPicture->alphaMap, (XID) 0);
+			FreePicture ((void *) pPicture->alphaMap, (XID) 0);
 		    pPicture->alphaMap = pAlpha;
 		}
 	    }
@@ -1295,7 +1295,7 @@ ChangePicture (PicturePtr	pPicture,
 		    }
 		}
 		error = (*ps->ChangePictureClip)(pPicture, clipType,
-						 (pointer)pPixmap, 0);
+						 (void *)pPixmap, 0);
 		break;
 	    }
 	case CPGraphicsExposure:
@@ -1395,7 +1395,7 @@ SetPictureClipRects (PicturePtr	pPicture,
     if (!clientClip)
 	return BadAlloc;
     result =(*ps->ChangePictureClip) (pPicture, CT_REGION, 
-				      (pointer) clientClip, 0);
+				      (void *) clientClip, 0);
     if (result == Success)
     {
 	pPicture->clipOrigin.x = xOrigin;
@@ -1439,7 +1439,7 @@ SetPictureClipRegion (PicturePtr    pPicture,
     }
 
     result =(*ps->ChangePictureClip) (pPicture, type,
-                                      (pointer) clientClip, 0);
+                                      (void *) clientClip, 0);
     if (result == Success)
     {
         pPicture->clipOrigin.x = xOrigin;
@@ -1511,7 +1511,7 @@ CopyPicture (PicturePtr	pSrc,
 	    if (pSrc->alphaMap && pSrc->alphaMap->pDrawable->type == DRAWABLE_PIXMAP)
 		pSrc->alphaMap->refcnt++;
 	    if (pDst->alphaMap)
-		FreePicture ((pointer) pDst->alphaMap, (XID) 0);
+		FreePicture ((void *) pDst->alphaMap, (XID) 0);
 	    pDst->alphaMap = pSrc->alphaMap;
 	    break;
 	case CPAlphaXOrigin:
@@ -1593,7 +1593,7 @@ ValidatePicture(PicturePtr pPicture)
 }
 
 int
-FreePicture (pointer	value,
+FreePicture (void *	value,
 	     XID	pid)
 {
     PicturePtr	pPicture = (PicturePtr) value;
@@ -1613,7 +1613,7 @@ FreePicture (pointer	value,
             PictureScreenPtr    ps = GetPictureScreen(pScreen);
 	
             if (pPicture->alphaMap)
-                FreePicture ((pointer) pPicture->alphaMap, (XID) 0);
+                FreePicture ((void *) pPicture->alphaMap, (XID) 0);
             (*ps->DestroyPicture) (pPicture);
             (*ps->DestroyPictureClip) (pPicture);
             if (pPicture->pDrawable->type == DRAWABLE_WINDOW)
@@ -1643,7 +1643,7 @@ FreePicture (pointer	value,
 }
 
 int
-FreePictFormat (pointer	pPictFormat,
+FreePictFormat (void *	pPictFormat,
 		XID     pid)
 {
     return Success;
diff --git a/nx-X11/programs/Xserver/render/picturestr.h b/nx-X11/programs/Xserver/render/picturestr.h
index 561625766..96c2b8abc 100644
--- a/nx-X11/programs/Xserver/render/picturestr.h
+++ b/nx-X11/programs/Xserver/render/picturestr.h
@@ -149,7 +149,7 @@ typedef struct _Picture {
     DDXPointRec	    alphaOrigin;
 
     DDXPointRec	    clipOrigin;
-    pointer	    clientClip;
+    void	    *clientClip;
 
     Atom	    dither;
 
@@ -195,7 +195,7 @@ typedef int	(*CreatePictureProcPtr)	    (PicturePtr pPicture);
 typedef void	(*DestroyPictureProcPtr)    (PicturePtr pPicture);
 typedef int	(*ChangePictureClipProcPtr) (PicturePtr	pPicture,
 					     int	clipType,
-					     pointer    value,
+					     void       *value,
 					     int	n);
 typedef void	(*DestroyPictureClipProcPtr)(PicturePtr	pPicture);
 
@@ -374,9 +374,9 @@ extern RESTYPE		GlyphSetType;
 
 #define GetPictureScreen(s) ((PictureScreenPtr) ((s)->devPrivates[PictureScreenPrivateIndex].ptr))
 #define GetPictureScreenIfSet(s) ((PictureScreenPrivateIndex != -1) ? GetPictureScreen(s) : NULL)
-#define SetPictureScreen(s,p) ((s)->devPrivates[PictureScreenPrivateIndex].ptr = (pointer) (p))
+#define SetPictureScreen(s,p) ((s)->devPrivates[PictureScreenPrivateIndex].ptr = (void *) (p))
 #define GetPictureWindow(w) ((PicturePtr) ((w)->devPrivates[PictureWindowPrivateIndex].ptr))
-#define SetPictureWindow(w,p) ((w)->devPrivates[PictureWindowPrivateIndex].ptr = (pointer) (p))
+#define SetPictureWindow(w,p) ((w)->devPrivates[PictureWindowPrivateIndex].ptr = (void *) (p))
 
 #define VERIFY_PICTURE(pPicture, pid, client, mode, err) {\
     pPicture = SecurityLookupIDByType(client, pid, PictureType, mode);\
@@ -516,11 +516,11 @@ void
 ValidatePicture(PicturePtr pPicture);
 
 int
-FreePicture (pointer	pPicture,
+FreePicture (void	*pPicture,
 	     XID	pid);
 
 int
-FreePictFormat (pointer	pPictFormat,
+FreePictFormat (void	*pPictFormat,
 		XID     pid);
 
 void
diff --git a/nx-X11/programs/Xserver/render/render.c b/nx-X11/programs/Xserver/render/render.c
index 6a65631ea..8d644b35e 100644
--- a/nx-X11/programs/Xserver/render/render.c
+++ b/nx-X11/programs/Xserver/render/render.c
@@ -230,8 +230,8 @@ typedef struct _RenderClient {
 
 static void
 RenderClientCallback (CallbackListPtr	*list,
-		      pointer		closure,
-		      pointer		data)
+		      void *		closure,
+		      void *		data)
 {
     NewClientInfoRec	*clientinfo = (NewClientInfoRec *) data;
     ClientPtr		pClient = clientinfo->client;
@@ -660,7 +660,7 @@ ProcRenderCreatePicture (ClientPtr client)
 			      &error);
     if (!pPicture)
 	return error;
-    if (!AddResource (stuff->pid, PictureType, (pointer)pPicture))
+    if (!AddResource (stuff->pid, PictureType, (void *)pPicture))
 	return BadAlloc;
     return Success;
 }
@@ -1031,7 +1031,7 @@ ProcRenderCreateGlyphSet (ClientPtr client)
     glyphSet = AllocateGlyphSet (f, format);
     if (!glyphSet)
 	return BadAlloc;
-    if (!AddResource (stuff->gsid, GlyphSetType, (pointer)glyphSet))
+    if (!AddResource (stuff->gsid, GlyphSetType, (void *)glyphSet))
 	return BadAlloc;
     return Success;
 }
@@ -1056,7 +1056,7 @@ ProcRenderReferenceGlyphSet (ClientPtr client)
 	return RenderErrBase + BadGlyphSet;
     }
     glyphSet->refcnt++;
-    if (!AddResource (stuff->gsid, GlyphSetType, (pointer)glyphSet))
+    if (!AddResource (stuff->gsid, GlyphSetType, (void *)glyphSet))
 	return BadAlloc;
     return client->noClientException;
 }
@@ -1540,7 +1540,7 @@ ProcRenderCreateCursor (ClientPtr client)
     {
 	(*pScreen->GetImage) (pSrc->pDrawable,
 			      0, 0, width, height, ZPixmap,
-			      0xffffffff, (pointer) argbbits);
+			      0xffffffff, (void *) argbbits);
     }
     else
     {
@@ -1580,7 +1580,7 @@ ProcRenderCreateCursor (ClientPtr client)
 			  0, 0, 0, 0, 0, 0, width, height);
 	(*pScreen->GetImage) (pPicture->pDrawable,
 			      0, 0, width, height, ZPixmap,
-			      0xffffffff, (pointer) argbbits);
+			      0xffffffff, (void *) argbbits);
 	FreePicture (pPicture, 0);
     }
     /*
@@ -1673,7 +1673,7 @@ ProcRenderCreateCursor (ClientPtr client)
 			       GetColor(twocolor[1], 16),
 			       GetColor(twocolor[1], 8),
 			       GetColor(twocolor[1], 0));
-    if (pCursor && AddResource(stuff->cid, RT_CURSOR, (pointer)pCursor))
+    if (pCursor && AddResource(stuff->cid, RT_CURSOR, (void *)pCursor))
 	return (client->noClientException);
     return BadAlloc;
 }
@@ -1864,7 +1864,7 @@ ProcRenderCreateAnimCursor (ClientPtr client)
     if (ret != Success)
 	return ret;
     
-    if (AddResource (stuff->cid, RT_CURSOR, (pointer)pCursor))
+    if (AddResource (stuff->cid, RT_CURSOR, (void *)pCursor))
 	return client->noClientException;
     return BadAlloc;
 }
@@ -1905,7 +1905,7 @@ static int ProcRenderCreateSolidFill(ClientPtr client)
     pPicture = CreateSolidPicture(stuff->pid, &stuff->color, &error);
     if (!pPicture)
 	return error;
-    if (!AddResource (stuff->pid, PictureType, (pointer)pPicture))
+    if (!AddResource (stuff->pid, PictureType, (void *)pPicture))
 	return BadAlloc;
     return Success;
 }
@@ -1936,7 +1936,7 @@ static int ProcRenderCreateLinearGradient (ClientPtr client)
                                             stuff->nStops, stops, colors, &error);
     if (!pPicture)
 	return error;
-    if (!AddResource (stuff->pid, PictureType, (pointer)pPicture))
+    if (!AddResource (stuff->pid, PictureType, (void *)pPicture))
 	return BadAlloc;
     return Success;
 }
@@ -1966,7 +1966,7 @@ static int ProcRenderCreateRadialGradient (ClientPtr client)
                                             stuff->nStops, stops, colors, &error);
     if (!pPicture)
 	return error;
-    if (!AddResource (stuff->pid, PictureType, (pointer)pPicture))
+    if (!AddResource (stuff->pid, PictureType, (void *)pPicture))
 	return BadAlloc;
     return Success;
 }
@@ -1995,7 +1995,7 @@ static int ProcRenderCreateConicalGradient (ClientPtr client)
                                              stuff->nStops, stops, colors, &error);
     if (!pPicture)
 	return error;
-    if (!AddResource (stuff->pid, PictureType, (pointer)pPicture))
+    if (!AddResource (stuff->pid, PictureType, (void *)pPicture))
 	return BadAlloc;
     return Success;
 }
diff --git a/nx-X11/programs/Xserver/xfixes/cursor.c b/nx-X11/programs/Xserver/xfixes/cursor.c
index f6895d193..8bdaca84d 100755
--- a/nx-X11/programs/Xserver/xfixes/cursor.c
+++ b/nx-X11/programs/Xserver/xfixes/cursor.c
@@ -76,7 +76,7 @@ typedef struct _CursorScreen {
 
 #define GetCursorScreen(s)	((CursorScreenPtr) ((s)->devPrivates[CursorScreenPrivateIndex].ptr))
 #define GetCursorScreenIfSet(s) ((CursorScreenPrivateIndex != -1) ? GetCursorScreen(s) : NULL)
-#define SetCursorScreen(s,p)	((s)->devPrivates[CursorScreenPrivateIndex].ptr = (pointer) (p))
+#define SetCursorScreen(s,p)	((s)->devPrivates[CursorScreenPrivateIndex].ptr = (void *) (p))
 #define Wrap(as,s,elt,func)	(((as)->elt = (s)->elt), (s)->elt = func)
 #define Unwrap(as,s,elt)	((s)->elt = (as)->elt)
 
@@ -172,13 +172,13 @@ XFixesSelectCursorInput (ClientPtr	pClient,
 	 */
 	if (!LookupIDByType(pWindow->drawable.id, CursorWindowType))
 	    if (!AddResource (pWindow->drawable.id, CursorWindowType,
-			      (pointer) pWindow))
+			      (void *) pWindow))
 	    {
 		xfree (e);
 		return BadAlloc;
 	    }
 
-	if (!AddResource (e->clientResource, CursorClientType, (pointer) e))
+	if (!AddResource (e->clientResource, CursorClientType, (void *) e))
 	    return BadAlloc;
 
 	*prev = e;
@@ -520,13 +520,13 @@ SProcXFixesGetCursorImageAndName (ClientPtr client)
  * whether it should be replaced with a reference to pCursor.
  */
 
-typedef Bool (*TestCursorFunc) (CursorPtr pOld, pointer closure);
+typedef Bool (*TestCursorFunc) (CursorPtr pOld, void * closure);
 
 typedef struct {
     RESTYPE type;
     TestCursorFunc testCursor;
     CursorPtr pNew;
-    pointer closure;
+    void * closure;
 } ReplaceCursorLookupRec, *ReplaceCursorLookupPtr;
 
 static const RESTYPE    CursorRestypes[] = {
@@ -536,7 +536,7 @@ static const RESTYPE    CursorRestypes[] = {
 #define NUM_CURSOR_RESTYPES (sizeof (CursorRestypes) / sizeof (CursorRestypes[0]))
 
 static Bool
-ReplaceCursorLookup (pointer value, XID id, pointer closure)
+ReplaceCursorLookup (void * value, XID id, void * closure)
 {
     ReplaceCursorLookupPtr  rcl = (ReplaceCursorLookupPtr) closure;
     WindowPtr		    pWin;
@@ -583,7 +583,7 @@ ReplaceCursorLookup (pointer value, XID id, pointer closure)
 static void
 ReplaceCursor (CursorPtr pCursor,
 	       TestCursorFunc testCursor,
-	       pointer closure)
+	       void * closure)
 {
     int	clientIndex;
     int resIndex;
@@ -612,7 +612,7 @@ ReplaceCursor (CursorPtr pCursor,
 	    LookupClientResourceComplex (clients[clientIndex], 
 					 rcl.type, 
 					 ReplaceCursorLookup,
-					 (pointer) &rcl);
+					 (void *) &rcl);
 	}
     }
     /* this "knows" that WindowHasNewCursor doesn't depend on it's argument */
@@ -620,7 +620,7 @@ ReplaceCursor (CursorPtr pCursor,
 }
 
 static Bool 
-TestForCursor (CursorPtr pCursor, pointer closure)
+TestForCursor (CursorPtr pCursor, void * closure)
 {
     return (pCursor == (CursorPtr) closure);
 }
@@ -635,7 +635,7 @@ ProcXFixesChangeCursor (ClientPtr client)
     VERIFY_CURSOR (pSource, stuff->source, client, SecurityReadAccess);
     VERIFY_CURSOR (pDestination, stuff->destination, client, SecurityWriteAccess);
 
-    ReplaceCursor (pSource, TestForCursor, (pointer) pDestination);
+    ReplaceCursor (pSource, TestForCursor, (void *) pDestination);
     return (client->noClientException);
 }
 
@@ -653,7 +653,7 @@ SProcXFixesChangeCursor (ClientPtr client)
 }
 
 static Bool
-TestForCursorName (CursorPtr pCursor, pointer closure)
+TestForCursorName (CursorPtr pCursor, void * closure)
 {
     return (pCursor->name == (Atom) closure);
 }
@@ -671,7 +671,7 @@ ProcXFixesChangeCursorByName (ClientPtr client)
     tchar = (char *) &stuff[1];
     name = MakeAtom (tchar, stuff->nbytes, FALSE);
     if (name)
-	ReplaceCursor (pSource, TestForCursorName, (pointer) name);
+	ReplaceCursor (pSource, TestForCursorName, (void *) name);
     return (client->noClientException);
 }
 
@@ -689,7 +689,7 @@ SProcXFixesChangeCursorByName (ClientPtr client)
 }
 
 static int
-CursorFreeClient (pointer data, XID id)
+CursorFreeClient (void * data, XID id)
 {
     CursorEventPtr	old = (CursorEventPtr) data;
     CursorEventPtr	*prev, e;
@@ -707,7 +707,7 @@ CursorFreeClient (pointer data, XID id)
 }
 
 static int
-CursorFreeWindow (pointer data, XID id)
+CursorFreeWindow (void * data, XID id)
 {
     WindowPtr		pWindow = (WindowPtr) data;
     CursorEventPtr	e, next;
diff --git a/nx-X11/programs/Xserver/xfixes/region.c b/nx-X11/programs/Xserver/xfixes/region.c
index 9ceff6d51..cb9e0de9a 100755
--- a/nx-X11/programs/Xserver/xfixes/region.c
+++ b/nx-X11/programs/Xserver/xfixes/region.c
@@ -39,7 +39,7 @@ extern int RenderErrBase;
 RESTYPE	    RegionResType;
 
 static int
-RegionResFree (pointer data, XID id)
+RegionResFree (void * data, XID id)
 {
     RegionPtr    pRegion = (RegionPtr) data;
 
@@ -87,7 +87,7 @@ ProcXFixesCreateRegion (ClientPtr client)
     pRegion = RECTS_TO_REGION(0, things, (xRectangle *) (stuff + 1), CT_UNSORTED);
     if (!pRegion)
 	return BadAlloc;
-    if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
+    if (!AddResource (stuff->region, RegionResType, (void *) pRegion))
 	return BadAlloc;
     
     return(client->noClientException);
@@ -132,7 +132,7 @@ ProcXFixesCreateRegionFromBitmap (ClientPtr client)
     if (!pRegion)
 	return BadAlloc;
     
-    if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
+    if (!AddResource (stuff->region, RegionResType, (void *) pRegion))
 	return BadAlloc;
     
     return(client->noClientException);
@@ -196,7 +196,7 @@ ProcXFixesCreateRegionFromWindow (ClientPtr client)
 	pRegion = XFixesRegionCopy (pRegion);
     if (!pRegion)
 	return BadAlloc;
-    if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
+    if (!AddResource (stuff->region, RegionResType, (void *) pRegion))
 	return BadAlloc;
     
     return(client->noClientException);
@@ -243,7 +243,7 @@ ProcXFixesCreateRegionFromGC (ClientPtr client)
 	return BadImplementation;   /* assume sane server bits */
     }
     
-    if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
+    if (!AddResource (stuff->region, RegionResType, (void *) pRegion))
 	return BadAlloc;
     
     return(client->noClientException);
@@ -292,7 +292,7 @@ ProcXFixesCreateRegionFromPicture (ClientPtr client)
 	return BadImplementation;   /* assume sane server bits */
     }
     
-    if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
+    if (!AddResource (stuff->region, RegionResType, (void *) pRegion))
 	return BadAlloc;
     
     return(client->noClientException);
@@ -646,7 +646,7 @@ ProcXFixesSetGCClipRegion (ClientPtr client)
     vals[0] = stuff->xOrigin;
     vals[1] = stuff->yOrigin;
     DoChangeGC (pGC, GCClipXOrigin|GCClipYOrigin, vals, 0);
-    (*pGC->funcs->ChangeClip)(pGC, pRegion ? CT_REGION : CT_NONE, (pointer)pRegion, 0);
+    (*pGC->funcs->ChangeClip)(pGC, pRegion ? CT_REGION : CT_NONE, (void *)pRegion, 0);
 
     return (client->noClientException);
 }
diff --git a/nx-X11/programs/Xserver/xfixes/select.c b/nx-X11/programs/Xserver/xfixes/select.c
index ddc776ef7..464979165 100755
--- a/nx-X11/programs/Xserver/xfixes/select.c
+++ b/nx-X11/programs/Xserver/xfixes/select.c
@@ -52,7 +52,7 @@ typedef struct _SelectionEvent {
 static SelectionEventPtr	selectionEvents;
 
 static void
-XFixesSelectionCallback (CallbackListPtr *callbacks, pointer data, pointer args)
+XFixesSelectionCallback (CallbackListPtr *callbacks, void * data, void * args)
 {
     SelectionEventPtr	e;
     SelectionInfoRec	*info = (SelectionInfoRec *) args;
@@ -172,13 +172,13 @@ XFixesSelectSelectionInput (ClientPtr	pClient,
 	 */
 	if (!LookupIDByType(pWindow->drawable.id, SelectionWindowType))
 	    if (!AddResource (pWindow->drawable.id, SelectionWindowType,
-			      (pointer) pWindow))
+			      (void *) pWindow))
 	    {
 		xfree (e);
 		return BadAlloc;
 	    }
 
-	if (!AddResource (e->clientResource, SelectionClientType, (pointer) e))
+	if (!AddResource (e->clientResource, SelectionClientType, (void *) e))
 	    return BadAlloc;
 
 	*prev = e;
@@ -240,7 +240,7 @@ SXFixesSelectionNotifyEvent (xXFixesSelectionNotifyEvent *from,
 }
 
 static int
-SelectionFreeClient (pointer data, XID id)
+SelectionFreeClient (void * data, XID id)
 {
     SelectionEventPtr	old = (SelectionEventPtr) data;
     SelectionEventPtr	*prev, e;
@@ -259,7 +259,7 @@ SelectionFreeClient (pointer data, XID id)
 }
 
 static int
-SelectionFreeWindow (pointer data, XID id)
+SelectionFreeWindow (void * data, XID id)
 {
     WindowPtr		pWindow = (WindowPtr) data;
     SelectionEventPtr	e, next;
diff --git a/nx-X11/programs/Xserver/xfixes/xfixes.c b/nx-X11/programs/Xserver/xfixes/xfixes.c
index 1465931cb..3b3a0f305 100755
--- a/nx-X11/programs/Xserver/xfixes/xfixes.c
+++ b/nx-X11/programs/Xserver/xfixes/xfixes.c
@@ -185,8 +185,8 @@ SProcXFixesDispatch (ClientPtr client)
 
 static void
 XFixesClientCallback (CallbackListPtr	*list,
-		      pointer		closure,
-		      pointer		data)
+		      void		*closure,
+		      void		*data)
 {
     NewClientInfoRec	*clientinfo = (NewClientInfoRec *) data;
     ClientPtr		pClient = clientinfo->client;
diff --git a/nx-X11/programs/Xserver/xkb/ddxBeep.c b/nx-X11/programs/Xserver/xkb/ddxBeep.c
index 429d1e778..22d62a502 100644
--- a/nx-X11/programs/Xserver/xkb/ddxBeep.c
+++ b/nx-X11/programs/Xserver/xkb/ddxBeep.c
@@ -148,7 +148,7 @@ _XkbDDXBeepInitAtoms(void)
 }
 
 static CARD32
-_XkbDDXBeepExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+_XkbDDXBeepExpire(OsTimerPtr timer,CARD32 now,void * arg)
 {
 DeviceIntPtr	dev= (DeviceIntPtr)arg;
 KbdFeedbackPtr	feed;
@@ -322,11 +322,11 @@ Atom		name;
 	ctrl->bell_duration= duration;
 	ctrl->bell_pitch= pitch;
 	if (xkbInfo->beepCount==0) {
-	     XkbHandleBell(0,0,dev,ctrl->bell,(pointer)ctrl,KbdFeedbackClass,name,None,
+	     XkbHandleBell(0,0,dev,ctrl->bell,(void *)ctrl,KbdFeedbackClass,name,None,
 									NULL);
 	}
 	else if (xkbInfo->desc->ctrls->enabled_ctrls&XkbAudibleBellMask) {
-	    (*dev->kbdfeed->BellProc)(ctrl->bell,dev,(pointer)ctrl,KbdFeedbackClass);
+	    (*dev->kbdfeed->BellProc)(ctrl->bell,dev,(void *)ctrl,KbdFeedbackClass);
 	}
 	ctrl->bell_duration= oldDuration;
 	ctrl->bell_pitch= oldPitch;
@@ -360,11 +360,11 @@ CARD32		 next;
 
     xkbInfo->beepType= what;
     xkbInfo->beepCount= 0;
-    next= _XkbDDXBeepExpire(NULL,0,(pointer)dev);
+    next= _XkbDDXBeepExpire(NULL,0,(void *)dev);
     if (next>0) {
 	xkbInfo->beepTimer= TimerSet(xkbInfo->beepTimer,
 					0, next,
-					_XkbDDXBeepExpire, (pointer)dev);
+					_XkbDDXBeepExpire, (void *)dev);
     }
     return 1;
 }
diff --git a/nx-X11/programs/Xserver/xkb/xkb.c b/nx-X11/programs/Xserver/xkb/xkb.c
index 1e4052914..441d88a5c 100644
--- a/nx-X11/programs/Xserver/xkb/xkb.c
+++ b/nx-X11/programs/Xserver/xkb/xkb.c
@@ -369,7 +369,7 @@ ProcXkbBell(ClientPtr client)
     WindowPtr	 pWin;
     int base;
     int newPercent,oldPitch,oldDuration;
-    pointer ctrl;
+    void * ctrl;
 
     REQUEST_SIZE_MATCH(xkbBellReq);
 
@@ -416,7 +416,7 @@ ProcXkbBell(ClientPtr client)
 	    return BadValue;
 	}
 	base = k->ctrl.bell;
-	ctrl = (pointer) &(k->ctrl);
+	ctrl = (void *) &(k->ctrl);
 	oldPitch= k->ctrl.bell_pitch;
 	oldDuration= k->ctrl.bell_duration;
 	if (stuff->pitch!=0) {
@@ -445,7 +445,7 @@ ProcXkbBell(ClientPtr client)
 	    return BadValue;
 	}
 	base = b->ctrl.percent;
-	ctrl = (pointer) &(b->ctrl);
+	ctrl = (void *) &(b->ctrl);
 	oldPitch= b->ctrl.pitch;
 	oldDuration= b->ctrl.duration;
 	if (stuff->pitch!=0) {
@@ -6241,7 +6241,7 @@ ProcXkbDispatch (ClientPtr client)
 }
 
 static int
-XkbClientGone(pointer data,XID id)
+XkbClientGone(void * data,XID id)
 {
     DevicePtr	pXDev = (DevicePtr)data;
 
diff --git a/nx-X11/programs/Xserver/xkb/xkb.h b/nx-X11/programs/Xserver/xkb/xkb.h
index 704cd49c0..3a8a49541 100644
--- a/nx-X11/programs/Xserver/xkb/xkb.h
+++ b/nx-X11/programs/Xserver/xkb/xkb.h
@@ -51,7 +51,7 @@ extern Bool XkbApplyLEDChangeToKeyboard(
     Bool                    on,
     XkbChangesPtr           change);
 
-extern Bool XkbWriteRulesProp(ClientPtr client, pointer closure);
+extern Bool XkbWriteRulesProp(ClientPtr client, void * closure);
 
 extern XkbAction XkbGetButtonAction(DeviceIntPtr kbd, DeviceIntPtr dev, int button);
 
diff --git a/nx-X11/programs/Xserver/xkb/xkbAccessX.c b/nx-X11/programs/Xserver/xkb/xkbAccessX.c
index b31ca7ed5..75e46dc32 100644
--- a/nx-X11/programs/Xserver/xkb/xkbAccessX.c
+++ b/nx-X11/programs/Xserver/xkb/xkbAccessX.c
@@ -47,7 +47,7 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 int	XkbDfltRepeatDelay=	660;
 int	XkbDfltRepeatInterval=	40;
-pointer	XkbLastRepeatEvent=	NULL;
+void *	XkbLastRepeatEvent=	NULL;
 
 #define	DFLT_TIMEOUT_CTRLS (XkbAX_KRGMask|XkbStickyKeysMask|XkbMouseKeysMask)
 #define	DFLT_TIMEOUT_OPTS  (XkbAX_IndicatorFBMask)
@@ -141,7 +141,7 @@ xEvent		xE;
     if (_XkbIsPressEvent(type))
 	XkbDDXKeyClick(keybd,keyCode,TRUE);
     else if (isRepeat)
-	XkbLastRepeatEvent=	(pointer)&xE;
+	XkbLastRepeatEvent=	(void *)&xE;
     XkbProcessKeyboardEvent(&xE,keybd,1L);
     XkbLastRepeatEvent= NULL;
     return;
@@ -286,7 +286,7 @@ XkbSrvLedInfoPtr	sli;
 } /* AccessXStickyKeysTurnOff */
 
 static CARD32
-AccessXKRGExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+AccessXKRGExpire(OsTimerPtr timer,CARD32 now,void * arg)
 {
 XkbSrvInfoPtr		xkbi= ((DeviceIntPtr)arg)->key->xkbInfo;
 xkbControlsNotify	cn;
@@ -308,7 +308,7 @@ xkbControlsNotify	cn;
 }
 
 static CARD32
-AccessXRepeatKeyExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+AccessXRepeatKeyExpire(OsTimerPtr timer,CARD32 now,void * arg)
 {
 XkbSrvInfoPtr	xkbi= ((DeviceIntPtr)arg)->key->xkbInfo;
 KeyCode		key;
@@ -330,7 +330,7 @@ AccessXCancelRepeatKey(XkbSrvInfoPtr xkbi,KeyCode key)
 }
 
 static CARD32
-AccessXSlowKeyExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+AccessXSlowKeyExpire(OsTimerPtr timer,CARD32 now,void * arg)
 {
 DeviceIntPtr	keybd;
 XkbSrvInfoPtr	xkbi;
@@ -370,7 +370,7 @@ XkbControlsPtr	ctrls;
 		xkbi->repeatKey = xkbi->slowKey;
 		xkbi->repeatKeyTimer= TimerSet(xkbi->repeatKeyTimer,
 					0, ctrls->repeat_delay,
-					AccessXRepeatKeyExpire, (pointer)keybd);
+					AccessXRepeatKeyExpire, (void *)keybd);
 	    }
 	}
     }
@@ -378,7 +378,7 @@ XkbControlsPtr	ctrls;
 }
 
 static CARD32
-AccessXBounceKeyExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+AccessXBounceKeyExpire(OsTimerPtr timer,CARD32 now,void * arg)
 {
 XkbSrvInfoPtr	xkbi= ((DeviceIntPtr)arg)->key->xkbInfo;
 
@@ -387,7 +387,7 @@ XkbSrvInfoPtr	xkbi= ((DeviceIntPtr)arg)->key->xkbInfo;
 }
 
 static CARD32
-AccessXTimeoutExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+AccessXTimeoutExpire(OsTimerPtr timer,CARD32 now,void * arg)
 {
 DeviceIntPtr		dev = (DeviceIntPtr)arg;
 XkbSrvInfoPtr		xkbi= dev->key->xkbInfo;
@@ -466,12 +466,12 @@ KeySym *	sym = XkbKeySymsPtr(xkbi->desc,key);
 	    if (XkbAX_NeedFeedback(ctrls,XkbAX_SlowWarnFBMask)) {
 		xkbi->krgTimerActive = _KRG_WARN_TIMER;
 		xkbi->krgTimer= TimerSet(xkbi->krgTimer, 0, 4000,
-					AccessXKRGExpire, (pointer)keybd);
+					AccessXKRGExpire, (void *)keybd);
 	    }
 	    else {
 		xkbi->krgTimerActive = _KRG_TIMER;
 		xkbi->krgTimer= TimerSet(xkbi->krgTimer, 0, 8000,
-					AccessXKRGExpire, (pointer)keybd);
+					AccessXKRGExpire, (void *)keybd);
 	    }
 	    if (!(ctrls->enabled_ctrls & XkbSlowKeysMask)) {
 		CARD32 now= GetTimeInMillis();
@@ -510,7 +510,7 @@ KeySym *	sym = XkbKeySymsPtr(xkbi->desc,key);
 	xkbi->slowKey= key;
 	xkbi->slowKeysTimer = TimerSet(xkbi->slowKeysTimer,
 				 0, ctrls->slow_keys_delay,
-				 AccessXSlowKeyExpire, (pointer)keybd);
+				 AccessXSlowKeyExpire, (void *)keybd);
 	ignoreKeyEvent = TRUE;
     }
 
@@ -543,7 +543,7 @@ KeySym *	sym = XkbKeySymsPtr(xkbi->desc,key);
 		xkbi->repeatKey = key;
 		xkbi->repeatKeyTimer= TimerSet(xkbi->repeatKeyTimer,
 					0, ctrls->repeat_delay,
-					AccessXRepeatKeyExpire, (pointer)keybd);
+					AccessXRepeatKeyExpire, (void *)keybd);
 	    }
 	}
     }
@@ -604,7 +604,7 @@ Bool		ignoreKeyEvent = FALSE;
 	xkbi->inactiveKey= key;
 	xkbi->bounceKeysTimer= TimerSet(xkbi->bounceKeysTimer, 0,
 					ctrls->debounce_delay,
-					AccessXBounceKeyExpire, (pointer)keybd);
+					AccessXBounceKeyExpire, (void *)keybd);
     }
 
     /* Don't transmit the KeyRelease if SlowKeys is turned on and
@@ -645,7 +645,7 @@ Bool		ignoreKeyEvent = FALSE;
 	xkbi->lastPtrEventTime= 0;
 	xkbi->krgTimer= TimerSet(xkbi->krgTimer, 0, 
 					ctrls->ax_timeout*1000,
-					AccessXTimeoutExpire, (pointer)keybd);
+					AccessXTimeoutExpire, (void *)keybd);
 	xkbi->krgTimerActive= _ALL_TIMEOUT_TIMER;
     }
     else if (xkbi->krgTimerActive!=_OFF_TIMER) {
diff --git a/nx-X11/programs/Xserver/xkb/xkbActions.c b/nx-X11/programs/Xserver/xkb/xkbActions.c
index b767658f3..b7f3e13a5 100644
--- a/nx-X11/programs/Xserver/xkb/xkbActions.c
+++ b/nx-X11/programs/Xserver/xkb/xkbActions.c
@@ -48,7 +48,7 @@ int xkbDevicePrivateIndex = -1;
 
 void
 xkbUnwrapProc(DeviceIntPtr device, DeviceHandleProc proc,
-                   pointer data)
+                   void * data)
 {
     xkbDeviceInfoPtr xkbPrivPtr = XKBDEVICEINFO(device);
     ProcessInputProc tmp = device->public.processInputProc;
@@ -533,7 +533,7 @@ _XkbFilterISOLock(	XkbSrvInfoPtr	xkbi,
 
 
 static CARD32
-_XkbPtrAccelExpire(OsTimerPtr timer,CARD32 now,pointer arg)
+_XkbPtrAccelExpire(OsTimerPtr timer,CARD32 now,void * arg)
 {
 XkbSrvInfoPtr	xkbi= (XkbSrvInfoPtr)arg;
 XkbControlsPtr	ctrls= xkbi->desc->ctrls;
@@ -602,7 +602,7 @@ Bool	accel;
 	xkbi->mouseKeysDY= XkbPtrActionY(&pAction->ptr);
 	xkbi->mouseKeyTimer= TimerSet(xkbi->mouseKeyTimer, 0,
 				xkbi->desc->ctrls->mk_delay,
-				_XkbPtrAccelExpire,(pointer)xkbi);
+				_XkbPtrAccelExpire,(void *)xkbi);
     }
     else if (filter->keycode==keycode) {
 	filter->active = 0;
diff --git a/nx-X11/programs/Xserver/xkb/xkbEvents.c b/nx-X11/programs/Xserver/xkb/xkbEvents.c
index 914e3e782..ca201c6f0 100644
--- a/nx-X11/programs/Xserver/xkb/xkbEvents.c
+++ b/nx-X11/programs/Xserver/xkb/xkbEvents.c
@@ -383,7 +383,7 @@ XkbHandleBell(	BOOL		 force,
 		BOOL		 eventOnly,
 		DeviceIntPtr	 kbd,
 		CARD8		 percent,
-		pointer		 pCtrl,
+		void *		 pCtrl,
 		CARD8		 class,
 		Atom		 name,
 		WindowPtr	 pWin,
@@ -402,7 +402,7 @@ XID		winID = 0;
 
     if ((force||(xkbi->desc->ctrls->enabled_ctrls&XkbAudibleBellMask))&&
 							(!eventOnly)) {
-	(*kbd->kbdfeed->BellProc)(percent,kbd,(pointer)pCtrl,class);
+	(*kbd->kbdfeed->BellProc)(percent,kbd,(void *)pCtrl,class);
     }
     interest = kbd->xkb_interest;
     if ((!interest)||(force))
@@ -822,7 +822,7 @@ XkbSrvInfoPtr	xkbi;
 	    ErrorF("   Event state= 0x%04x\n",xE[0].u.keyButtonPointer.state);
 	    ErrorF("   XkbLastRepeatEvent!=xE (0x%x!=0x%x) %s\n",
 			XkbLastRepeatEvent,xE,
-			((XkbLastRepeatEvent!=(pointer)xE)?"True":"False"));
+			((XkbLastRepeatEvent!=(void *)xE)?"True":"False"));
 	    ErrorF("   (xkbClientEventsFlags&XWDA)==0 (0x%x) %s\n",
 		pClient->xkbClientFlags,
 		(_XkbWantsDetectableAutoRepeat(pClient)?"True":"False"));
@@ -830,7 +830,7 @@ XkbSrvInfoPtr	xkbi;
 			(!_XkbIsReleaseEvent(xE[0].u.u.type))?"True":"False");
 	}
 #endif /* DEBUG */
-	if (	(XkbLastRepeatEvent==(pointer)xE) &&
+	if (	(XkbLastRepeatEvent==(void *)xE) &&
 	     	(_XkbWantsDetectableAutoRepeat(pClient)) &&
 	     	(_XkbIsReleaseEvent(xE[0].u.u.type)) ) {
 	    return False;
diff --git a/nx-X11/programs/Xserver/xkb/xkbInit.c b/nx-X11/programs/Xserver/xkb/xkbInit.c
index a338de8ad..ef7e6a4f7 100644
--- a/nx-X11/programs/Xserver/xkb/xkbInit.c
+++ b/nx-X11/programs/Xserver/xkb/xkbInit.c
@@ -168,7 +168,7 @@ XkbGetRulesDflts(XkbRF_VarDefsPtr defs)
 }
 
 Bool
-XkbWriteRulesProp(ClientPtr client, pointer closure)
+XkbWriteRulesProp(ClientPtr client, void * closure)
 {
 int 			len,out;
 Atom			name;
@@ -296,7 +296,7 @@ XkbSetRulesDflts(char *rulesFile,char *model,char *layout,
 #include "xkbDflts.h"
 
 /* A dummy to keep the compiler quiet */
-pointer xkbBogus = &indicators;
+void * xkbBogus = &indicators;
 
 static Bool
 XkbInitKeyTypes(XkbDescPtr xkb,SrvXkmInfo *file)
@@ -619,7 +619,7 @@ XkbInitKeyboardDeviceStruct(
     void                        (*bellProc)(
         int /*percent*/,
         DeviceIntPtr /*device*/,
-        pointer /*ctrl*/,
+        void * /*ctrl*/,
         int),
     void                        (*ctrlProc)(
         DeviceIntPtr /*device*/,
diff --git a/nx-X11/programs/Xserver/xkb/xkbPrKeyEv.c b/nx-X11/programs/Xserver/xkb/xkbPrKeyEv.c
index ee521be69..713995d16 100644
--- a/nx-X11/programs/Xserver/xkb/xkbPrKeyEv.c
+++ b/nx-X11/programs/Xserver/xkb/xkbPrKeyEv.c
@@ -76,7 +76,7 @@ unsigned        ndx;
 	    case XkbKB_Default:
 		if (( xE->u.u.type == KeyPress ) && 
 		    (keyc->down[key>>3] & (1<<(key&7)))) {
-		    XkbLastRepeatEvent=	(pointer)xE;
+		    XkbLastRepeatEvent=	(void *)xE;
 		    xE->u.u.type = KeyRelease;
 		    XkbHandleActions(keybd,keybd,xE,count);
 		    xE->u.u.type = KeyPress;
@@ -86,7 +86,7 @@ unsigned        ndx;
 		}
 		else if ((xE->u.u.type==KeyRelease) &&
 			(!(keyc->down[key>>3]&(1<<(key&7))))) {
-		    XkbLastRepeatEvent=	(pointer)&xE;
+		    XkbLastRepeatEvent=	(void *)&xE;
 		    xE->u.u.type = KeyPress;
 		    XkbHandleActions(keybd,keybd,xE,count);
 		    xE->u.u.type = KeyRelease;
-- 
cgit v1.2.3


From acf87144d019f18e646501657d9082c6eba77f54 Mon Sep 17 00:00:00 2001
From: Mike Gabriel <mike.gabriel@das-netzwerkteam.de>
Date: Sun, 26 Jun 2016 01:38:22 +0200
Subject: nx-X11/programs/Xserver: Drop {X,x}free() macros, use free() instead.

Fixes ArcticaProject/nx-libs#105
---
 nx-X11/include/Xthreads.h                          |  7 +-
 nx-X11/lib/xtrans/Xtrans.c                         | 52 ++++++------
 nx-X11/lib/xtrans/Xtransdnet.c                     | 10 +--
 nx-X11/lib/xtrans/Xtranslcl.c                      | 20 ++---
 nx-X11/lib/xtrans/Xtransos2.c                      | 76 +++++++++---------
 nx-X11/lib/xtrans/Xtranssock.c                     | 30 +++----
 nx-X11/lib/xtrans/Xtranstli.c                      | 28 +++----
 nx-X11/lib/xtrans/Xtransutil.c                     |  4 +-
 nx-X11/lib/xtrans/transport.c                      |  1 -
 nx-X11/programs/Xserver/GL/glx/glximports.c        |  4 +-
 nx-X11/programs/Xserver/GL/glx/glxscreens.c        |  6 +-
 nx-X11/programs/Xserver/GL/glx/glxutil.c           |  4 +-
 nx-X11/programs/Xserver/GL/mesa/X/xf86glx.c        |  2 +-
 nx-X11/programs/Xserver/GL/mesa/X/xf86glx_util.c   |  2 +-
 nx-X11/programs/Xserver/Xext/extmod/modinit.c      |  2 +-
 nx-X11/programs/Xserver/Xext/panoramiX.c           | 16 ++--
 nx-X11/programs/Xserver/Xext/panoramiXprocs.c      | 16 ++--
 nx-X11/programs/Xserver/Xext/saver.c               | 14 ++--
 nx-X11/programs/Xserver/Xext/security.c            | 20 ++---
 nx-X11/programs/Xserver/Xext/shape.c               |  8 +-
 nx-X11/programs/Xserver/Xext/shm.c                 |  8 +-
 nx-X11/programs/Xserver/Xext/sleepuntil.c          |  4 +-
 nx-X11/programs/Xserver/Xext/sync.c                | 28 +++----
 nx-X11/programs/Xserver/Xext/xcmisc.c              |  2 +-
 nx-X11/programs/Xserver/Xext/xf86bigfont.c         |  6 +-
 nx-X11/programs/Xserver/Xext/xvdisp.c              |  2 +-
 nx-X11/programs/Xserver/Xext/xvmain.c              |  6 +-
 nx-X11/programs/Xserver/Xext/xvmc.c                | 20 ++---
 nx-X11/programs/Xserver/Xi/chgptr.c                |  4 +-
 nx-X11/programs/Xserver/Xi/exevents.c              | 12 +--
 nx-X11/programs/Xserver/Xi/getdctl.c               |  2 +-
 nx-X11/programs/Xserver/Xi/getfctl.c               |  2 +-
 nx-X11/programs/Xserver/Xi/getprop.c               |  2 +-
 nx-X11/programs/Xserver/Xi/getselev.c              |  2 +-
 nx-X11/programs/Xserver/Xi/listdev.c               |  2 +-
 nx-X11/programs/Xserver/Xi/queryst.c               |  2 +-
 nx-X11/programs/Xserver/composite/compalloc.c      | 20 ++---
 nx-X11/programs/Xserver/composite/compinit.c       |  4 +-
 nx-X11/programs/Xserver/damageext/damageext.c      |  4 +-
 nx-X11/programs/Xserver/dbe/dbe.c                  | 44 +++++------
 nx-X11/programs/Xserver/dix/atom.c                 | 12 +--
 nx-X11/programs/Xserver/dix/colormap.c             | 50 ++++++------
 nx-X11/programs/Xserver/dix/cursor.c               | 28 +++----
 nx-X11/programs/Xserver/dix/devices.c              | 56 ++++++-------
 nx-X11/programs/Xserver/dix/dispatch.c             | 12 +--
 nx-X11/programs/Xserver/dix/dixfonts.c             | 92 +++++++++++-----------
 nx-X11/programs/Xserver/dix/dixutils.c             | 22 +++---
 nx-X11/programs/Xserver/dix/events.c               |  8 +-
 nx-X11/programs/Xserver/dix/extension.c            | 22 +++---
 nx-X11/programs/Xserver/dix/gc.c                   | 14 ++--
 nx-X11/programs/Xserver/dix/glyphcurs.c            |  2 +-
 nx-X11/programs/Xserver/dix/grabs.c                | 10 +--
 nx-X11/programs/Xserver/dix/main.c                 | 18 ++---
 nx-X11/programs/Xserver/dix/privates.c             |  2 +-
 nx-X11/programs/Xserver/dix/property.c             | 16 ++--
 nx-X11/programs/Xserver/dix/region.c               | 12 +--
 nx-X11/programs/Xserver/dix/resource.c             | 16 ++--
 nx-X11/programs/Xserver/dix/window.c               | 18 ++---
 nx-X11/programs/Xserver/fb/fbcmap.c                |  6 +-
 nx-X11/programs/Xserver/fb/fbcopy.c                |  2 +-
 nx-X11/programs/Xserver/fb/fbpixmap.c              |  4 +-
 nx-X11/programs/Xserver/fb/fbpseudocolor.c         | 16 ++--
 nx-X11/programs/Xserver/fb/fbscreen.c              | 10 +--
 nx-X11/programs/Xserver/hw/nxagent/Args.c          |  6 +-
 nx-X11/programs/Xserver/hw/nxagent/Clipboard.c     |  6 +-
 nx-X11/programs/Xserver/hw/nxagent/Colormap.c      | 20 ++---
 nx-X11/programs/Xserver/hw/nxagent/Cursor.c        |  4 +-
 nx-X11/programs/Xserver/hw/nxagent/Display.c       | 14 ++--
 nx-X11/programs/Xserver/hw/nxagent/Drawable.c      | 10 +--
 nx-X11/programs/Xserver/hw/nxagent/Font.c          | 20 ++---
 nx-X11/programs/Xserver/hw/nxagent/GC.c            | 12 +--
 nx-X11/programs/Xserver/hw/nxagent/GCOps.c         |  6 +-
 nx-X11/programs/Xserver/hw/nxagent/Image.c         | 24 +++---
 nx-X11/programs/Xserver/hw/nxagent/Keyboard.c      | 14 ++--
 nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c    |  4 +-
 nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c    | 90 ++++++++++-----------
 nx-X11/programs/Xserver/hw/nxagent/NXglyph.c       |  4 +-
 nx-X11/programs/Xserver/hw/nxagent/NXglyphcurs.c   |  2 +-
 nx-X11/programs/Xserver/hw/nxagent/NXpicture.c     | 12 +--
 nx-X11/programs/Xserver/hw/nxagent/NXproperty.c    | 12 +--
 nx-X11/programs/Xserver/hw/nxagent/NXrender.c      | 38 ++++-----
 nx-X11/programs/Xserver/hw/nxagent/NXresource.c    |  4 +-
 nx-X11/programs/Xserver/hw/nxagent/NXshm.c         |  2 +-
 nx-X11/programs/Xserver/hw/nxagent/NXwindow.c      |  2 +-
 nx-X11/programs/Xserver/hw/nxagent/Pixmap.c        |  8 +-
 nx-X11/programs/Xserver/hw/nxagent/Reconnect.c     |  6 +-
 nx-X11/programs/Xserver/hw/nxagent/Render.c        |  4 +-
 nx-X11/programs/Xserver/hw/nxagent/Rootless.c      |  8 +-
 nx-X11/programs/Xserver/hw/nxagent/Screen.c        | 38 ++++-----
 nx-X11/programs/Xserver/include/os.h               |  2 +-
 nx-X11/programs/Xserver/mi/miarc.c                 | 26 +++---
 nx-X11/programs/Xserver/mi/mibank.c                | 10 +--
 nx-X11/programs/Xserver/mi/mibitblt.c              |  4 +-
 nx-X11/programs/Xserver/mi/mibstore.c              |  8 +-
 nx-X11/programs/Xserver/mi/micmap.c                | 12 +--
 nx-X11/programs/Xserver/mi/midash.c                |  2 +-
 nx-X11/programs/Xserver/mi/midispcur.c             | 18 ++---
 nx-X11/programs/Xserver/mi/migc.c                  |  4 +-
 nx-X11/programs/Xserver/mi/mioverlay.c             | 10 +--
 nx-X11/programs/Xserver/mi/mipointer.c             |  2 +-
 nx-X11/programs/Xserver/mi/mipolyutil.c            |  2 +-
 nx-X11/programs/Xserver/mi/mipushpxl.c             |  2 +-
 nx-X11/programs/Xserver/mi/miscrinit.c             |  2 +-
 nx-X11/programs/Xserver/mi/mispans.c               | 58 +++++++-------
 nx-X11/programs/Xserver/mi/misprite.c              |  4 +-
 nx-X11/programs/Xserver/mi/miwideline.c            |  6 +-
 nx-X11/programs/Xserver/mi/miwindow.c              |  2 +-
 nx-X11/programs/Xserver/miext/cw/cw.c              |  2 +-
 nx-X11/programs/Xserver/miext/cw/cw_render.c       |  4 +-
 nx-X11/programs/Xserver/miext/damage/damage.c      |  4 +-
 nx-X11/programs/Xserver/os/WaitFor.c               |  4 +-
 nx-X11/programs/Xserver/os/access.c                | 14 ++--
 nx-X11/programs/Xserver/os/connection.c            | 10 +--
 nx-X11/programs/Xserver/os/io.c                    | 32 ++++----
 nx-X11/programs/Xserver/os/log.c                   |  2 +-
 nx-X11/programs/Xserver/os/mitauth.c               | 10 +--
 nx-X11/programs/Xserver/os/oscolor.c               |  2 +-
 nx-X11/programs/Xserver/os/rpcauth.c               |  2 +-
 nx-X11/programs/Xserver/os/utils.c                 | 10 +--
 nx-X11/programs/Xserver/os/xdmauth.c               | 32 ++++----
 nx-X11/programs/Xserver/os/xdmcp.c                 |  8 +-
 nx-X11/programs/Xserver/randr/randr.c              | 12 +--
 nx-X11/programs/Xserver/randr/rrcrtc.c             | 38 ++++-----
 nx-X11/programs/Xserver/randr/rrdispatch.c         |  2 +-
 nx-X11/programs/Xserver/randr/rrinfo.c             |  4 +-
 nx-X11/programs/Xserver/randr/rrmode.c             |  8 +-
 nx-X11/programs/Xserver/randr/rrmonitor.c          | 10 +--
 nx-X11/programs/Xserver/randr/rroutput.c           | 18 ++---
 nx-X11/programs/Xserver/randr/rrproperty.c         | 22 +++---
 nx-X11/programs/Xserver/randr/rrprovider.c         |  6 +-
 nx-X11/programs/Xserver/randr/rrproviderproperty.c | 22 +++---
 nx-X11/programs/Xserver/randr/rrscreen.c           | 34 ++++----
 nx-X11/programs/Xserver/randr/rrtransform.c        |  4 +-
 nx-X11/programs/Xserver/record/record.c            | 20 ++---
 nx-X11/programs/Xserver/record/set.c               |  7 +-
 nx-X11/programs/Xserver/render/animcur.c           |  2 +-
 nx-X11/programs/Xserver/render/filter.c            | 12 +--
 nx-X11/programs/Xserver/render/glyph.c             | 16 ++--
 nx-X11/programs/Xserver/render/miindex.c           |  6 +-
 nx-X11/programs/Xserver/render/mipict.c            |  2 +-
 nx-X11/programs/Xserver/render/picture.c           | 42 +++++-----
 nx-X11/programs/Xserver/render/render.c            | 44 +++++------
 nx-X11/programs/Xserver/xfixes/cursor.c            | 10 +--
 nx-X11/programs/Xserver/xfixes/region.c            |  2 +-
 nx-X11/programs/Xserver/xfixes/select.c            |  4 +-
 nx-X11/programs/Xserver/xkb/ddxList.c              |  8 +-
 nx-X11/programs/Xserver/xkb/ddxLoad.c              | 12 +--
 nx-X11/programs/Xserver/xkb/xkb.c                  | 14 ++--
 148 files changed, 1001 insertions(+), 1006 deletions(-)

(limited to 'nx-X11/programs/Xserver/xfixes/select.c')

diff --git a/nx-X11/include/Xthreads.h b/nx-X11/include/Xthreads.h
index 41440a2fb..97fda5948 100644
--- a/nx-X11/include/Xthreads.h
+++ b/nx-X11/include/Xthreads.h
@@ -36,9 +36,6 @@ in this Software without prior written authorization from The Open Group.
 #ifndef xmalloc
 #define xmalloc malloc
 #endif
-#ifndef xfree
-#define xfree free
-#endif
 
 #ifdef CTHREADS
 #include <cthreads.h>
@@ -285,13 +282,13 @@ typedef xmutex_rec *xmutex_t;
 #define xcondition_malloc() (xcondition_t)xmalloc(sizeof(xcondition_rec))
 #endif
 #ifndef xcondition_free
-#define xcondition_free(c) xfree((char *)c)
+#define xcondition_free(c) free((char *)c)
 #endif
 #ifndef xmutex_malloc
 #define xmutex_malloc() (xmutex_t)xmalloc(sizeof(xmutex_rec))
 #endif
 #ifndef xmutex_free
-#define xmutex_free(m) xfree((char *)m)
+#define xmutex_free(m) free((char *)m)
 #endif
 #ifndef xthread_have_id
 #define xthread_have_id(id) id
diff --git a/nx-X11/lib/xtrans/Xtrans.c b/nx-X11/lib/xtrans/Xtrans.c
index ef4d64aed..f1e5ff966 100644
--- a/nx-X11/lib/xtrans/Xtrans.c
+++ b/nx-X11/lib/xtrans/Xtrans.c
@@ -145,15 +145,15 @@ TRANS(FreeConnInfo) (XtransConnInfo ciptr)
     PRMSG (3,"FreeConnInfo(%p)\n", ciptr, 0, 0);
 
     if (ciptr->addr)
-	xfree (ciptr->addr);
+	free (ciptr->addr);
 
     if (ciptr->peeraddr)
-	xfree (ciptr->peeraddr);
+	free (ciptr->peeraddr);
 
     if (ciptr->port)
-	xfree (ciptr->port);
+	free (ciptr->port);
 
-    xfree ((char *) ciptr);
+    free ((char *) ciptr);
 }
 
 
@@ -238,7 +238,7 @@ TRANS(ParseAddress) (char *address, char **protocol, char **host, char **port)
 	*protocol = NULL;
 	*host = NULL;
 	*port = NULL;
-	xfree (tmpptr);
+	free (tmpptr);
 	return 0;
     }
 
@@ -288,7 +288,7 @@ TRANS(ParseAddress) (char *address, char **protocol, char **host, char **port)
 	*protocol = NULL;
 	*host = NULL;
 	*port = NULL;
-	xfree (tmpptr);
+	free (tmpptr);
 	return 0;
     }
 
@@ -368,7 +368,7 @@ TRANS(ParseAddress) (char *address, char **protocol, char **host, char **port)
 	*port = NULL;
 	*host = NULL;
 	*protocol = NULL;
-	xfree (tmpptr);
+	free (tmpptr);
 	return 0;
     }
     else
@@ -379,9 +379,9 @@ TRANS(ParseAddress) (char *address, char **protocol, char **host, char **port)
 	/* Malloc failed */
 	*port = NULL;
 	*host = NULL;
-	xfree (*protocol);
+	free (*protocol);
 	*protocol = NULL;
-	xfree (tmpptr);
+	free (tmpptr);
 	return 0;
 	}
     else
@@ -391,17 +391,17 @@ TRANS(ParseAddress) (char *address, char **protocol, char **host, char **port)
     {
 	/* Malloc failed */
 	*port = NULL;
-	xfree (*host);
+	free (*host);
 	*host = NULL;
-	xfree (*protocol);
+	free (*protocol);
 	*protocol = NULL;
-	xfree (tmpptr);
+	free (tmpptr);
 	return 0;
     }
     else
         strcpy (*port, _port);
 
-    xfree (tmpptr);
+    free (tmpptr);
 
     return 1;
 }
@@ -446,9 +446,9 @@ TRANS(Open) (int type, char *address)
 	PRMSG (1,"Open: Unable to find transport for %s\n",
 	       protocol, 0, 0);
 
-	xfree (protocol);
-	xfree (host);
-	xfree (port);
+	free (protocol);
+	free (host);
+	free (port);
 	return NULL;
     }
 
@@ -487,17 +487,17 @@ TRANS(Open) (int type, char *address)
 	    PRMSG (1,"Open: transport open failed for %s/%s:%s\n",
 	           protocol, host, port);
 	}
-	xfree (protocol);
-	xfree (host);
-	xfree (port);
+	free (protocol);
+	free (host);
+	free (port);
 	return NULL;
     }
 
     ciptr->transptr = thistrans;
     ciptr->port = port;			/* We need this for TRANS(Reopen) */
 
-    xfree (protocol);
-    xfree (host);
+    free (protocol);
+    free (host);
 
     return ciptr;
 }
@@ -859,16 +859,16 @@ TRANS(Connect) (XtransConnInfo ciptr, char *address)
     {
 	PRMSG (1,"Connect: Missing port specification in %s\n",
 	      address, 0, 0);
-	if (protocol) xfree (protocol);
-	if (host) xfree (host);
+	if (protocol) free (protocol);
+	if (host) free (host);
 	return -1;
     }
 
     ret = ciptr->transptr->Connect (ciptr, host, port);
 
-    if (protocol) xfree (protocol);
-    if (host) xfree (host);
-    if (port) xfree (port);
+    if (protocol) free (protocol);
+    if (host) free (host);
+    if (port) free (port);
     
     return ret;
 }
diff --git a/nx-X11/lib/xtrans/Xtransdnet.c b/nx-X11/lib/xtrans/Xtransdnet.c
index a1728f187..34e191260 100644
--- a/nx-X11/lib/xtrans/Xtransdnet.c
+++ b/nx-X11/lib/xtrans/Xtransdnet.c
@@ -224,7 +224,7 @@ TRANS(DNETOpenCOTSServer) (Xtransport *thistrans, char *protocol,
 
     if ((ciptr->fd = socket (AF_DECnet, SOCK_STREAM, 0)) < 0)
     {
-	xfree ((char *) ciptr);
+	free ((char *) ciptr);
 	return NULL;
     }
 
@@ -406,7 +406,7 @@ TRANS(DNETAccept) (XtransConnInfo ciptr, int *status)
     {
 	PRMSG (1, "DNETAccept: accept() failed\n", 0, 0, 0);
 
-	xfree (newciptr);
+	free (newciptr);
 	*status = TRANS_ACCEPT_FAILED;
 	return NULL;
     }
@@ -421,7 +421,7 @@ TRANS(DNETAccept) (XtransConnInfo ciptr, int *status)
 	PRMSG(1,
 	"DNETAccept: ...DNETGetAddr() failed:\n", 0, 0, 0);
 	close (newciptr->fd);
-	xfree (newciptr);
+	free (newciptr);
 	*status = TRANS_ACCEPT_MISC_ERROR;
         return NULL;
     }
@@ -432,8 +432,8 @@ TRANS(DNETAccept) (XtransConnInfo ciptr, int *status)
 	"DNETAccept: ...DNETGetPeerAddr() failed:\n", 0, 0, 0);
 
 	close (newciptr->fd);
-	if (newciptr->addr) xfree (newciptr->addr);
-	xfree (newciptr);
+	if (newciptr->addr) free (newciptr->addr);
+	free (newciptr);
 	*status = TRANS_ACCEPT_MISC_ERROR;
         return NULL;
     }
diff --git a/nx-X11/lib/xtrans/Xtranslcl.c b/nx-X11/lib/xtrans/Xtranslcl.c
index 6165d3658..c1689c654 100644
--- a/nx-X11/lib/xtrans/Xtranslcl.c
+++ b/nx-X11/lib/xtrans/Xtranslcl.c
@@ -171,7 +171,7 @@ TRANS(FillAddrInfo)(XtransConnInfo ciptr, char *sun_path, char *peer_sun_path)
 	PRMSG(1,
 	   "FillAddrInfo: failed to allocate memory for peer addr\n",
 									0,0,0);
-	xfree ((char *) sunaddr);
+	free ((char *) sunaddr);
 	ciptr->addr = NULL;
 
 	return 0;
@@ -610,7 +610,7 @@ TRANS(PTSAccept)(XtransConnInfo ciptr, XtransConnInfo newciptr, int *status)
     if( (sunaddr=(struct sockaddr_un *)xalloc(newciptr->peeraddrlen)) == NULL ) {
 	PRMSG(1,"PTSAccept: failed to allocate memory for peer addr\n",
 									0,0,0);
-	xfree(newciptr->addr);
+	free(newciptr->addr);
 	close(newfd);
 	*status = TRANS_ACCEPT_BAD_MALLOC;
 	return -1;
@@ -834,7 +834,7 @@ TRANS(NAMEDAccept)(XtransConnInfo ciptr, XtransConnInfo newciptr, int *status)
 	PRMSG(1,
 	"NAMEDAccept: failed to allocate memory for peer addr\n",
 									0,0,0);
-	xfree(newciptr->addr);
+	free(newciptr->addr);
 	close(str.fd);
 	*status = TRANS_ACCEPT_BAD_MALLOC;
 	return -1;
@@ -1178,7 +1178,7 @@ TRANS(ISCAccept)(XtransConnInfo ciptr, XtransConnInfo newciptr, int *status)
 	PRMSG(1,
 	      "ISCAccept: failed to allocate memory for peer addr\n",
 	      0,0,0);
-	xfree(newciptr->addr);
+	free(newciptr->addr);
 	close(str.fd);
 	*status = TRANS_ACCEPT_BAD_MALLOC;
 	return -1;
@@ -1455,7 +1455,7 @@ TRANS(SCOAccept)(XtransConnInfo ciptr, XtransConnInfo newciptr, int *status)
 	PRMSG(1,
 	      "SCOAccept: failed to allocate memory for peer addr\n",
 	      0,0,0);
-	xfree(newciptr->addr);
+	free(newciptr->addr);
 	close(fd);
 	*status = TRANS_ACCEPT_BAD_MALLOC;
 	return -1;
@@ -1913,7 +1913,7 @@ TRANS(LocalEndTransports)(void)
 
 {
     PRMSG(3,"LocalEndTransports()\n", 0,0,0 );
-    xfree(freeXLOCAL);
+    free(freeXLOCAL);
 }
 
 #define TYPEBUFSIZE	32
@@ -2080,7 +2080,7 @@ TRANS(LocalOpenClient)(int type, char *protocol, char *host, char *port)
 
     if( ciptr->fd < 0 )
     {
-	xfree(ciptr);
+	free(ciptr);
 	return NULL;
     }
 
@@ -2150,7 +2150,7 @@ TRANS(LocalOpenServer)(int type, char *protocol, char *host, char *port)
 	}
     }
 
-    xfree(ciptr);
+    free(ciptr);
     return NULL;
 }
 
@@ -2197,7 +2197,7 @@ TRANS(LocalReopenServer)(int type, int index, int fd, char *port)
 	return ciptr;
     }
 
-    xfree(ciptr);
+    free(ciptr);
     return NULL;
 }
 
@@ -2396,7 +2396,7 @@ TRANS(LocalAccept)(XtransConnInfo ciptr, int *status)
 
     if( newciptr->fd < 0 )
     {
-	xfree(newciptr);
+	free(newciptr);
 	return NULL;
     }
 
diff --git a/nx-X11/lib/xtrans/Xtransos2.c b/nx-X11/lib/xtrans/Xtransos2.c
index f4a6b036b..807a6029d 100644
--- a/nx-X11/lib/xtrans/Xtransos2.c
+++ b/nx-X11/lib/xtrans/Xtransos2.c
@@ -111,7 +111,7 @@ TRANS(Os2OpenClient)(Xtransport *thistrans, char *protocol,
 			0,0,0 );
 		PRMSG(1,"\tor the DISPLAY variable is set incorrectly.\n",
 			0,0,0 );
-		xfree(ciptr);
+		free(ciptr);
 		return NULL;
 	    }
        try ++;
@@ -133,7 +133,7 @@ TRANS(Os2OpenClient)(Xtransport *thistrans, char *protocol,
         pipe_len=0;
         DosWrite(hServer,&pipe_len,1,&byteWritten);
         DosClose(hServer);
-        xfree(ciptr);
+        free(ciptr);
 	return(NULL);
     }
 
@@ -145,7 +145,7 @@ TRANS(Os2OpenClient)(Xtransport *thistrans, char *protocol,
         PRMSG(1, "Os2OpenClient: Unable to connect to pipe %s\n", pipename,0,0 );
         DosClose (hfd);
         DosClose(hServer);
-        xfree(ciptr);
+        free(ciptr);
         return (NULL);
     }
 
@@ -158,7 +158,7 @@ TRANS(Os2OpenClient)(Xtransport *thistrans, char *protocol,
                 hServer,rc,byteWritten );
            DosClose(hServer);
            DosClose(hfd);
-           xfree(ciptr);
+           free(ciptr);
            return(NULL);
            }
 
@@ -182,7 +182,7 @@ TRANS(Os2OpenClient)(Xtransport *thistrans, char *protocol,
            PRMSG(1, "\tor the XServer is too busy to respond.\n",0,0,0 );
            DosClose(hServer);
            DosClose(hfd);
-           xfree(ciptr);
+           free(ciptr);
            return(NULL);
            }
 
@@ -197,7 +197,7 @@ TRANS(Os2OpenClient)(Xtransport *thistrans, char *protocol,
            PRMSG(1, "Os2OpenClient: Client pipe does not appear connected. rc=%d, h=%d\n",rc,hfd,0 );
            PRMSG(1, "\tProbable cause: the XServer has just exited.\n",0,0,0 );
            DosClose(hfd);
-           xfree(ciptr);
+           free(ciptr);
            return(NULL);
            }
 
@@ -207,7 +207,7 @@ TRANS(Os2OpenClient)(Xtransport *thistrans, char *protocol,
                 PRMSG (1, "Os2OpenClient: Can't allocate space for the addr\n",
 	        0, 0, 0);
                 DosClose(hfd);
-                xfree(ciptr);
+                free(ciptr);
                 return(NULL);
            }
         ciptr->addrlen = namelen;
@@ -219,8 +219,8 @@ TRANS(Os2OpenClient)(Xtransport *thistrans, char *protocol,
                 PRMSG (1, "Os2OpenCLient: Can't allocate space for the addr\n",
 	        0, 0, 0);
                 DosClose(hfd);
-                xfree(ciptr->addr);
-                xfree(ciptr);
+                free(ciptr->addr);
+                free(ciptr);
                 return(NULL);
            }
        ciptr->peeraddrlen = namelen;
@@ -237,9 +237,9 @@ TRANS(Os2OpenClient)(Xtransport *thistrans, char *protocol,
            PRMSG(1, "Os2OpenClient: Could not import the pipe handle into EMX\n",0,0,0 );
            PRMSG(1, "\tProbable cause: EMX has run out of free file handles.\n",0,0,0 );
            DosClose(hfd);
-           xfree(ciptr->addr);
-           xfree(ciptr->peeraddr);
-           xfree(ciptr);
+           free(ciptr->addr);
+           free(ciptr->peeraddr);
+           free(ciptr);
            return(NULL);
            }
     PRMSG(5, "Os2OpenClient: pipe handle %d EMX handle %d\n",ciptr->index,ciptr->fd,0 );
@@ -296,7 +296,7 @@ TRANS(Os2OpenServer)(Xtransport *thistrans, char *protocol,
         PRMSG(1, "Os2OpenServer: Unable to create pipe %s, rc=%d\n", pipename,rc,0 );
         PRMSG(1, "\tProbable cause: there is already another XServer running on display :%s\n",port,0,0 );
 	DosClose(hfd);
-        xfree(ciptr);
+        free(ciptr);
 	return(NULL);
     }
 
@@ -307,7 +307,7 @@ TRANS(Os2OpenServer)(Xtransport *thistrans, char *protocol,
     {
         PRMSG(1, "Os2OpenServer: Unable to connect to pipe %s\n", pipename,0,0 );
         DosClose (hfd);
-        xfree(ciptr);
+        free(ciptr);
         return (NULL);
     }
 
@@ -321,7 +321,7 @@ TRANS(Os2OpenServer)(Xtransport *thistrans, char *protocol,
                 PRMSG (1, "Os2OpenServer: Can't allocate space for the addr\n",
 	        0, 0, 0);
                 DosClose(hfd);
-                xfree(ciptr);
+                free(ciptr);
                 return(NULL);
            }
         ciptr->addrlen = namelen;
@@ -333,8 +333,8 @@ TRANS(Os2OpenServer)(Xtransport *thistrans, char *protocol,
                 PRMSG (1, "Os2OpenServer: Can't allocate space for the addr\n",
 	        0, 0, 0);
                 DosClose(hfd);
-                xfree(ciptr->addr);
-                xfree(ciptr);
+                free(ciptr->addr);
+                free(ciptr);
                 return(NULL);
            }
 
@@ -351,9 +351,9 @@ TRANS(Os2OpenServer)(Xtransport *thistrans, char *protocol,
 
     if((ciptr->fd=_imphandle(hfd))<0){
        DosClose(hfd);
-       xfree(ciptr->addr);
-       xfree(ciptr->peeraddr);
-       xfree(ciptr);
+       free(ciptr->addr);
+       free(ciptr->peeraddr);
+       free(ciptr);
        return(NULL);
        }
     PRMSG(5, "Os2OpenServer: Pipe handle %d EMX handle %d",ciptr->index,ciptr->fd,0 );
@@ -365,9 +365,9 @@ TRANS(Os2OpenServer)(Xtransport *thistrans, char *protocol,
         PRMSG(1, "Os2OpenCOTSServer: Could not attach sem %d to pipe %d, rc=%d\n",
                  hPipeSem,ciptr->fd,rc);
         DosClose(ciptr->fd);
-        xfree(ciptr->addr);
-        xfree(ciptr->peeraddr);
-        xfree(ciptr);
+        free(ciptr->addr);
+        free(ciptr->peeraddr);
+        free(ciptr);
          return(NULL);
         }
 #endif
@@ -445,7 +445,7 @@ TRANS(Os2ReopenCOTSServer)(Xtransport *thistrans, int fd, char *port)
           {
                 PRMSG (1, "Os2ReopenCOTSServer: Can't allocate space for the addr\n",
 	        0, 0, 0);
-                xfree(ciptr);
+                free(ciptr);
                 return(NULL);
            }
 
@@ -455,7 +455,7 @@ TRANS(Os2ReopenCOTSServer)(Xtransport *thistrans, int fd, char *port)
           {
                 PRMSG (1, "Os2ReopenCOTSServer: Can't allocate space for the addr\n",
 	        0, 0, 0);
-                xfree(ciptr);
+                free(ciptr);
                 return(NULL);
            }
 
@@ -521,7 +521,7 @@ TRANS(Os2Accept)(XtransConnInfo ciptr, int *status)
         PRMSG(2,"Os2Accept: Error reading incoming connection, in=%d, error=%d\n",
 	      in,errno,0 );
 	*status = TRANS_ACCEPT_MISC_ERROR;
-        xfree(newciptr);
+        free(newciptr);
         rc = DosDisConnectNPipe(ciptr->fd);
         rc = DosConnectNPipe (ciptr->fd);
         if (rc != 0 && rc != ERROR_PIPE_NOT_CONNECTED)
@@ -540,7 +540,7 @@ TRANS(Os2Accept)(XtransConnInfo ciptr, int *status)
         PRMSG(2,"Os2Accept: Error reading incoming connection, in=%d, error=%d\n",
 	      in,errno,0 );
 	*status = TRANS_ACCEPT_MISC_ERROR;
-        xfree(newciptr);
+        free(newciptr);
         rc = DosDisConnectNPipe(ciptr->fd);
         rc = DosConnectNPipe (ciptr->fd);
         if (rc != 0 && rc != ERROR_PIPE_NOT_CONNECTED)
@@ -566,7 +566,7 @@ TRANS(Os2Accept)(XtransConnInfo ciptr, int *status)
 	    PRMSG(1,"Os2Accept: Open pipe %s to client failed, rc=%d\n",
 	    clientname,rc,0 );
             PRMSG(1, "\tProbable cause: the client has exited or timed-out.\n",0,0,0 );
-            xfree(newciptr);
+            free(newciptr);
             rc = DosDisConnectNPipe(ciptr->fd);
             rc = DosConnectNPipe (ciptr->fd);
             if (rc != 0 && rc != ERROR_PIPE_NOT_CONNECTED)
@@ -581,7 +581,7 @@ TRANS(Os2Accept)(XtransConnInfo ciptr, int *status)
         {
             PRMSG(1,"Os2Accept: Could not set pipe %s to non-blocking mode, rc=%d\n",
 	    hClient,rc,0 );
-            xfree(newciptr);
+            free(newciptr);
             rc = DosDisConnectNPipe(ciptr->fd);
             rc = DosConnectNPipe (ciptr->fd);
             if (rc != 0 && rc != ERROR_PIPE_NOT_CONNECTED)
@@ -610,7 +610,7 @@ TRANS(Os2Accept)(XtransConnInfo ciptr, int *status)
                 PRMSG (1, "Os2Accept: Can't allocate space for the addr\n",
 	        0, 0, 0);
                 DosClose(hClient);
-                xfree(newciptr);
+                free(newciptr);
                 return(NULL);
            }
 
@@ -623,8 +623,8 @@ TRANS(Os2Accept)(XtransConnInfo ciptr, int *status)
                 PRMSG (1, "Os2Accept: Can't allocate space for the addr\n",
 	        0, 0, 0);
                 DosClose(hClient);
-                xfree(ciptr->addr);
-                xfree(newciptr);
+                free(ciptr->addr);
+                free(newciptr);
                 return(NULL);
            }
 
@@ -643,9 +643,9 @@ TRANS(Os2Accept)(XtransConnInfo ciptr, int *status)
            hClient,errno,0 );
            PRMSG(1, "\tProbable cause: EMX has run out of file handles.\n",0,0,0 );
            DosClose(hClient);
-           xfree(newciptr->addr);
-           xfree(newciptr->peeraddr);
-           xfree(newciptr);
+           free(newciptr->addr);
+           free(newciptr->peeraddr);
+           free(newciptr);
            return(NULL);
            }
     PRMSG(5, "Os2Accept: Pipe handle %d EMX handle %d",newciptr->index,newciptr->fd,0 );
@@ -657,9 +657,9 @@ TRANS(Os2Accept)(XtransConnInfo ciptr, int *status)
         PRMSG(1, "Os2OpenCOTSServer: Could not attach sem %d to pipe %d, rc=%d\n",
                  hPipeSem,newciptr->fd,rc);
         DosClose(newciptr->fd);
-        xfree(newciptr->addr);
-        xfree(newciptr->peeraddr);
-        xfree(newciptr);
+        free(newciptr->addr);
+        free(newciptr->peeraddr);
+        free(newciptr);
          return(NULL);
         }
 #endif
diff --git a/nx-X11/lib/xtrans/Xtranssock.c b/nx-X11/lib/xtrans/Xtranssock.c
index 5c57fc5ba..6a6600435 100644
--- a/nx-X11/lib/xtrans/Xtranssock.c
+++ b/nx-X11/lib/xtrans/Xtranssock.c
@@ -619,7 +619,7 @@ static XtransConnInfo TRANS(SocketCreateConnInfo) ()
     if (socketpair(PF_LOCAL, SOCK_STREAM, 0, fds) < 0)
     {
         PRMSG (1, "SocketCreateConnInfo: socketpair() failed.\n", 0, 0, 0);
-        xfree ((char *) ciptr);
+        free ((char *) ciptr);
         return NULL;
     }
 
@@ -643,7 +643,7 @@ static XtransConnInfo TRANS(SocketCreateConnInfo) ()
     {
         PRMSG (1, "SocketCreateConnInfo: No space for a new _NXProxyConnInfo for [%d].\n",
                   ciptr->fd, 0, 0);
-        xfree ((char *) ciptr);
+        free ((char *) ciptr);
         return NULL;
     }
     else if (_NXProxyConnInfoTab[ciptr->fd] != NULL)
@@ -658,7 +658,7 @@ static XtransConnInfo TRANS(SocketCreateConnInfo) ()
     if (_NXProxyConnInfoTab[ciptr->fd] == NULL)
     {
         PRMSG (1, "SocketCreateConnInfo: Alloc of _NXProxyConnInfo failed.\n", 0, 0, 0);
-        xfree ((char *) ciptr);
+        free ((char *) ciptr);
         return NULL;
     }
 
@@ -812,7 +812,7 @@ static void TRANS(SocketCloseConnInfo) (XtransConnInfo ciptr)
                 ciptr->fd);
 #endif
 
-    xfree((char *) _NXProxyConnInfoTab[ciptr->fd]);
+    free((char *) _NXProxyConnInfoTab[ciptr->fd]);
 
     _NXProxyConnInfoTab[ciptr->fd] = NULL;
 
@@ -1084,7 +1084,7 @@ TRANS(SocketOpen) (int i, int type)
 	PRMSG (2, "SocketOpen: socket() failed for %s\n",
 	    Sockettrans2devtab[i].transname, 0, 0);
 
-	xfree ((char *) ciptr);
+	free ((char *) ciptr);
 	return NULL;
     }
 
@@ -1968,7 +1968,7 @@ TRANS(SocketINETAccept) (XtransConnInfo ciptr, int *status)
 	errno = WSAGetLastError();
 #endif
 	PRMSG (1, "SocketINETAccept: accept() failed\n", 0, 0, 0);
-	xfree (newciptr);
+	free (newciptr);
 	*status = TRANS_ACCEPT_FAILED;
 	return NULL;
     }
@@ -1996,7 +1996,7 @@ TRANS(SocketINETAccept) (XtransConnInfo ciptr, int *status)
 	    "SocketINETAccept: ...SocketINETGetAddr() failed:\n",
 	    0, 0, 0);
 	close (newciptr->fd);
-	xfree (newciptr);
+	free (newciptr);
 	*status = TRANS_ACCEPT_MISC_ERROR;
         return NULL;
     }
@@ -2007,8 +2007,8 @@ TRANS(SocketINETAccept) (XtransConnInfo ciptr, int *status)
 	  "SocketINETAccept: ...SocketINETGetPeerAddr() failed:\n",
 		0, 0, 0);
 	close (newciptr->fd);
-	if (newciptr->addr) xfree (newciptr->addr);
-	xfree (newciptr);
+	if (newciptr->addr) free (newciptr->addr);
+	free (newciptr);
 	*status = TRANS_ACCEPT_MISC_ERROR;
         return NULL;
     }
@@ -2048,7 +2048,7 @@ TRANS(SocketUNIXAccept) (XtransConnInfo ciptr, int *status)
 	(struct sockaddr *) &sockname, (void *)&namelen)) < 0)
     {
 	PRMSG (1, "SocketUNIXAccept: accept() failed\n", 0, 0, 0);
-	xfree (newciptr);
+	free (newciptr);
 	*status = TRANS_ACCEPT_FAILED;
 	return NULL;
     }
@@ -2064,7 +2064,7 @@ TRANS(SocketUNIXAccept) (XtransConnInfo ciptr, int *status)
         "SocketUNIXAccept: Can't allocate space for the addr\n",
 	      0, 0, 0);
 	close (newciptr->fd);
-	xfree (newciptr);
+	free (newciptr);
 	*status = TRANS_ACCEPT_BAD_MALLOC;
         return NULL;
     }
@@ -2084,8 +2084,8 @@ TRANS(SocketUNIXAccept) (XtransConnInfo ciptr, int *status)
 	      "SocketUNIXAccept: Can't allocate space for the addr\n",
 	      0, 0, 0);
 	close (newciptr->fd);
-	if (newciptr->addr) xfree (newciptr->addr);
-	xfree (newciptr);
+	if (newciptr->addr) free (newciptr->addr);
+	free (newciptr);
 	*status = TRANS_ACCEPT_BAD_MALLOC;
         return NULL;
     }
@@ -2263,7 +2263,7 @@ TRANS(SocketINETConnect) (XtransConnInfo ciptr, char *host, char *port)
 					" socketfor IPv4 address\n", 0,0,0);
 			}
 			if (newciptr)
-			    xfree(newciptr);
+			    free(newciptr);
 		    } else {
 			socketaddr = NULL;
 			PRMSG (4,"SocketINETConnect Skipping IPv4 address\n",
@@ -2301,7 +2301,7 @@ TRANS(SocketINETConnect) (XtransConnInfo ciptr, char *host, char *port)
 				   "socket for IPv6 address\n", 0,0,0);
 			}
 			if (newciptr)
-			    xfree(newciptr);
+			    free(newciptr);
 		    }
 		    else
 		    {
diff --git a/nx-X11/lib/xtrans/Xtranstli.c b/nx-X11/lib/xtrans/Xtranstli.c
index d8b5db83b..ab37275dd 100644
--- a/nx-X11/lib/xtrans/Xtranstli.c
+++ b/nx-X11/lib/xtrans/Xtranstli.c
@@ -171,7 +171,7 @@ TRANS(TLIGetAddr)(XtransConnInfo ciptr)
      */
     
     if( ciptr->addr )
-	xfree(ciptr->addr);
+	free(ciptr->addr);
     
     if( (ciptr->addr=(char *)xalloc(netbuf.len)) == NULL )
     {
@@ -221,7 +221,7 @@ TRANS(TLIGetPeerAddr)(XtransConnInfo ciptr)
      */
     
     if( ciptr->peeraddr )
-	xfree(ciptr->peeraddr);
+	free(ciptr->peeraddr);
     
     if( (ciptr->peeraddr=(char *)xalloc(netbuf.len)) == NULL )
     {
@@ -457,7 +457,7 @@ TRANS(TLIOpenCOTSClient)(Xtransport *thistrans, char *protocol,
 	      "TLIOpenCOTSClient: ...TLITLIBindLocal() failed: %d\n",
 	      errno, 0,0 );
 	t_close(ciptr->fd);
-	xfree(ciptr);
+	free(ciptr);
 	return NULL;
     }
     
@@ -467,7 +467,7 @@ TRANS(TLIOpenCOTSClient)(Xtransport *thistrans, char *protocol,
 	      "TLIOpenCOTSClient: ...TLIGetAddr() failed: %d\n",
 	      errno, 0,0 );
 	t_close(ciptr->fd);
-	xfree(ciptr);
+	free(ciptr);
 	return NULL;
     }
     
@@ -557,7 +557,7 @@ TRANS(TLIOpenCLTSClient)(Xtransport *thistrans, char *protocol,
 	      "TLIOpenCLTSClient: ...TLITLIBindLocal() failed: %d\n",
 	      errno, 0,0 );
 	t_close(ciptr->fd);
-	xfree(ciptr);
+	free(ciptr);
 	return NULL;
     }
     
@@ -567,7 +567,7 @@ TRANS(TLIOpenCLTSClient)(Xtransport *thistrans, char *protocol,
 	      "TLIOpenCLTSClient: ...TLIGetPeerAddr() failed: %d\n",
 	      errno, 0,0 );
 	t_close(ciptr->fd);
-	xfree(ciptr);
+	free(ciptr);
 	return NULL;
     }
     
@@ -917,7 +917,7 @@ TRANS(TLIAccept)(XtransConnInfo ciptr, int *status)
 	      errno, 0,0 );
 	t_free((char *)call,T_CALL);
 	t_close(newciptr->fd);
-	xfree(newciptr);
+	free(newciptr);
 	*status = TRANS_ACCEPT_MISC_ERROR;
 	return NULL;
     }
@@ -961,7 +961,7 @@ TRANS(TLIAccept)(XtransConnInfo ciptr, int *status)
 	      "TLIAccept: TRANS(TLIGetPeerAddr)() failed: %d\n",
 	      errno, 0,0 );
 	t_close(newciptr->fd);
-	xfree(newciptr);
+	free(newciptr);
 	*status = TRANS_ACCEPT_MISC_ERROR;
 	return NULL;
     }
@@ -972,8 +972,8 @@ TRANS(TLIAccept)(XtransConnInfo ciptr, int *status)
 	      "TLIAccept: TRANS(TLIGetPeerAddr)() failed: %d\n",
 	      errno, 0,0 );
 	t_close(newciptr->fd);
-	xfree(newciptr->addr);
-	xfree(newciptr);
+	free(newciptr->addr);
+	free(newciptr);
 	*status = TRANS_ACCEPT_MISC_ERROR;
 	return NULL;
     }
@@ -983,8 +983,8 @@ TRANS(TLIAccept)(XtransConnInfo ciptr, int *status)
 	PRMSG(1, "TLIAccept() ioctl(I_POP, \"timod\") failed %d\n",
 	      errno,0,0 );
 	t_close(newciptr->fd);
-	xfree(newciptr->addr);
-	xfree(newciptr);
+	free(newciptr->addr);
+	free(newciptr);
 	*status = TRANS_ACCEPT_MISC_ERROR;
 	return NULL;
     }
@@ -994,8 +994,8 @@ TRANS(TLIAccept)(XtransConnInfo ciptr, int *status)
 	PRMSG(1, "TLIAccept() ioctl(I_PUSH,\"tirdwr\") failed %d\n",
 	      errno,0,0 );
 	t_close(newciptr->fd);
-	xfree(newciptr->addr);
-	xfree(newciptr);
+	free(newciptr->addr);
+	free(newciptr);
 	*status = TRANS_ACCEPT_MISC_ERROR;
 	return NULL;
     }
diff --git a/nx-X11/lib/xtrans/Xtransutil.c b/nx-X11/lib/xtrans/Xtransutil.c
index 20e431ac8..7dc91b16c 100644
--- a/nx-X11/lib/xtrans/Xtransutil.c
+++ b/nx-X11/lib/xtrans/Xtransutil.c
@@ -211,7 +211,7 @@ TRANS(ConvertAddress)(int *familyp, int *addrlenp, Xtransaddr **addrp)
 	if (len > 0) {
 	    if (*addrp && *addrlenp < (len + 1))
 	    {
-		xfree ((char *) *addrp);
+		free ((char *) *addrp);
 		*addrp = NULL;
 	    }
 	    if (!*addrp)
@@ -226,7 +226,7 @@ TRANS(ConvertAddress)(int *familyp, int *addrlenp, Xtransaddr **addrp)
 	else
 	{
 	    if (*addrp)
-		xfree ((char *) *addrp);
+		free ((char *) *addrp);
 	    *addrp = NULL;
 	    *addrlenp = 0;
 	}
diff --git a/nx-X11/lib/xtrans/transport.c b/nx-X11/lib/xtrans/transport.c
index ff460c257..49441d76e 100644
--- a/nx-X11/lib/xtrans/transport.c
+++ b/nx-X11/lib/xtrans/transport.c
@@ -62,7 +62,6 @@ from The Open Group.
 #define xalloc(_size)		malloc(_size)
 #define xcalloc(_num,_size)	calloc(_num,_size)
 #define xrealloc(_ptr,_size)	realloc(_ptr,_size)
-#define xfree(_ptr)		free(_ptr)
 #endif
 
 #include "Xtransint.h"
diff --git a/nx-X11/programs/Xserver/GL/glx/glximports.c b/nx-X11/programs/Xserver/GL/glx/glximports.c
index 435caca58..5b6c545fc 100644
--- a/nx-X11/programs/Xserver/GL/glx/glximports.c
+++ b/nx-X11/programs/Xserver/GL/glx/glximports.c
@@ -81,7 +81,7 @@ void *__glXImpCalloc(__GLcontext *gc, size_t numElements, size_t elementSize)
 void __glXImpFree(__GLcontext *gc, void *addr)
 {
     if (addr) {
-	xfree(addr);
+	free(addr);
     }
 }
 
@@ -91,7 +91,7 @@ void *__glXImpRealloc(__GLcontext *gc, void *addr, size_t newSize)
 
     if (addr) {
 	if (newSize == 0) {
-	    xfree(addr);
+	    free(addr);
 	    return NULL;
 	}
 	newAddr = xrealloc(addr, newSize);
diff --git a/nx-X11/programs/Xserver/GL/glx/glxscreens.c b/nx-X11/programs/Xserver/GL/glx/glxscreens.c
index 58b38b1a2..1cbc0baf7 100644
--- a/nx-X11/programs/Xserver/GL/glx/glxscreens.c
+++ b/nx-X11/programs/Xserver/GL/glx/glxscreens.c
@@ -366,9 +366,9 @@ void __glXScreenReset(void)
       __glXFree(__glXActiveScreens[i].GLXextensions);
       __glXFree(__glXActiveScreens[i].GLextensions);
   }
-  xfree(__glXActiveScreens);
-  xfree(__glXHyperpipeFuncs);
-  xfree(__glXSwapBarrierFuncs);
+  free(__glXActiveScreens);
+  free(__glXHyperpipeFuncs);
+  free(__glXSwapBarrierFuncs);
   __glXNumHyperpipeFuncs = 0;
   __glXNumSwapBarrierFuncs = 0;
   __glXHyperpipeFuncs = NULL;
diff --git a/nx-X11/programs/Xserver/GL/glx/glxutil.c b/nx-X11/programs/Xserver/GL/glx/glxutil.c
index 03bc19f63..cf0aae011 100644
--- a/nx-X11/programs/Xserver/GL/glx/glxutil.c
+++ b/nx-X11/programs/Xserver/GL/glx/glxutil.c
@@ -102,7 +102,7 @@ __glXRealloc(void *addr, size_t newSize)
 
     if (addr) {
 	if (newSize == 0) {
-	    xfree(addr);
+	    free(addr);
 	    return NULL;
 	} else {
 	    newAddr = xrealloc(addr, newSize);
@@ -125,7 +125,7 @@ void
 __glXFree(void *addr)
 {
     if (addr) {
-	xfree(addr);
+	free(addr);
     }
 }
 
diff --git a/nx-X11/programs/Xserver/GL/mesa/X/xf86glx.c b/nx-X11/programs/Xserver/GL/mesa/X/xf86glx.c
index 19b5be637..6ec2164ba 100644
--- a/nx-X11/programs/Xserver/GL/mesa/X/xf86glx.c
+++ b/nx-X11/programs/Xserver/GL/mesa/X/xf86glx.c
@@ -516,7 +516,7 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
 
     /* Free the private list created by DDX HW driver */
     if (visualPrivates)
-        xfree(visualPrivates);
+        free(visualPrivates);
     visualPrivates = NULL;
 
     return TRUE;
diff --git a/nx-X11/programs/Xserver/GL/mesa/X/xf86glx_util.c b/nx-X11/programs/Xserver/GL/mesa/X/xf86glx_util.c
index 1889bdabd..0a86bf208 100644
--- a/nx-X11/programs/Xserver/GL/mesa/X/xf86glx_util.c
+++ b/nx-X11/programs/Xserver/GL/mesa/X/xf86glx_util.c
@@ -70,7 +70,7 @@ void XMesaDestroyImage(XMesaImage *image)
 {
     if (image->data)
 	free(image->data);
-    xfree(image);
+    free(image);
 }
 
 unsigned long XMesaGetPixel(XMesaImage *image, int x, int y)
diff --git a/nx-X11/programs/Xserver/Xext/extmod/modinit.c b/nx-X11/programs/Xserver/Xext/extmod/modinit.c
index 6969148a3..5bfd15719 100644
--- a/nx-X11/programs/Xserver/Xext/extmod/modinit.c
+++ b/nx-X11/programs/Xserver/Xext/extmod/modinit.c
@@ -167,7 +167,7 @@ extmodSetup(void * module, void * opts, int *errmaj, int *errmin)
 		strcpy(s, "omit");
 		strcat(s, extensionModules[i].name);
 		o = xf86FindOption(opts, s);
-		xfree(s);
+		free(s);
 		if (o) {
 		    xf86MarkOptionUsed(o);
 		    continue;
diff --git a/nx-X11/programs/Xserver/Xext/panoramiX.c b/nx-X11/programs/Xserver/Xext/panoramiX.c
index a1bfa91d6..c3b47cf2c 100644
--- a/nx-X11/programs/Xserver/Xext/panoramiX.c
+++ b/nx-X11/programs/Xserver/Xext/panoramiX.c
@@ -165,7 +165,7 @@ XineramaCloseScreen (int i, ScreenPtr pScreen)
     if (pScreen->myNum == 0)
 	RegionUninit(&PanoramiXScreenRegion);
 
-    xfree ((void *) pScreenPriv);
+    free ((void *) pScreenPriv);
 
     return (*pScreen->CloseScreen) (i, pScreen);
 }
@@ -337,7 +337,7 @@ XineramaDestroyClip(GCPtr pGC)
 int
 XineramaDeleteResource(void * data, XID id)
 {
-    xfree(data);
+    free(data);
     return 1;
 }
 
@@ -727,10 +727,10 @@ Bool PanoramiXCreateConnectionBlock(void)
 
     connSetupPrefix.length = length >> 2;
 
-    xfree(PanoramiXVisuals);
+    free(PanoramiXVisuals);
     for (i = 0; i < PanoramiXNumDepths; i++)
-	xfree(PanoramiXDepths[i].vids);
-    xfree(PanoramiXDepths);
+	free(PanoramiXDepths[i].vids);
+    free(PanoramiXDepths);
 
     /*
      *  OK, change some dimensions so it looks as if it were one big screen
@@ -752,7 +752,7 @@ Bool PanoramiXCreateConnectionBlock(void)
 	tmp = (void *)ConnectionCallbackList;
 	(*ConnectionCallbackList->func)();
 	ConnectionCallbackList = ConnectionCallbackList->next;
-	xfree(tmp);
+	free(tmp);
     }
 
     return TRUE;
@@ -927,7 +927,7 @@ static void PanoramiXResetProc(ExtensionEntry* extEntry)
     for (i = 256; i--; )
 	ProcVector[i] = SavedProcVector[i];
 
-    Xfree(panoramiXdataPtr);    
+    free(panoramiXdataPtr);
 }
 
 
@@ -1292,7 +1292,7 @@ XineramaGetImageData(
     }
 
     if(ScratchMem)
-	xfree(ScratchMem);
+	free(ScratchMem);
 
     RegionUninit(&SrcRegion);
     RegionUninit(&GrabRegion);
diff --git a/nx-X11/programs/Xserver/Xext/panoramiXprocs.c b/nx-X11/programs/Xserver/Xext/panoramiXprocs.c
index b4719d76f..28c0eb8b0 100644
--- a/nx-X11/programs/Xserver/Xext/panoramiXprocs.c
+++ b/nx-X11/programs/Xserver/Xext/panoramiXprocs.c
@@ -170,7 +170,7 @@ int PanoramiXCreateWindow(ClientPtr client)
     if (result == Success)
         AddResource(newWin->info[0].id, XRT_WINDOW, newWin);
     else 
-        xfree(newWin);
+        free(newWin);
 
     return (result);
 }
@@ -679,7 +679,7 @@ int PanoramiXCreatePixmap(ClientPtr client)
     if (result == Success)
 	AddResource(newPix->info[0].id, XRT_PIXMAP, newPix);
     else 
-	xfree(newPix);
+	free(newPix);
 
     return (result);
 }
@@ -784,7 +784,7 @@ int PanoramiXCreateGC(ClientPtr client)
     if (result == Success)
         AddResource(newGC->info[0].id, XRT_GC, newGC);
     else 
-        xfree(newGC);
+        free(newGC);
 
     return (result);
 }
@@ -1049,7 +1049,7 @@ int PanoramiXCopyArea(ClientPtr client)
 
 	    if(drawables[0]->depth != pDst->depth) {
 		client->errorValue = stuff->dstDrawable;
-		xfree(data);
+		free(data);
 		return (BadMatch);
 	    }
 
@@ -1060,7 +1060,7 @@ int PanoramiXCopyArea(ClientPtr client)
 	    if(dstShared) break;
 	}
 
-	xfree(data);
+	free(data);
 
 	result = Success;
     } else {
@@ -1890,7 +1890,7 @@ int PanoramiXGetImage(ClientPtr client)
             }
 	}
     }
-    xfree(pBuf);
+    free(pBuf);
     return (client->noClientException);
 }
 
@@ -2092,7 +2092,7 @@ int PanoramiXCreateColormap(ClientPtr client)
     if (result == Success)
         AddResource(newCmap->info[0].id, XRT_COLORMAP, newCmap);
     else 
-        xfree(newCmap);
+        free(newCmap);
 
     return (result);
 }
@@ -2159,7 +2159,7 @@ PanoramiXCopyColormapAndFree(ClientPtr client)
     if (result == Success)
         AddResource(newCmap->info[0].id, XRT_COLORMAP, newCmap);
     else 
-        xfree(newCmap);
+        free(newCmap);
 
     return (result);
 }
diff --git a/nx-X11/programs/Xserver/Xext/saver.c b/nx-X11/programs/Xserver/Xext/saver.c
index 81f502189..68dbe2fe8 100644
--- a/nx-X11/programs/Xserver/Xext/saver.c
+++ b/nx-X11/programs/Xserver/Xext/saver.c
@@ -274,7 +274,7 @@ CheckScreenPrivate (pScreen)
     if (!pPriv->attr && !pPriv->events &&
 	!pPriv->hasWindow && pPriv->installedMap == None)
     {
-	xfree (pPriv);
+	free (pPriv);
 	SetScreenPrivate (pScreen, NULL);
 	savedScreenInfo[pScreen->myNum].ExternalScreenSaver = NULL;
     }
@@ -340,7 +340,7 @@ setEventMask (pScreen, client, mask)
     {
 	FreeResource (pEv->resource, EventType);
 	*pPrev = pEv->next;
-	xfree (pEv);
+	free (pEv);
 	CheckScreenPrivate (pScreen);
     }
     else
@@ -386,8 +386,8 @@ FreeScreenAttr (pAttr)
     ScreenSaverAttrPtr	pAttr;
 {
     FreeAttrs (pAttr);
-    xfree (pAttr->values);
-    xfree (pAttr);
+    free (pAttr->values);
+    free (pAttr);
 }
 
 static int
@@ -408,7 +408,7 @@ ScreenSaverFreeEvents (value, id)
     if (!pEv)
 	return TRUE;
     *pPrev = pEv->next;
-    xfree (pEv);
+    free (pEv);
     CheckScreenPrivate (pScreen);
     return TRUE;
 }
@@ -1172,8 +1172,8 @@ PatchUp:
     FreeAttrs (pAttr);
 bail:
     CheckScreenPrivate (pScreen);
-    if (pAttr) xfree (pAttr->values);
-    xfree (pAttr);
+    if (pAttr) free (pAttr->values);
+    free (pAttr);
     return ret;
 }
 
diff --git a/nx-X11/programs/Xserver/Xext/security.c b/nx-X11/programs/Xserver/Xext/security.c
index 096b88d20..ceadd8f6a 100644
--- a/nx-X11/programs/Xserver/Xext/security.c
+++ b/nx-X11/programs/Xserver/Xext/security.c
@@ -331,7 +331,7 @@ SecurityDeleteAuthorization(
     }
 
     SecurityAudit("revoked authorization ID %d\n", pAuth->id);
-    xfree(pAuth);
+    free(pAuth);
     return Success;
 
 } /* SecurityDeleteAuthorization */
@@ -356,7 +356,7 @@ SecurityDeleteAuthorizationEventClient(
 		prev->next = pEventClient->next;
 	    else
 		pAuth->eventClients = pEventClient->next;
-	    xfree(pEventClient);
+	    free(pEventClient);
 	    return(Success);
 	}
 	prev = pEventClient;
@@ -533,7 +533,7 @@ SecurityEventSelectForAuthorization(
     if (!AddResource(pEventClient->resource, RTEventClient,
 		     (void *)pAuth))
     {
-	xfree(pEventClient);
+	free(pEventClient);
 	return BadAlloc;
     }
     pAuth->eventClients = pEventClient;
@@ -734,7 +734,7 @@ bailout:
     if (removeAuth)
 	RemoveAuthorization(stuff->nbytesAuthProto, protoname,
 			    authdata_len, pAuthdata);
-    if (pAuth) xfree(pAuth);
+    if (pAuth) free(pAuth);
     return err;
 
 } /* ProcSecurityGenerateAuthorization */
@@ -1486,7 +1486,7 @@ SecurityFreePropertyAccessList(void)
     {
 	PropertyAccessPtr freeit = PropertyAccessList;
 	PropertyAccessList = PropertyAccessList->next;
-	xfree(freeit);
+	free(freeit);
     }
 } /* SecurityFreePropertyAccessList */
 
@@ -1650,7 +1650,7 @@ SecurityParsePropertyAccessRule(
     pacl->name = MakeAtom(propname, strlen(propname), TRUE);
     if (pacl->name == BAD_RESOURCE)
     {
-	Xfree(pacl);
+	free(pacl);
 	return FALSE;
     }
     if (mustHaveProperty)
@@ -1659,7 +1659,7 @@ SecurityParsePropertyAccessRule(
 					  strlen(mustHaveProperty), TRUE);
 	if (pacl->mustHaveProperty == BAD_RESOURCE)
 	{
-	    Xfree(pacl);
+	    free(pacl);
 	    return FALSE;
 	}
     }
@@ -1724,7 +1724,7 @@ SecurityParseSitePolicy(
 			  sizeof (char *) * (nSecurityPolicyStrings + 1));
     if (!newStrings)
     {
-	Xfree(copyPolicyStr);
+	free(copyPolicyStr);
 	return TRUE;
     }
 
@@ -1752,9 +1752,9 @@ SecurityFreeSitePolicyStrings(void)
 	assert(nSecurityPolicyStrings);
 	while (nSecurityPolicyStrings--)
 	{
-	    Xfree(SecurityPolicyStrings[nSecurityPolicyStrings]);
+	    free(SecurityPolicyStrings[nSecurityPolicyStrings]);
 	}
-	Xfree(SecurityPolicyStrings);
+	free(SecurityPolicyStrings);
 	SecurityPolicyStrings = NULL;
 	nSecurityPolicyStrings = 0;
     }
diff --git a/nx-X11/programs/Xserver/Xext/shape.c b/nx-X11/programs/Xserver/Xext/shape.c
index b272f1bbe..a55dd4553 100644
--- a/nx-X11/programs/Xserver/Xext/shape.c
+++ b/nx-X11/programs/Xserver/Xext/shape.c
@@ -796,7 +796,7 @@ ShapeFreeClient (data, id)
 	    	*pHead = pShapeEvent->next;
 	}
     }
-    xfree ((void *) pShapeEvent);
+    free ((void *) pShapeEvent);
     return 1;
 }
 
@@ -812,9 +812,9 @@ ShapeFreeEvents (data, id)
     for (pCur = *pHead; pCur; pCur = pNext) {
 	pNext = pCur->next;
 	FreeResource (pCur->clientResource, ClientType);
-	xfree ((void *) pCur);
+	free ((void *) pCur);
     }
-    xfree ((void *) pHead);
+    free ((void *) pHead);
     return 1;
 }
 
@@ -898,7 +898,7 @@ ProcShapeSelectInput (client)
 		    pNewShapeEvent->next = pShapeEvent->next;
 		else
 		    *pHead = pShapeEvent->next;
-		xfree (pShapeEvent);
+		free (pShapeEvent);
 	    }
 	}
 	break;
diff --git a/nx-X11/programs/Xserver/Xext/shm.c b/nx-X11/programs/Xserver/Xext/shm.c
index 83d6eaaab..4e36a6bb4 100644
--- a/nx-X11/programs/Xserver/Xext/shm.c
+++ b/nx-X11/programs/Xserver/Xext/shm.c
@@ -447,7 +447,7 @@ ProcShmAttach(client)
 	if ((shmdesc->addr == ((char *)-1)) ||
 	    shmctl(stuff->shmid, IPC_STAT, &buf))
 	{
-	    xfree(shmdesc);
+	    free(shmdesc);
 	    return BadAccess;
 	}
 
@@ -457,7 +457,7 @@ ProcShmAttach(client)
 
 	if (shm_access(client, &(buf.shm_perm), stuff->readOnly) == -1) {
 	    shmdt(shmdesc->addr);
-	    xfree(shmdesc);
+	    free(shmdesc);
 	    return BadAccess;
 	}
 
@@ -488,7 +488,7 @@ ShmDetachSegment(value, shmseg)
     for (prev = &Shmsegs; *prev != shmdesc; prev = &(*prev)->next)
 	;
     *prev = shmdesc->next;
-    xfree(shmdesc);
+    free(shmdesc);
     return Success;
 }
 
@@ -820,7 +820,7 @@ CreatePmap:
 	    (*pScreen->DestroyPixmap)(pMap);
 	    FreeResource(newPix->info[j].id, RT_NONE);
 	}
-	xfree(newPix);
+	free(newPix);
     } else 
 	AddResource(stuff->pid, XRT_PIXMAP, newPix);
 
diff --git a/nx-X11/programs/Xserver/Xext/sleepuntil.c b/nx-X11/programs/Xserver/Xext/sleepuntil.c
index 62f946cf8..368dc6b48 100644
--- a/nx-X11/programs/Xserver/Xext/sleepuntil.c
+++ b/nx-X11/programs/Xserver/Xext/sleepuntil.c
@@ -111,7 +111,7 @@ ClientSleepUntil (client, revive, notifyFunc, closure)
 					     SertafiedWakeupHandler,
 					     (void *) 0))
 	{
-	    xfree (pRequest);
+	    free (pRequest);
 	    return FALSE;
 	}
 	BlockHandlerRegistered = TRUE;
@@ -169,7 +169,7 @@ SertafiedDelete (value, id)
 	}
     if (pRequest->notifyFunc)
 	(*pRequest->notifyFunc) (pRequest->pClient, pRequest->closure);
-    xfree (pRequest);
+    free (pRequest);
     return TRUE;
 }
 
diff --git a/nx-X11/programs/Xserver/Xext/sync.c b/nx-X11/programs/Xserver/Xext/sync.c
index f79cc1b23..8fe510497 100644
--- a/nx-X11/programs/Xserver/Xext/sync.c
+++ b/nx-X11/programs/Xserver/Xext/sync.c
@@ -319,7 +319,7 @@ SyncDeleteTriggerFromCounter(pTrigger)
 		pPrev->next = pCur->next;
 	    else
 		pTrigger->pCounter->pTriglist = pCur->next;
-	    xfree(pCur);
+	    free(pCur);
 	    break;
 	}
     }
@@ -890,7 +890,7 @@ SyncEventSelectForAlarm(pAlarm, client, wantevents)
     pClients->delete_id = FakeClientID(client->index);
     if (!AddResource(pClients->delete_id, RTAlarmClient, pAlarm))
     {
-	xfree(pClients);
+	free(pClients);
 	return BadAlloc;
     }
 
@@ -1019,7 +1019,7 @@ SyncCreateCounter(client, id, initialvalue)
 
     if (!AddResource(id, RTCounter, (void *) pCounter))
     {
-	xfree((void *) pCounter);
+	free((void *) pCounter);
 	return (SyncCounter *)NULL;
     }
 
@@ -1214,7 +1214,7 @@ FreeAlarm(addr, id)
 
     SyncDeleteTriggerFromCounter(&pAlarm->trigger);
 
-    xfree(pAlarm);
+    free(pAlarm);
     return Success;
 }
 
@@ -1237,13 +1237,13 @@ FreeCounter(env, id)
     {
 	(*ptl->pTrigger->CounterDestroyed)(ptl->pTrigger);
 	pnext = ptl->next;
-	xfree(ptl); /* destroy the trigger list as we go */
+	free(ptl); /* destroy the trigger list as we go */
     }
     if (IsSystemCounter(pCounter))
     {
 	int i, found = 0;
 
-	xfree(pCounter->pSysCounterInfo);
+	free(pCounter->pSysCounterInfo);
 
 	/* find the counter in the list of system counters and remove it */
 
@@ -1267,7 +1267,7 @@ FreeCounter(env, id)
 	}
 	SyncNumSystemCounters--;
     }
-    xfree(pCounter);
+    free(pCounter);
     return Success;
 }
 
@@ -1298,7 +1298,7 @@ FreeAwait(addr, id)
 	if (pCounter && !pCounter->beingDestroyed)
 	    SyncDeleteTriggerFromCounter(&pAwait->trigger);
     }
-    xfree(pAwaitUnion);
+    free(pAwaitUnion);
     return Success;
 }
 
@@ -1321,7 +1321,7 @@ FreeAlarmClient(value, id)
 		pPrev->next = pCur->next;
 	    else
 		pAlarm->pEventClients = pCur->next;
-	    xfree(pCur);
+	    free(pCur);
 	    return(Success);
 	}
     }
@@ -1679,7 +1679,7 @@ ProcSyncAwait(client)
     pAwaitUnion->header.delete_id = FakeClientID(client->index);
     if (!AddResource(pAwaitUnion->header.delete_id, RTAwait, pAwaitUnion))
     {
-	xfree(pAwaitUnion);
+	free(pAwaitUnion);
 	return BadAlloc;
     }
 
@@ -1838,7 +1838,7 @@ ProcSyncCreateAlarm(client)
     status = SyncInitTrigger(client, pTrigger, None, XSyncCAAllTrigger);
     if (status != Success)
     {
-	xfree(pAlarm);
+	free(pAlarm);
 	return status;
     }
 
@@ -1852,13 +1852,13 @@ ProcSyncCreateAlarm(client)
 				       (CARD32 *)&stuff[1]);
     if (status != Success)
     {
-	xfree(pAlarm);
+	free(pAlarm);
 	return status;
     }
 
     if (!AddResource(stuff->id, RTAlarm, pAlarm))
     {
-	xfree(pAlarm);
+	free(pAlarm);
 	return BadAlloc;
     }
 
@@ -2346,7 +2346,7 @@ static void
 SyncResetProc(extEntry)
     ExtensionEntry *extEntry;
 {
-    xfree(SysCounterList);
+    free(SysCounterList);
     SysCounterList = NULL;
     RTCounter = 0;
 }
diff --git a/nx-X11/programs/Xserver/Xext/xcmisc.c b/nx-X11/programs/Xserver/Xext/xcmisc.c
index ee7d69fc3..8f381cee5 100644
--- a/nx-X11/programs/Xserver/Xext/xcmisc.c
+++ b/nx-X11/programs/Xserver/Xext/xcmisc.c
@@ -175,7 +175,7 @@ ProcXCMiscGetXIDList(client)
     	client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
 	WriteSwappedDataToClient(client, count * sizeof(XID), pids);
     }
-    Xfree(pids);
+    free(pids);
     return(client->noClientException);
 }
 
diff --git a/nx-X11/programs/Xserver/Xext/xf86bigfont.c b/nx-X11/programs/Xserver/Xext/xf86bigfont.c
index 848f0114b..7bdda72b4 100644
--- a/nx-X11/programs/Xserver/Xext/xf86bigfont.c
+++ b/nx-X11/programs/Xserver/Xext/xf86bigfont.c
@@ -257,7 +257,7 @@ shmalloc(
     if (shmid == -1) {
 	ErrorF(XF86BIGFONTNAME " extension: shmget() failed, size = %u, errno = %d\n",
 	       size, errno);
-	xfree(pDesc);
+	free(pDesc);
 	return (ShmDescPtr) NULL;
     }
 
@@ -265,7 +265,7 @@ shmalloc(
 	ErrorF(XF86BIGFONTNAME " extension: shmat() failed, size = %u, errno = %d\n",
 	       size, errno);
 	shmctl(shmid, IPC_RMID, (void *) 0);
-	xfree(pDesc);
+	free(pDesc);
 	return (ShmDescPtr) NULL;
     }
 
@@ -294,7 +294,7 @@ shmdealloc(
 
     if (pDesc->next) pDesc->next->prev = pDesc->prev;
     *pDesc->prev = pDesc->next;
-    xfree(pDesc);
+    free(pDesc);
 }
 
 #endif
diff --git a/nx-X11/programs/Xserver/Xext/xvdisp.c b/nx-X11/programs/Xserver/Xext/xvdisp.c
index 3bcb130c7..b300a32d5 100644
--- a/nx-X11/programs/Xserver/Xext/xvdisp.c
+++ b/nx-X11/programs/Xserver/Xext/xvdisp.c
@@ -1281,7 +1281,7 @@ ProcXvQueryImageAttributes(ClientPtr client)
     SwapLongs((CARD32*)offsets, rep.length);
   WriteToClient(client, rep.length << 2, (char*)offsets);
 
-  xfree(offsets);
+  free(offsets);
 
   return Success;
 }
diff --git a/nx-X11/programs/Xserver/Xext/xvmain.c b/nx-X11/programs/Xserver/Xext/xvmain.c
index 571bb9c46..d2c21b13f 100644
--- a/nx-X11/programs/Xserver/Xext/xvmain.c
+++ b/nx-X11/programs/Xserver/Xext/xvmain.c
@@ -325,7 +325,7 @@ XvCloseScreen(
 
   (* pxvs->ddCloseScreen)(ii, pScreen); 
 
-  xfree(pxvs);
+  free(pxvs);
 
   pScreen->devPrivates[XvScreenIndex].ptr = (void *)NULL;
 
@@ -522,7 +522,7 @@ XvdiDestroyVideoNotifyList(void * pn, XID id)
     {
       npn = cpn->next;
       if (cpn->client) FreeResource(cpn->id, XvRTVideoNotify);
-      xfree(cpn);
+      free(cpn);
       cpn = npn;
     }
   return Success;
@@ -946,7 +946,7 @@ XvdiSelectVideoNotify(
       tpn->next = (XvVideoNotifyPtr)NULL;
       if (!AddResource(pDraw->id, XvRTVideoNotifyList, tpn))
 	{
-	  xfree(tpn);
+	  free(tpn);
 	  return BadAlloc;
 	}
     }
diff --git a/nx-X11/programs/Xserver/Xext/xvmc.c b/nx-X11/programs/Xserver/Xext/xvmc.c
index b1441fa1d..0ec04f3e3 100644
--- a/nx-X11/programs/Xserver/Xext/xvmc.c
+++ b/nx-X11/programs/Xserver/Xext/xvmc.c
@@ -75,7 +75,7 @@ XvMCDestroyContextRes(void * data, XID id)
    if(!pContext->refcnt) {
   	 XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen);
 	(*pScreenPriv->adaptors[pContext->adapt_num].DestroyContext)(pContext);
-	xfree(pContext);
+	free(pContext);
    }	   
 
    return Success;
@@ -89,7 +89,7 @@ XvMCDestroySurfaceRes(void * data, XID id)
    XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen);
 
    (*pScreenPriv->adaptors[pContext->adapt_num].DestroySurface)(pSurface); 
-   xfree(pSurface);
+   free(pSurface);
 
    XvMCDestroyContextRes((void *)pContext, pContext->context_id);
 
@@ -105,7 +105,7 @@ XvMCDestroySubpictureRes(void * data, XID id)
    XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen);
 
    (*pScreenPriv->adaptors[pContext->adapt_num].DestroySubpicture)(pSubpict); 
-   xfree(pSubpict);
+   free(pSubpict);
 
    XvMCDestroyContextRes((void *)pContext, pContext->context_id);
 
@@ -259,7 +259,7 @@ ProcXvMCCreateContext(ClientPtr client)
     result = (*adaptor->CreateContext)(pPort, pContext, &dwords, &data);
 
     if(result != Success) {
-	xfree(pContext);
+	free(pContext);
 	return result;
     }
 
@@ -276,7 +276,7 @@ ProcXvMCCreateContext(ClientPtr client)
     AddResource(pContext->context_id, XvMCRTContext, pContext);
 
     if(data)
-	xfree(data);
+	free(data);
 
     return Success;
 }
@@ -324,7 +324,7 @@ ProcXvMCCreateSurface(ClientPtr client)
                 pSurface, &dwords, &data);
 
     if(result != Success) {
-        xfree(pSurface);
+        free(pSurface);
         return result;
     }
 
@@ -338,7 +338,7 @@ ProcXvMCCreateSurface(ClientPtr client)
     AddResource(pSurface->surface_id, XvMCRTSurface, pSurface);
 
     if(data)
-        xfree(data);
+        free(data);
 
     pContext->refcnt++;
 
@@ -427,7 +427,7 @@ ProcXvMCCreateSubpicture(ClientPtr client)
                 pSubpicture, &dwords, &data);
 
     if(result != Success) {
-        xfree(pSubpicture);
+        free(pSubpicture);
         return result;
     }
 
@@ -449,7 +449,7 @@ ProcXvMCCreateSubpicture(ClientPtr client)
     AddResource(pSubpicture->subpicture_id, XvMCRTSubpicture, pSubpicture);
 
     if(data)
-        xfree(data);
+        free(data);
 
     pContext->refcnt++;
 
@@ -708,7 +708,7 @@ XvMCCloseScreen (int i, ScreenPtr pScreen)
 
     pScreen->CloseScreen = pScreenPriv->CloseScreen;
 
-    xfree(pScreenPriv);
+    free(pScreenPriv);
 
     return (*pScreen->CloseScreen)(i, pScreen);
 }
diff --git a/nx-X11/programs/Xserver/Xi/chgptr.c b/nx-X11/programs/Xserver/Xi/chgptr.c
index 4877fcc84..2bbd7bc37 100644
--- a/nx-X11/programs/Xserver/Xi/chgptr.c
+++ b/nx-X11/programs/Xserver/Xi/chgptr.c
@@ -185,8 +185,8 @@ void
 DeleteFocusClassDeviceStruct(dev)
     DeviceIntPtr dev;
     {
-    xfree(dev->focus->trace);
-    xfree(dev->focus);
+    free(dev->focus->trace);
+    free(dev->focus);
     dev->focus = NULL;
     }
 
diff --git a/nx-X11/programs/Xserver/Xi/exevents.c b/nx-X11/programs/Xserver/Xi/exevents.c
index ce5fe9ec9..1612047bb 100644
--- a/nx-X11/programs/Xserver/Xi/exevents.c
+++ b/nx-X11/programs/Xserver/Xi/exevents.c
@@ -515,7 +515,7 @@ DeviceFocusEvent(dev, type, mode, detail, pWin)
 
 	(void) DeliverEventsToWindow(pWin, (xEvent *)sev, evcount,
 	    DeviceStateNotifyMask, NullGrab, dev->id);
-	xfree (sev);
+	free (sev);
         }
     }
 
@@ -830,17 +830,17 @@ InputClientGone(pWin, id)
 	    if (prev)
 		{
 		prev->next = other->next;
-		xfree(other);
+		free(other);
 		}
 	    else if (!(other->next))
 		{
 	        if (ShouldFreeInputMasks(pWin, TRUE))
 		    {
 		    wOtherInputMasks(pWin)->inputClients = other->next;
-		    xfree(wOtherInputMasks(pWin));
+		    free(wOtherInputMasks(pWin));
 		    pWin->optional->inputMasks = (OtherInputMasks *) NULL;
 		    CheckWindowOptionalNeed (pWin);
-		    xfree(other);
+		    free(other);
 		    }
 		else
 		    {
@@ -853,7 +853,7 @@ InputClientGone(pWin, id)
 	    else
 		{
 		wOtherInputMasks(pWin)->inputClients = other->next;
-		xfree(other);
+		free(other);
 		}
 	    RecalculateDeviceDeliverableEvents(pWin);
 	    return(Success);
@@ -1032,7 +1032,7 @@ SetModifierMapping(client, dev, len, rlen, numKeyPerModifier, inputMap, k)
             return BadAlloc;
     }
     if ((*k)->modifierKeyMap)
-        xfree((*k)->modifierKeyMap);
+        free((*k)->modifierKeyMap);
     if (inputMapLen) {
         (*k)->modifierKeyMap = map;
         memmove((char *)(*k)->modifierKeyMap, (char *)inputMap, inputMapLen);
diff --git a/nx-X11/programs/Xserver/Xi/getdctl.c b/nx-X11/programs/Xserver/Xi/getdctl.c
index d8c310d92..440c1eeb4 100644
--- a/nx-X11/programs/Xserver/Xi/getdctl.c
+++ b/nx-X11/programs/Xserver/Xi/getdctl.c
@@ -161,7 +161,7 @@ ProcXGetDeviceControl(client)
     rep.length = (total_length+3) >> 2;
     WriteReplyToClient(client, sizeof(xGetDeviceControlReply), &rep);
     WriteToClient(client, total_length, savbuf);
-    xfree (savbuf);
+    free (savbuf);
     return Success;
     }
 
diff --git a/nx-X11/programs/Xserver/Xi/getfctl.c b/nx-X11/programs/Xserver/Xi/getfctl.c
index c6cb8457c..e2f243430 100644
--- a/nx-X11/programs/Xserver/Xi/getfctl.c
+++ b/nx-X11/programs/Xserver/Xi/getfctl.c
@@ -190,7 +190,7 @@ ProcXGetFeedbackControl(client)
     rep.length = (total_length+3) >> 2;
     WriteReplyToClient(client, sizeof(xGetFeedbackControlReply), &rep);
     WriteToClient(client, total_length, savbuf);
-    xfree (savbuf);
+    free (savbuf);
     return Success;
     }
 
diff --git a/nx-X11/programs/Xserver/Xi/getprop.c b/nx-X11/programs/Xserver/Xi/getprop.c
index ac37617ec..33d49fb95 100644
--- a/nx-X11/programs/Xserver/Xi/getprop.c
+++ b/nx-X11/programs/Xserver/Xi/getprop.c
@@ -154,7 +154,7 @@ ProcXGetDeviceDontPropagateList (client)
 	{
 	client->pSwapReplyFunc = (ReplySwapPtr)Swap32Write;
 	WriteSwappedDataToClient( client, count * sizeof(XEventClass), buf);
-	xfree (buf);
+	free (buf);
 	}
     return Success;
     }
diff --git a/nx-X11/programs/Xserver/Xi/getselev.c b/nx-X11/programs/Xserver/Xi/getselev.c
index 7cd97b5ef..05d9d987c 100644
--- a/nx-X11/programs/Xserver/Xi/getselev.c
+++ b/nx-X11/programs/Xserver/Xi/getselev.c
@@ -168,7 +168,7 @@ ProcXGetSelectedExtensionEvents(client)
 	{
 	client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
 	WriteSwappedDataToClient( client, total_length, buf);
-	xfree (buf);
+	free (buf);
 	}
     return Success;
     }
diff --git a/nx-X11/programs/Xserver/Xi/listdev.c b/nx-X11/programs/Xserver/Xi/listdev.c
index e99584d0e..2e78aa339 100644
--- a/nx-X11/programs/Xserver/Xi/listdev.c
+++ b/nx-X11/programs/Xserver/Xi/listdev.c
@@ -144,7 +144,7 @@ ProcXListInputDevices (client)
     rep.length = (total_length + 3) >> 2;
     WriteReplyToClient (client, sizeof (xListInputDevicesReply), &rep);
     WriteToClient(client, total_length, savbuf);
-    xfree (savbuf);
+    free (savbuf);
     return Success;
     }
 
diff --git a/nx-X11/programs/Xserver/Xi/queryst.c b/nx-X11/programs/Xserver/Xi/queryst.c
index af2b4301d..975643e0e 100644
--- a/nx-X11/programs/Xserver/Xi/queryst.c
+++ b/nx-X11/programs/Xserver/Xi/queryst.c
@@ -190,7 +190,7 @@ ProcXQueryDeviceState(client)
     WriteReplyToClient (client, sizeof(xQueryDeviceStateReply), &rep);
     if (total_length > 0)
 	WriteToClient (client, total_length, savbuf);
-    xfree (savbuf);
+    free (savbuf);
     return Success;
     }
 
diff --git a/nx-X11/programs/Xserver/composite/compalloc.c b/nx-X11/programs/Xserver/composite/compalloc.c
index 017459b6b..a5d0998eb 100644
--- a/nx-X11/programs/Xserver/composite/compalloc.c
+++ b/nx-X11/programs/Xserver/composite/compalloc.c
@@ -159,7 +159,7 @@ compRedirectWindow(ClientPtr pClient, WindowPtr pWin, int update)
 	cw = xalloc (sizeof (CompWindowRec));
 	if (!cw)
 	{
-	    xfree (ccw);
+	    free (ccw);
 	    return BadAlloc;
 	}
 	cw->damage = DamageCreate (compReportDamage,
@@ -170,8 +170,8 @@ compRedirectWindow(ClientPtr pClient, WindowPtr pWin, int update)
 				   pWin);
 	if (!cw->damage)
 	{
-	    xfree (ccw);
-	    xfree (cw);
+	    free (ccw);
+	    free (cw);
 	    return BadAlloc;
 	}
 
@@ -269,7 +269,7 @@ compFreeClientWindow (WindowPtr pWin, XID id)
 	    *prev = ccw->next;
 	    if (ccw->update == CompositeRedirectManual)
 		cw->update = CompositeRedirectAutomatic;
-	    xfree (ccw);
+	    free (ccw);
 	    break;
 	}
     }
@@ -288,7 +288,7 @@ compFreeClientWindow (WindowPtr pWin, XID id)
 	RegionUninit(&cw->borderClip);
     
         FAKE_DIX_SET_WINDOW_PRIVATE(pWin, NULL);
-	xfree (cw);
+	free (cw);
     }
     else if (cw->update == CompositeRedirectAutomatic &&
 	     !cw->damageRegistered && pWin->redirectDraw != RedirectDrawNone)
@@ -368,7 +368,7 @@ compRedirectSubwindows (ClientPtr pClient, WindowPtr pWin, int update)
 	csw = xalloc (sizeof (CompSubwindowsRec));
 	if (!csw)
 	{
-	    xfree (ccw);
+	    free (ccw);
 	    return BadAlloc;
 	}
 	csw->update = CompositeRedirectAutomatic;
@@ -387,10 +387,10 @@ compRedirectSubwindows (ClientPtr pClient, WindowPtr pWin, int update)
 		(void) compUnredirectWindow (pClient, pChild, update);
 	    if (!csw->clients)
 	    {
-		xfree (csw);
+		free (csw);
                 FAKE_DIX_SET_SUBWINDOWS_PRIVATE(pWin, NULL);
 	    }
-	    xfree (ccw);
+	    free (ccw);
 	    return ret;
 	}
     }
@@ -451,7 +451,7 @@ compFreeClientSubwindows (WindowPtr pWin, XID id)
 	    for (pChild = pWin->lastChild; pChild; pChild = pChild->prevSib)
 		(void) compUnredirectWindow (pClient, pChild, ccw->update);
 
-	    xfree (ccw);
+	    free (ccw);
 	    break;
 	}
     }
@@ -462,7 +462,7 @@ compFreeClientSubwindows (WindowPtr pWin, XID id)
     if (!csw->clients)
     {
         FAKE_DIX_SET_SUBWINDOWS_PRIVATE(pWin, NULL);
-	xfree (csw);
+	free (csw);
     }
 }
 
diff --git a/nx-X11/programs/Xserver/composite/compinit.c b/nx-X11/programs/Xserver/composite/compinit.c
index c86aaed5a..930787195 100644
--- a/nx-X11/programs/Xserver/composite/compinit.c
+++ b/nx-X11/programs/Xserver/composite/compinit.c
@@ -76,7 +76,7 @@ compCloseScreen (int index, ScreenPtr pScreen)
     pScreen->GetSpans = cs->GetSpans;
     pScreen->SourceValidate = cs->SourceValidate;
 
-    xfree (cs);
+    free (cs);
     FAKE_DIX_SET_SCREEN_PRIVATE(pScreen, NULL);
     ret = (*pScreen->CloseScreen) (index, pScreen);
     return ret;
@@ -422,7 +422,7 @@ compScreenInit (ScreenPtr pScreen)
 
     if (!compAddAlternateVisuals (pScreen, cs))
     {
-	xfree (cs);
+	free (cs);
 	return FALSE;
     }
 
diff --git a/nx-X11/programs/Xserver/damageext/damageext.c b/nx-X11/programs/Xserver/damageext/damageext.c
index d14f14985..aedbecb7b 100755
--- a/nx-X11/programs/Xserver/damageext/damageext.c
+++ b/nx-X11/programs/Xserver/damageext/damageext.c
@@ -214,7 +214,7 @@ ProcDamageCreate (ClientPtr client)
 					pDamageExt);
     if (!pDamageExt->pDamage)
     {
-	xfree (pDamageExt);
+	free (pDamageExt);
 	return BadAlloc;
     }
     if (!AddResource (stuff->damage, DamageExtType, (void *) pDamageExt))
@@ -412,7 +412,7 @@ FreeDamageExt (void * value, XID did)
 	DamageUnregister (pDamageExt->pDrawable, pDamageExt->pDamage);
 	DamageDestroy (pDamageExt->pDamage);
     }
-    xfree (pDamageExt);
+    free (pDamageExt);
     return Success;
 }
 
diff --git a/nx-X11/programs/Xserver/dbe/dbe.c b/nx-X11/programs/Xserver/dbe/dbe.c
index 064987dec..e64b6bd22 100644
--- a/nx-X11/programs/Xserver/dbe/dbe.c
+++ b/nx-X11/programs/Xserver/dbe/dbe.c
@@ -476,7 +476,7 @@ ProcDbeAllocateBackBufferName(client)
     }
 
     /* Free what was allocated by the GetVisualInfo() call above. */
-    xfree(scrVisInfo.visinfo);
+    free(scrVisInfo.visinfo);
 
     if (!visualMatched)
     {
@@ -499,7 +499,7 @@ ProcDbeAllocateBackBufferName(client)
         if (!AddResource(stuff->buffer, dbeWindowPrivResType,
             (void *)pDbeWindowPriv))
         {
-            xfree(pDbeWindowPriv);
+            free(pDbeWindowPriv);
             return(BadAlloc);
         }
 
@@ -610,7 +610,7 @@ ProcDbeAllocateBackBufferName(client)
         /* The DDX buffer allocation routine failed for the first buffer of
          * this window.
          */
-        xfree(pDbeWindowPriv);
+        free(pDbeWindowPriv);
         return(status);
     }
 
@@ -761,14 +761,14 @@ ProcDbeSwapBuffers(client)
         if (!(pWin = SecurityLookupWindow(dbeSwapInfo[i].window, client,
 					  SecurityWriteAccess)))
         {
-            Xfree(swapInfo);
+            free(swapInfo);
 	    return(BadWindow);
         }
 
         /* Each window must be double-buffered - BadMatch. */
         if (DBE_WINDOW_PRIV(pWin) == NULL)
         {
-            Xfree(swapInfo);
+            free(swapInfo);
             return(BadMatch);
         }
 
@@ -777,7 +777,7 @@ ProcDbeSwapBuffers(client)
         {
             if (dbeSwapInfo[i].window == dbeSwapInfo[j].window)
             {
-                Xfree(swapInfo);
+                free(swapInfo);
                 return(BadMatch);
 	    }
         }
@@ -788,7 +788,7 @@ ProcDbeSwapBuffers(client)
             (dbeSwapInfo[i].swapAction != XdbeUntouched ) &&
             (dbeSwapInfo[i].swapAction != XdbeCopied    ))
         {
-            Xfree(swapInfo);
+            free(swapInfo);
             return(BadValue);
         }
 
@@ -818,12 +818,12 @@ ProcDbeSwapBuffers(client)
         error = (*pDbeScreenPriv->SwapBuffers)(client, &nStuff, swapInfo);
         if (error != Success)
         {
-            Xfree(swapInfo);
+            free(swapInfo);
             return(error);
         }
     }
     
-    Xfree(swapInfo);
+    free(swapInfo);
     return(Success);
 
 } /* ProcDbeSwapBuffers() */
@@ -925,7 +925,7 @@ ProcDbeGetVisualInfo(client)
             if (!(pDrawables[i] = (DrawablePtr)SecurityLookupDrawable(
 				drawables[i], client, SecurityReadAccess)))
             {
-                Xfree(pDrawables);
+                free(pDrawables);
                 return(BadDrawable);
             }
         }
@@ -937,7 +937,7 @@ ProcDbeGetVisualInfo(client)
     {
         if (pDrawables)
         {
-            Xfree(pDrawables);
+            free(pDrawables);
         }
 
         return(BadAlloc);
@@ -958,13 +958,13 @@ ProcDbeGetVisualInfo(client)
             /* Free visinfos that we allocated for previous screen infos.*/
             for (j = 0; j < i; j++)
             {
-                xfree(pScrVisInfo[j].visinfo);
+                free(pScrVisInfo[j].visinfo);
             }
 
             /* Free pDrawables if we needed to allocate it above. */
             if (pDrawables)
             {
-                Xfree(pDrawables);
+                free(pDrawables);
             }
 
             return(BadAlloc);
@@ -1039,13 +1039,13 @@ ProcDbeGetVisualInfo(client)
     /* Clean up memory. */
     for (i = 0; i < count; i++)
     {
-        xfree(pScrVisInfo[i].visinfo);
+        free(pScrVisInfo[i].visinfo);
     }
-    xfree(pScrVisInfo);
+    free(pScrVisInfo);
 
     if (pDrawables)
     {
-        Xfree(pDrawables);
+        free(pDrawables);
     }
 
     return(client->noClientException);
@@ -1640,7 +1640,7 @@ DbeWindowPrivDelete(pDbeWinPriv, id)
                DBE_INIT_MAX_IDS * sizeof(XID));
 
         /* Free the extended array; use the static array. */
-        xfree(pDbeWindowPriv->IDs);
+        free(pDbeWindowPriv->IDs);
         pDbeWindowPriv->IDs = pDbeWindowPriv->initIDs;
         pDbeWindowPriv->maxAvailableIDs = DBE_INIT_MAX_IDS;
     }
@@ -1671,7 +1671,7 @@ DbeWindowPrivDelete(pDbeWinPriv, id)
             (void *)NULL;
 
         /* We are done with the window priv. */
-        xfree(pDbeWindowPriv);
+        free(pDbeWindowPriv);
     }
 
     return(Success);
@@ -1719,10 +1719,10 @@ DbeResetProc(extEntry)
 
             if (pDbeScreenPriv->winPrivPrivSizes)
             {
-	        xfree(pDbeScreenPriv->winPrivPrivSizes);
+	        free(pDbeScreenPriv->winPrivPrivSizes);
             }
 
-	    xfree(pDbeScreenPriv);
+	    free(pDbeScreenPriv);
 	}
     }
 
@@ -1882,7 +1882,7 @@ DbeExtensionInit()
 
 	    for (j = 0; j < i; j++)
 	    {
-	      xfree(screenInfo.screens[j]->devPrivates[dbeScreenPrivIndex].ptr);
+	      free(screenInfo.screens[j]->devPrivates[dbeScreenPrivIndex].ptr);
               screenInfo.screens[j]->devPrivates[dbeScreenPrivIndex].ptr = NULL;
 	    }
 	    return;
@@ -1986,7 +1986,7 @@ DbeExtensionInit()
 
         for (i = 0; i < screenInfo.numScreens; i++)
         {
-             xfree(screenInfo.screens[i]->devPrivates[dbeScreenPrivIndex].ptr);
+             free(screenInfo.screens[i]->devPrivates[dbeScreenPrivIndex].ptr);
              pScreen->devPrivates[dbeScreenPrivIndex].ptr = NULL;
         }
         return;
diff --git a/nx-X11/programs/Xserver/dix/atom.c b/nx-X11/programs/Xserver/dix/atom.c
index 29e60be03..fdb1c18a2 100644
--- a/nx-X11/programs/Xserver/dix/atom.c
+++ b/nx-X11/programs/Xserver/dix/atom.c
@@ -120,7 +120,7 @@ MakeAtom(const char *string, unsigned len, Bool makeit)
 	{
 	    nd->string = (char *) xalloc(len + 1);
 	    if (!nd->string) {
-		xfree(nd);
+		free(nd);
 		return BAD_RESOURCE;
 	    }
 	    strncpy(nd->string, string, (int)len);
@@ -133,8 +133,8 @@ MakeAtom(const char *string, unsigned len, Bool makeit)
 					 tableLength * (2 * sizeof(NodePtr)));
 	    if (!table) {
 		if (nd->string != string)
-		    xfree(nd->string);
-		xfree(nd);
+		    free(nd->string);
+		free(nd);
 		return BAD_RESOURCE;
 	    }
 	    tableLength <<= 1;
@@ -180,8 +180,8 @@ FreeAtom(NodePtr patom)
     if(patom->right)
 	FreeAtom(patom->right);
     if (patom->a > XA_LAST_PREDEFINED)
-	xfree(patom->string);
-    xfree(patom);
+	free(patom->string);
+    free(patom);
 }
 
 void
@@ -191,7 +191,7 @@ FreeAllAtoms()
 	return;
     FreeAtom(atomRoot);
     atomRoot = (NodePtr)NULL;
-    xfree(nodeTable);
+    free(nodeTable);
     nodeTable = (NodePtr *)NULL;
     lastAtom = None;
 }
diff --git a/nx-X11/programs/Xserver/dix/colormap.c b/nx-X11/programs/Xserver/dix/colormap.c
index 4acfdc1bb..39da0abd4 100644
--- a/nx-X11/programs/Xserver/dix/colormap.c
+++ b/nx-X11/programs/Xserver/dix/colormap.c
@@ -306,7 +306,7 @@ CreateColormap (Colormap mid, ScreenPtr pScreen, VisualPtr pVisual,
 	ppix = (Pixel *)xalloc(size * sizeof(Pixel));
 	if (!ppix)
 	{
-	    xfree(pmap);
+	    free(pmap);
 	    return (BadAlloc);
 	}
 	pmap->clientPixelsRed[client] = ppix;
@@ -352,8 +352,8 @@ CreateColormap (Colormap mid, ScreenPtr pScreen, VisualPtr pVisual,
 	    ppix = (Pixel *) xalloc(size * sizeof(Pixel));
 	    if (!ppix)
 	    {
-		xfree(pmap->clientPixelsRed[client]);
-		xfree(pmap);
+		free(pmap->clientPixelsRed[client]);
+		free(pmap);
 		return(BadAlloc);
 	    }
 	    pmap->clientPixelsGreen[client] = ppix;
@@ -368,9 +368,9 @@ CreateColormap (Colormap mid, ScreenPtr pScreen, VisualPtr pVisual,
 	    ppix = (Pixel *) xalloc(size * sizeof(Pixel));
 	    if (!ppix)
 	    {
-		xfree(pmap->clientPixelsGreen[client]);
-		xfree(pmap->clientPixelsRed[client]);
-		xfree(pmap);
+		free(pmap->clientPixelsGreen[client]);
+		free(pmap->clientPixelsRed[client]);
+		free(pmap);
 		return(BadAlloc);
 	    }
 	    pmap->clientPixelsBlue[client] = ppix;
@@ -438,7 +438,7 @@ FreeColormap (void * value, XID mid)
     if(pmap->clientPixelsRed)
     {
 	for(i = 0; i < MAXCLIENTS; i++)
-	    xfree(pmap->clientPixelsRed[i]);
+	    free(pmap->clientPixelsRed[i]);
     }
 
     if ((pmap->class == PseudoColor) || (pmap->class == GrayScale))
@@ -450,11 +450,11 @@ FreeColormap (void * value, XID mid)
 	    if(pent->fShared)
 	    {
 		if (--pent->co.shco.red->refcnt == 0)
-		    xfree(pent->co.shco.red);
+		    free(pent->co.shco.red);
 		if (--pent->co.shco.green->refcnt == 0)
-		    xfree(pent->co.shco.green);
+		    free(pent->co.shco.green);
 		if (--pent->co.shco.blue->refcnt == 0)
-		    xfree(pent->co.shco.blue);
+		    free(pent->co.shco.blue);
 	    }
 	}
     }
@@ -462,15 +462,15 @@ FreeColormap (void * value, XID mid)
     {
         for(i = 0; i < MAXCLIENTS; i++)
 	{
-            xfree(pmap->clientPixelsGreen[i]);
-            xfree(pmap->clientPixelsBlue[i]);
+            free(pmap->clientPixelsGreen[i]);
+            free(pmap->clientPixelsBlue[i]);
         }
     }
 
     if (pmap->devPrivates)
-	xfree(pmap->devPrivates);
+	free(pmap->devPrivates);
 
-    xfree(pmap);
+    free(pmap);
     return(Success);
 }
 
@@ -721,11 +721,11 @@ FreeCell (ColormapPtr pmap, Pixel i, int channel)
         if (pent->fShared)
 	{
 	    if(--pent->co.shco.red->refcnt == 0)
-		xfree(pent->co.shco.red);
+		free(pent->co.shco.red);
 	    if(--pent->co.shco.green->refcnt == 0)
-		xfree(pent->co.shco.green);
+		free(pent->co.shco.green);
 	    if(--pent->co.shco.blue->refcnt == 0)
-		xfree(pent->co.shco.blue);
+		free(pent->co.shco.blue);
 	    pent->fShared = FALSE;
 	}
 	pent->refcnt = 0;
@@ -1518,7 +1518,7 @@ FreePixels(register ColormapPtr pmap, register int client)
 	}
     }
 
-    xfree(ppixStart);
+    free(ppixStart);
     pmap->clientPixelsRed[client] = (Pixel *) NULL;
     pmap->numPixelsRed[client] = 0;
     if ((class | DynamicClass) == DirectColor) 
@@ -1527,7 +1527,7 @@ FreePixels(register ColormapPtr pmap, register int client)
 	if (class & DynamicClass)
 	    for (ppix = ppixStart, n = pmap->numPixelsGreen[client]; --n >= 0;)
 		FreeCell(pmap, *ppix++, GREENMAP);
-	xfree(ppixStart);
+	free(ppixStart);
 	pmap->clientPixelsGreen[client] = (Pixel *) NULL;
 	pmap->numPixelsGreen[client] = 0;
 
@@ -1535,7 +1535,7 @@ FreePixels(register ColormapPtr pmap, register int client)
 	if (class & DynamicClass)
 	    for (ppix = ppixStart, n = pmap->numPixelsBlue[client]; --n >= 0; )
 		FreeCell(pmap, *ppix++, BLUEMAP);
-	xfree(ppixStart);
+	free(ppixStart);
 	pmap->clientPixelsBlue[client] = (Pixel *) NULL;
 	pmap->numPixelsBlue[client] = 0;
     }
@@ -1556,7 +1556,7 @@ FreeClientPixels (void * value, XID fakeid)
     pmap = (ColormapPtr) LookupIDByType(pcr->mid, RT_COLORMAP);
     if (pmap)
 	FreePixels(pmap, pcr->client);
-    xfree(pcr);
+    free(pcr);
     return Success;
 }
 
@@ -1626,7 +1626,7 @@ AllocColorCells (int client, ColormapPtr pmap, int colors, int planes,
 	if (!AddResource(FakeClientID(client), RT_CMAPENTRY, (void *)pcr))
 	    ok = BadAlloc;
     } else if (pcr)
-	xfree(pcr);
+	free(pcr);
 
     return (ok);
 }
@@ -1717,7 +1717,7 @@ AllocColorPlanes (int client, ColormapPtr pmap, int colors,
 	if (!AddResource(FakeClientID(client), RT_CMAPENTRY, (void *)pcr))
 	    ok = BadAlloc;
     } else if (pcr)
-	xfree(pcr);
+	free(pcr);
 
     return (ok);
 }
@@ -2092,7 +2092,7 @@ AllocShared (ColormapPtr pmap, Pixel *ppix, int c, int r, int g, int b,
 	if (!(ppshared[z] = (SHAREDCOLOR *)xalloc(sizeof(SHAREDCOLOR))))
 	{
 	    for (z++ ; z < npixShared; z++)
-		xfree(ppshared[z]);
+		free(ppshared[z]);
 	    return FALSE;
 	}
     }
@@ -2372,7 +2372,7 @@ FreeCo (ColormapPtr pmap, int client, int color, int npixIn, Pixel *ppixIn, Pixe
 	else
 	{
 	    npixClient = 0;
-	    xfree(ppixClient);
+	    free(ppixClient);
     	    ppixClient = (Pixel *)NULL;
 	}
 	switch(color)
diff --git a/nx-X11/programs/Xserver/dix/cursor.c b/nx-X11/programs/Xserver/dix/cursor.c
index 1e1dba36b..575ff1eb4 100644
--- a/nx-X11/programs/Xserver/dix/cursor.c
+++ b/nx-X11/programs/Xserver/dix/cursor.c
@@ -81,10 +81,10 @@ FreeCursorBits(CursorBitsPtr bits)
 {
     if (--bits->refcnt > 0)
 	return;
-    xfree(bits->source);
-    xfree(bits->mask);
+    free(bits->source);
+    free(bits->mask);
 #ifdef ARGB_CURSOR
-    xfree(bits->argb);
+    free(bits->argb);
 #endif
     if (bits->refcnt == 0)
     {
@@ -98,9 +98,9 @@ FreeCursorBits(CursorBitsPtr bits)
 	{
 	    *prev = this->next;
 	    CloseFont(this->font, (Font)0);
-	    xfree(this);
+	    free(this);
 	}
-	xfree(bits);
+	free(bits);
     }
 }
 
@@ -126,7 +126,7 @@ FreeCursor(void * value, XID cid)
 	(void)( *pscr->UnrealizeCursor)( pscr, pCurs);
     }
     FreeCursorBits(pCurs->bits);
-    xfree( pCurs);
+    free( pCurs);
     return(Success);
 }
 
@@ -177,8 +177,8 @@ AllocCursorARGB(unsigned char *psrcbits, unsigned char *pmaskbits, CARD32 *argb,
     pCurs = (CursorPtr)xalloc(sizeof(CursorRec) + sizeof(CursorBits));
     if (!pCurs)
     {
-	xfree(psrcbits);
-	xfree(pmaskbits);
+	free(psrcbits);
+	free(pmaskbits);
 	return (CursorPtr)NULL;
     }
     bits = (CursorBitsPtr)((char *)pCurs + sizeof(CursorRec));
@@ -223,7 +223,7 @@ AllocCursorARGB(unsigned char *psrcbits, unsigned char *pmaskbits, CARD32 *argb,
 		( *pscr->UnrealizeCursor)( pscr, pCurs);
 	    }
 	    FreeCursorBits(bits);
-	    xfree(pCurs);
+	    free(pCurs);
 	    return (CursorPtr)NULL;
 	}
     }
@@ -329,7 +329,7 @@ AllocGlyphCursor(Font source, unsigned sourceChar, Font mask, unsigned maskChar,
 	}
 	if ((res = ServerBitsFromGlyph(sourcefont, sourceChar, &cm, &srcbits)) != 0)
 	{
-	    xfree(mskbits);
+	    free(mskbits);
 	    return res;
 	}
 	if (sourcefont != maskfont)
@@ -350,9 +350,9 @@ AllocGlyphCursor(Font source, unsigned sourceChar, Font mask, unsigned maskChar,
 	}
 	if (!bits)
 	{
-	    xfree(pCurs);
-	    xfree(mskbits);
-	    xfree(srcbits);
+	    free(pCurs);
+	    free(mskbits);
+	    free(srcbits);
 	    return BadAlloc;
 	}
 	bits->source = srcbits;
@@ -414,7 +414,7 @@ AllocGlyphCursor(Font source, unsigned sourceChar, Font mask, unsigned maskChar,
 		( *pscr->UnrealizeCursor)( pscr, pCurs);
 	    }
 	    FreeCursorBits(pCurs->bits);
-	    xfree(pCurs);
+	    free(pCurs);
 	    return BadAlloc;
 	}
     }
diff --git a/nx-X11/programs/Xserver/dix/devices.c b/nx-X11/programs/Xserver/dix/devices.c
index 49ab80529..314714152 100644
--- a/nx-X11/programs/Xserver/dix/devices.c
+++ b/nx-X11/programs/Xserver/dix/devices.c
@@ -208,29 +208,29 @@ CloseDevice(register DeviceIntPtr dev)
 
     if (dev->inited)
 	(void)(*dev->deviceProc)(dev, DEVICE_CLOSE);
-    xfree(dev->name);
+    free(dev->name);
     if (dev->key)
     {
 #ifdef XKB
 	if (dev->key->xkbInfo)
 	    XkbFreeInfo(dev->key->xkbInfo);
 #endif
-	xfree(dev->key->curKeySyms.map);
-	xfree(dev->key->modifierKeyMap);
-	xfree(dev->key);
+	free(dev->key->curKeySyms.map);
+	free(dev->key->modifierKeyMap);
+	free(dev->key);
     }
-    xfree(dev->valuator);
+    free(dev->valuator);
 #ifdef XKB
     if ((dev->button)&&(dev->button->xkb_acts))
-	xfree(dev->button->xkb_acts);
+	free(dev->button->xkb_acts);
 #endif
-    xfree(dev->button);
+    free(dev->button);
     if (dev->focus)
     {
-	xfree(dev->focus->trace);
-	xfree(dev->focus);
+	free(dev->focus->trace);
+	free(dev->focus);
     }
-    xfree(dev->proximity);
+    free(dev->proximity);
     for (k=dev->kbdfeed; k; k=knext)
     {
 	knext = k->next;
@@ -238,29 +238,29 @@ CloseDevice(register DeviceIntPtr dev)
 	if (k->xkb_sli)
 	    XkbFreeSrvLedInfo(k->xkb_sli);
 #endif
-	xfree(k);
+	free(k);
     }
     for (p=dev->ptrfeed; p; p=pnext)
     {
 	pnext = p->next;
-	xfree(p);
+	free(p);
     }
     for (i=dev->intfeed; i; i=inext)
     {
 	inext = i->next;
-	xfree(i);
+	free(i);
     }
     for (s=dev->stringfeed; s; s=snext)
     {
 	snext = s->next;
-	xfree(s->ctrl.symbols_supported);
-	xfree(s->ctrl.symbols_displayed);
-	xfree(s);
+	free(s->ctrl.symbols_supported);
+	free(s->ctrl.symbols_displayed);
+	free(s);
     }
     for (b=dev->bell; b; b=bnext)
     {
 	bnext = b->next;
-	xfree(b);
+	free(b);
     }
     for (l=dev->leds; l; l=lnext)
     {
@@ -269,15 +269,15 @@ CloseDevice(register DeviceIntPtr dev)
 	if (l->xkb_sli)
 	    XkbFreeSrvLedInfo(l->xkb_sli);
 #endif
-	xfree(l);
+	free(l);
     }
 #ifdef XKB
     while (dev->xkb_interest) {
 	XkbRemoveResourceClient((DevicePtr)dev,dev->xkb_interest->resource);
     }
 #endif
-    xfree(dev->sync.event);
-    xfree(dev);
+    free(dev->sync.event);
+    free(dev);
 }
 
 void
@@ -471,7 +471,7 @@ SetKeySymsMap(register KeySymsPtr dst, register KeySymsPtr src)
 		memmove((char *)&map[i*src->mapWidth],
 			(char *)&dst->map[i*dst->mapWidth],
 		      dst->mapWidth * sizeof(KeySym));
-	    xfree(dst->map);
+	    free(dst->map);
 	}
 	dst->mapWidth = src->mapWidth;
 	dst->map = map;
@@ -550,9 +550,9 @@ InitKeyClassDeviceStruct(DeviceIntPtr dev, KeySymsPtr pKeySyms, CARD8 pModifiers
 	keyc->modifierKeyCount[i] = 0;
     if (!SetKeySymsMap(&keyc->curKeySyms, pKeySyms) || !InitModMap(keyc))
     {
-	xfree(keyc->curKeySyms.map);
-	xfree(keyc->modifierKeyMap);
-	xfree(keyc);
+	free(keyc->curKeySyms.map);
+	free(keyc->modifierKeyMap);
+	free(keyc);
 	return FALSE;
     }
     dev->key = keyc;
@@ -722,10 +722,10 @@ InitStringFeedbackClassDeviceStruct (
     if (!feedc->ctrl.symbols_supported || !feedc->ctrl.symbols_displayed)
     {
 	if (feedc->ctrl.symbols_supported)
-	    xfree(feedc->ctrl.symbols_supported);
+	    free(feedc->ctrl.symbols_supported);
 	if (feedc->ctrl.symbols_displayed)
-	    xfree(feedc->ctrl.symbols_displayed);
-	xfree(feedc);
+	    free(feedc->ctrl.symbols_displayed);
+	free(feedc);
 	return FALSE;
     }
     for (i=0; i<num_symbols_supported; i++)
@@ -1001,7 +1001,7 @@ ProcSetModifierMapping(ClientPtr client)
 	if (!map && inputMapLen)
 	    return BadAlloc;
 	if (keyc->modifierKeyMap)
-	    xfree(keyc->modifierKeyMap);
+	    free(keyc->modifierKeyMap);
 	keyc->modifierKeyMap = map;
 	memmove((char *)map, (char *)inputMap, inputMapLen);
 
diff --git a/nx-X11/programs/Xserver/dix/dispatch.c b/nx-X11/programs/Xserver/dix/dispatch.c
index 803870369..9b9021d62 100644
--- a/nx-X11/programs/Xserver/dix/dispatch.c
+++ b/nx-X11/programs/Xserver/dix/dispatch.c
@@ -214,7 +214,7 @@ void
 InitSelections()
 {
     if (CurrentSelections)
-	xfree(CurrentSelections);
+	free(CurrentSelections);
     CurrentSelections = (Selection *)NULL;
     NumCurrentSelections = 0;
 }
@@ -3090,7 +3090,7 @@ ProcCreateCursor (register ClientPtr client)
     mskbits = (unsigned char *)xalloc(n);
     if (!mskbits)
     {
-	xfree(srcbits);
+	free(srcbits);
 	return (BadAlloc);
     }
 
@@ -3332,7 +3332,7 @@ ProcListHosts(register ClientPtr client)
 	client->pSwapReplyFunc = (ReplySwapPtr) SLHostsExtend;
 	WriteSwappedDataToClient(client, len, pdata);
     }
-    xfree(pdata);
+    free(pdata);
     return (client->noClientException);
 }
 
@@ -3600,7 +3600,7 @@ CloseDownClient(register ClientPtr client)
 #ifdef SMART_SCHEDULE
 	SmartLastClient = NullClient;
 #endif
-	xfree(client);
+	free(client);
 
 	while (!clients[currentMaxClients-1])
 	    currentMaxClients--;
@@ -3760,7 +3760,7 @@ ClientPtr NextAvailableClient(void * ospriv)
     InitClientPrivates(client);
     if (!InitClientResources(client))
     {
-	xfree(client);
+	free(client);
 	return (ClientPtr)NULL;
     }
     data.reqType = 1;
@@ -3768,7 +3768,7 @@ ClientPtr NextAvailableClient(void * ospriv)
     if (!InsertFakeRequest(client, (char *)&data, sz_xReq))
     {
 	FreeClientResources(client);
-	xfree(client);
+	free(client);
 	return (ClientPtr)NULL;
     }
     if (i == currentMaxClients)
diff --git a/nx-X11/programs/Xserver/dix/dixfonts.c b/nx-X11/programs/Xserver/dix/dixfonts.c
index 58e562411..1a0352387 100644
--- a/nx-X11/programs/Xserver/dix/dixfonts.c
+++ b/nx-X11/programs/Xserver/dix/dixfonts.c
@@ -226,8 +226,8 @@ FreeFPE (FontPathElementPtr fpe)
     fpe->refcount--;
     if (fpe->refcount == 0) {
 	(*fpe_functions[fpe->type].free_fpe) (fpe);
-	xfree(fpe->name);
-	xfree(fpe);
+	free(fpe->name);
+	free(fpe);
     }
 }
 
@@ -377,9 +377,9 @@ bail:
     for (i = 0; i < c->num_fpes; i++) {
 	FreeFPE(c->fpe_list[i]);
     }
-    xfree(c->fpe_list);
-    xfree(c->fontname);
-    xfree(c);
+    free(c->fpe_list);
+    free(c->fontname);
+    free(c);
     return TRUE;
 }
 #endif /* NXAGENT_SERVER */
@@ -397,7 +397,7 @@ OpenFont(ClientPtr client, XID fid, Mask flags, unsigned lenfname, char *pfontna
     memmove(f, pfontname, lenfname);
     f[lenfname] = '\0';
     ErrorF("OpenFont: fontname is \"%s\"\n", f);
-    xfree(f);
+    free(f);
 #endif
     if (!lenfname || lenfname > XLFDMAXFONTNAMELEN)
 	return BadName;
@@ -437,7 +437,7 @@ OpenFont(ClientPtr client, XID fid, Mask flags, unsigned lenfname, char *pfontna
     c->origFontName = pfontname;
     c->origFontNameLen = lenfname;
     if (!c->fontname) {
-	xfree(c);
+	free(c);
 	return BadAlloc;
     }
     /*
@@ -447,8 +447,8 @@ OpenFont(ClientPtr client, XID fid, Mask flags, unsigned lenfname, char *pfontna
     c->fpe_list = (FontPathElementPtr *)
 	xalloc(sizeof(FontPathElementPtr) * num_fpes);
     if (!c->fpe_list) {
-	xfree(c->fontname);
-	xfree(c);
+	free(c->fontname);
+	free(c);
 	return BadAlloc;
     }
     memmove(c->fontname, pfontname, lenfname);
@@ -679,7 +679,7 @@ doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
 		    return TRUE;
 		}
 		if (err == FontNameAlias) {
-		    if (resolved) xfree(resolved);
+		    if (resolved) free(resolved);
 		    resolved = (char *) xalloc(resolvedlen + 1);
 		    if (resolved)
 			memmove(resolved, tmpname, resolvedlen + 1);
@@ -734,7 +734,7 @@ doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
 		    c->saved = c->current;
 		    c->haveSaved = TRUE;
 		    if (c->savedName)
-			xfree(c->savedName);
+			free(c->savedName);
 		    c->savedName = (char *)xalloc(namelen + 1);
 		    if (c->savedName)
 			memmove(c->savedName, name, namelen + 1);
@@ -829,11 +829,11 @@ bail:
 	ClientWakeup(client);
     for (i = 0; i < c->num_fpes; i++)
 	FreeFPE(c->fpe_list[i]);
-    xfree(c->fpe_list);
-    if (c->savedName) xfree(c->savedName);
+    free(c->fpe_list);
+    if (c->savedName) free(c->savedName);
     FreeFontNames(names);
-    xfree(c);
-    if (resolved) xfree(resolved);
+    free(c);
+    if (resolved) free(resolved);
     return TRUE;
 }
 
@@ -858,14 +858,14 @@ ListFonts(ClientPtr client, unsigned char *pattern, unsigned length,
     c->fpe_list = (FontPathElementPtr *)
 	xalloc(sizeof(FontPathElementPtr) * num_fpes);
     if (!c->fpe_list) {
-	xfree(c);
+	free(c);
 	return BadAlloc;
     }
     c->names = MakeFontNamesRecord(max_names < 100 ? max_names : 100);
     if (!c->names)
     {
-	xfree(c->fpe_list);
-	xfree(c);
+	free(c->fpe_list);
+	free(c);
 	return BadAlloc;
     }
     memmove( c->current.pattern, pattern, length);
@@ -994,7 +994,7 @@ doListFontsWithInfo(ClientPtr client, LFWIclosurePtr c)
 		c->haveSaved = TRUE;
 		c->savedNumFonts = numFonts;
 		if (c->savedName)
-		  xfree(c->savedName);
+		  free(c->savedName);
 		c->savedName = (char *)xalloc(namelen + 1);
 		if (c->savedName)
 		  memmove(c->savedName, name, namelen + 1);
@@ -1084,8 +1084,8 @@ doListFontsWithInfo(ClientPtr client, LFWIclosurePtr c)
 	    (void) WriteToClient(client, namelen, name);
 	    if (pFontInfo == &fontInfo)
  	    {
-		xfree(fontInfo.props);
-		xfree(fontInfo.isStringProp);
+		free(fontInfo.props);
+		free(fontInfo.isStringProp);
 	    }
 	    --c->current.max_names;
 	}
@@ -1103,10 +1103,10 @@ bail:
 	ClientWakeup(client);
     for (i = 0; i < c->num_fpes; i++)
 	FreeFPE(c->fpe_list[i]);
-    xfree(c->reply);
-    xfree(c->fpe_list);
-    if (c->savedName) xfree(c->savedName);
-    xfree(c);
+    free(c->reply);
+    free(c->fpe_list);
+    if (c->savedName) free(c->savedName);
+    free(c);
     return TRUE;
 }
 #endif /* NXAGENT_SERVER */
@@ -1133,7 +1133,7 @@ StartListFontsWithInfo(ClientPtr client, int length, unsigned char *pattern,
 	xalloc(sizeof(FontPathElementPtr) * num_fpes);
     if (!c->fpe_list)
     {
-	xfree(c);
+	free(c);
 	goto badAlloc;
     }
     memmove(c->current.pattern, pattern, length);
@@ -1330,7 +1330,7 @@ doPolyText(ClientPtr client, register PTclosurePtr c)
 		    c->data = (unsigned char *)xalloc(len);
 		    if (!c->data)
 		    {
-			xfree(c);
+			free(c);
 			err = BadAlloc;
 			goto bail;
 		    }
@@ -1343,8 +1343,8 @@ doPolyText(ClientPtr client, register PTclosurePtr c)
 		    pGC = GetScratchGC(c->pGC->depth, c->pGC->pScreen);
 		    if (!pGC)
 		    {
-			xfree(c->data);
-			xfree(c);
+			free(c->data);
+			free(c);
 			err = BadAlloc;
 			goto bail;
 		    }
@@ -1366,8 +1366,8 @@ doPolyText(ClientPtr client, register PTclosurePtr c)
 				      Success)
 		    {
 			FreeScratchGC(pGC);
-			xfree(c->data);
-			xfree(c);
+			free(c->data);
+			free(c);
 			err = BadAlloc;
 			goto bail;
 		    }
@@ -1434,8 +1434,8 @@ bail:
 	c->pGC->font = NullFont;
 
 	FreeScratchGC(c->pGC);
-	xfree(c->data);
-	xfree(c);
+	free(c->data);
+	free(c);
     }
     return TRUE;
 }
@@ -1530,7 +1530,7 @@ doImageText(ClientPtr client, register ITclosurePtr c)
 	    data = (unsigned char *)xalloc(c->nChars * c->itemSize);
 	    if (!data)
 	    {
-		xfree(c);
+		free(c);
 		c = old_closure;
 		err = BadAlloc;
 		goto bail;
@@ -1541,8 +1541,8 @@ doImageText(ClientPtr client, register ITclosurePtr c)
 	    pGC = GetScratchGC(c->pGC->depth, c->pGC->pScreen);
 	    if (!pGC)
 	    {
-		xfree(c->data);
-		xfree(c);
+		free(c->data);
+		free(c);
 		c = old_closure;
 		err = BadAlloc;
 		goto bail;
@@ -1562,8 +1562,8 @@ doImageText(ClientPtr client, register ITclosurePtr c)
 			      GCClipYOrigin | GCClipMask)) != Success)
 	    {
 		FreeScratchGC(pGC);
-		xfree(c->data);
-		xfree(c);
+		free(c->data);
+		free(c);
 		c = old_closure;
 		err = BadAlloc;
 		goto bail;
@@ -1602,8 +1602,8 @@ bail:
 	c->pGC->font = NullFont;
 
 	FreeScratchGC(c->pGC);
-	xfree(c->data);
-	xfree(c);
+	free(c->data);
+	free(c);
     }
     return TRUE;
 }
@@ -1677,7 +1677,7 @@ FreeFontPath(FontPathElementPtr *list, int n, Bool force)
 	}
 	FreeFPE(list[i]);
     }
-    xfree((char *) list);
+    free((char *) list);
 }
 
 static FontPathElementPtr
@@ -1754,7 +1754,7 @@ SetFontPathElements(int npaths, unsigned char *paths, int *bad, Bool persist)
 		fpe->name = (char *) xalloc(len + 1);
 		if (!fpe->name) 
 		{
-		    xfree(fpe);
+		    free(fpe);
 		    err = BadAlloc;
 		    goto bail;
 		}
@@ -1777,8 +1777,8 @@ SetFontPathElements(int npaths, unsigned char *paths, int *bad, Bool persist)
 			       fpe->name);
 		    }
 #endif /* NXAGENT_SERVER */
-		    xfree (fpe->name);
-		    xfree (fpe);
+		    free (fpe->name);
+		    free (fpe);
 		}
 	    }
 	}
@@ -1805,7 +1805,7 @@ bail:
     *bad = i;
     while (--valid_paths >= 0)
 	FreeFPE(fplist[valid_paths]);
-    xfree(fplist);
+    free(fplist);
     return FontToXError(err);
 }
 
@@ -2037,7 +2037,7 @@ FreeFonts()
     FreeFontPath(font_path_elements, num_fpes, TRUE);
     font_path_elements = 0;
     num_fpes = 0;
-    xfree(fpe_functions);
+    free(fpe_functions);
     num_fpe_types = 0;
     fpe_functions = (FPEFunctions *) 0;
 }
diff --git a/nx-X11/programs/Xserver/dix/dixutils.c b/nx-X11/programs/Xserver/dix/dixutils.c
index e91303851..1c6305684 100644
--- a/nx-X11/programs/Xserver/dix/dixutils.c
+++ b/nx-X11/programs/Xserver/dix/dixutils.c
@@ -377,7 +377,7 @@ AlterSaveSetForClient(ClientPtr client, WindowPtr pWin, unsigned mode,
 	}
         else
         {
-            xfree(client->saveSet);
+            free(client->saveSet);
 	    client->saveSet = (SaveSetElt *)NULL;
 	}
 	client->numSaved = numnow;
@@ -549,7 +549,7 @@ RemoveBlockAndWakeupHandlers (BlockHandlerProcPtr blockHandler,
 void
 InitBlockAndWakeupHandlers ()
 {
-    xfree (handlers);
+    free (handlers);
     handlers = (BlockHandlerPtr) 0;
     numHandlers = 0;
     sizeHandlers = 0;
@@ -581,7 +581,7 @@ ProcessWorkQueue(void)
 	{
 	    /* remove q from the list */
 	    *p = q->next;    /* don't fetch until after func called */
-	    xfree (q);
+	    free (q);
 	}
 	else
 	{
@@ -604,7 +604,7 @@ ProcessWorkQueueZombies(void)
 	    (void) (*q->function) (q->client, q->closure);
 	    /* remove q from the list */
 	    *p = q->next;    /* don't fetch until after func called */
-	    xfree (q);
+	    free (q);
 	}
 	else
 	{
@@ -692,7 +692,7 @@ ClientWakeup (ClientPtr client)
 	if (q->client == client)
 	{
 	    *prev = q->next;
-	    xfree (q);
+	    free (q);
 	    if (client->clientGone)
 		/* Oops -- new zombie cleanup code ensures this only
 		 * happens from inside CloseDownClient; don't want to
@@ -775,7 +775,7 @@ _DeleteCallback(
 		cbl->list = cbr->next;
 	    else
 		pcbr->next = cbr->next;
-	    xfree(cbr);
+	    free(cbr);
 	}
 	return TRUE;
     }
@@ -820,12 +820,12 @@ _CallCallbacks(
 		if (pcbr)
 		{
 		    cbr = cbr->next;
-		    xfree(pcbr->next);
+		    free(pcbr->next);
 		    pcbr->next = cbr;
 		} else
 		{
 		    cbr = cbr->next;
-		    xfree(cbl->list);
+		    free(cbl->list);
 		    cbl->list = cbr;
 		}
 		cbl->numDeleted--;
@@ -865,9 +865,9 @@ _DeleteCallbackList(
     for (cbr = cbl->list; cbr != NULL; cbr = nextcbr)
     {
 	nextcbr = cbr->next;
-	xfree(cbr);
+	free(cbr);
     }
-    xfree(cbl);
+    free(cbl);
     *pcbl = NULL;
 }
 
@@ -955,7 +955,7 @@ InitCallbackManager()
     {
 	DeleteCallbackList(listsToCleanup[i]);
     }
-    if (listsToCleanup) xfree(listsToCleanup);
+    if (listsToCleanup) free(listsToCleanup);
 
     numCallbackListsToCleanup = 0;
     listsToCleanup = NULL;
diff --git a/nx-X11/programs/Xserver/dix/events.c b/nx-X11/programs/Xserver/dix/events.c
index 31b76e38f..ba0c5d847 100644
--- a/nx-X11/programs/Xserver/dix/events.c
+++ b/nx-X11/programs/Xserver/dix/events.c
@@ -1076,7 +1076,7 @@ PlayReleasedEvents(void)
 #endif
 	    (*qe->device->public.processInputProc)(qe->event, qe->device,
 						   qe->evcount);
-	    xfree(qe);
+	    free(qe);
 	    for (dev = inputInfo.devices; dev && dev->sync.frozen; dev = dev->next)
 		;
 	    if (!dev)
@@ -2959,7 +2959,7 @@ OtherClientGone(void * value, XID id)
 		if (!(pWin->optional->otherClients = other->next))
 		    CheckWindowOptionalNeed (pWin);
 	    }
-	    xfree(other);
+	    free(other);
 	    RecalculateDeliverableEvents(pWin);
 	    return(Success);
 	}
@@ -3948,7 +3948,7 @@ InitEvents()
     while (syncEvents.pending)
     {
 	QdEventPtr next = syncEvents.pending->next;
-	xfree(syncEvents.pending);
+	free(syncEvents.pending);
 	syncEvents.pending = next;
     }
     syncEvents.pendtail = &syncEvents.pending;
@@ -3968,7 +3968,7 @@ InitEvents()
 void
 CloseDownEvents(void)
 {
-  xfree(spriteTrace);
+  free(spriteTrace);
   spriteTrace = NULL;
   spriteTraceSize = 0;
 }
diff --git a/nx-X11/programs/Xserver/dix/extension.c b/nx-X11/programs/Xserver/dix/extension.c
index fe51f8916..4f06c0af4 100644
--- a/nx-X11/programs/Xserver/dix/extension.c
+++ b/nx-X11/programs/Xserver/dix/extension.c
@@ -103,7 +103,7 @@ AddExtension(char *name, int NumEvents, int NumErrors,
     ext->aliases = (char **)NULL;
     if (!ext->name)
     {
-	xfree(ext);
+	free(ext);
 	return((ExtensionEntry *) NULL);
     }
     strcpy(ext->name,  name);
@@ -112,8 +112,8 @@ AddExtension(char *name, int NumEvents, int NumErrors,
 					   (i + 1) * sizeof(ExtensionEntry *));
     if (!newexts)
     {
-	xfree(ext->name);
-	xfree(ext);
+	free(ext->name);
+	free(ext);
 	return((ExtensionEntry *) NULL);
     }
     NumExtensions++;
@@ -263,13 +263,13 @@ CloseDownExtensions()
 	if (extensions[i]->CloseDown)
 	    (* extensions[i]->CloseDown)(extensions[i]);
 	NumExtensions = i;
-	xfree(extensions[i]->name);
+	free(extensions[i]->name);
 	for (j = extensions[i]->num_aliases; --j >= 0;)
-	    xfree(extensions[i]->aliases[j]);
-	xfree(extensions[i]->aliases);
-	xfree(extensions[i]);
+	    free(extensions[i]->aliases[j]);
+	free(extensions[i]->aliases);
+	free(extensions[i]);
     }
-    xfree(extensions);
+    free(extensions);
     extensions = (ExtensionEntry **)NULL;
     lastEvent = EXTENSION_EVENT_BASE;
     lastError = FirstExtensionError;
@@ -280,9 +280,9 @@ CloseDownExtensions()
 	while (spentry->num)
 	{
 	    spentry->num--;
-	    xfree(spentry->procList[spentry->num].name);
+	    free(spentry->procList[spentry->num].name);
 	}
-	xfree(spentry->procList);
+	free(spentry->procList);
 	spentry->procList = (ProcEntryPtr)NULL;
     }
 }
@@ -446,7 +446,7 @@ RegisterScreenProc(char *name, ScreenPtr pScreen, ExtensionLookupProc proc)
 				     sizeof(ProcEntryRec) * (spentry->num+1));
 	if (!procEntry)
 	{
-	    xfree(newname);
+	    free(newname);
 	    return FALSE;
 	}
 	spentry->procList = procEntry;
diff --git a/nx-X11/programs/Xserver/dix/gc.c b/nx-X11/programs/Xserver/dix/gc.c
index 2c17de3d6..595d8ab74 100644
--- a/nx-X11/programs/Xserver/dix/gc.c
+++ b/nx-X11/programs/Xserver/dix/gc.c
@@ -457,7 +457,7 @@ dixChangeGC(ClientPtr client, register GC *pGC, register BITS32 mask, CARD32 *pC
 		{
 		    if (pGC->dash != DefaultDash)
 		    {
-			xfree(pGC->dash);
+			free(pGC->dash);
 			pGC->numInDashList = 2;
 			pGC->dash = DefaultDash;
 		    }
@@ -470,7 +470,7 @@ dixChangeGC(ClientPtr client, register GC *pGC, register BITS32 mask, CARD32 *pC
 		    if (dash)
 		    {
 			if (pGC->dash != DefaultDash)
-			    xfree(pGC->dash);
+			    free(pGC->dash);
 			pGC->numInDashList = 2;
 			pGC->dash = dash;
 			dash[0] = newdash;
@@ -838,7 +838,7 @@ CopyGC(register GC *pgcSrc, register GC *pgcDst, register BITS32 mask)
 		{
 		    if (pgcDst->dash != DefaultDash)
 		    {
-			xfree(pgcDst->dash);
+			free(pgcDst->dash);
 			pgcDst->numInDashList = pgcSrc->numInDashList;
 			pgcDst->dash = pgcSrc->dash;
 		    }
@@ -853,7 +853,7 @@ CopyGC(register GC *pgcSrc, register GC *pgcDst, register BITS32 mask)
 		    if (dash)
 		    {
 			if (pgcDst->dash != DefaultDash)
-			    xfree(pgcDst->dash);
+			    free(pgcDst->dash);
 			pgcDst->numInDashList = pgcSrc->numInDashList;
 			pgcDst->dash = dash;
 			for (i=0; i<pgcSrc->numInDashList; i++)
@@ -904,8 +904,8 @@ FreeGC(void * value, XID gid)
 
     (*pGC->funcs->DestroyGC) (pGC);
     if (pGC->dash != DefaultDash)
-	xfree(pGC->dash);
-    xfree(pGC);
+	free(pGC->dash);
+    free(pGC);
     return(Success);
 }
 
@@ -1113,7 +1113,7 @@ SetDashes(register GCPtr pGC, unsigned offset, unsigned ndash, unsigned char *pd
     }
 
     if (pGC->dash != DefaultDash)
-	xfree(pGC->dash);
+	free(pGC->dash);
     pGC->numInDashList = ndash;
     pGC->dash = p;
     if (ndash & 1)
diff --git a/nx-X11/programs/Xserver/dix/glyphcurs.c b/nx-X11/programs/Xserver/dix/glyphcurs.c
index f715a327f..c8b71db4e 100644
--- a/nx-X11/programs/Xserver/dix/glyphcurs.c
+++ b/nx-X11/programs/Xserver/dix/glyphcurs.c
@@ -108,7 +108,7 @@ ServerBitsFromGlyph(FontPtr pfont, unsigned ch, register CursorMetricPtr cm, uns
 	    (*pScreen->DestroyPixmap)(ppix);
 	if (pGC)
 	    FreeScratchGC(pGC);
-	xfree(pbits);
+	free(pbits);
 	return BadAlloc;
     }
 
diff --git a/nx-X11/programs/Xserver/dix/grabs.c b/nx-X11/programs/Xserver/dix/grabs.c
index 839e930b1..7fd9ad096 100644
--- a/nx-X11/programs/Xserver/dix/grabs.c
+++ b/nx-X11/programs/Xserver/dix/grabs.c
@@ -116,15 +116,15 @@ static void
 FreeGrab(GrabPtr pGrab)
 {
     if (pGrab->modifiersDetail.pMask != NULL)
-	xfree(pGrab->modifiersDetail.pMask);
+	free(pGrab->modifiersDetail.pMask);
 
     if (pGrab->detail.pMask != NULL)
-	xfree(pGrab->detail.pMask);
+	free(pGrab->detail.pMask);
 
     if (pGrab->cursor)
 	FreeCursor(pGrab->cursor, (Cursor)0);
 
-    xfree(pGrab);
+    free(pGrab);
 }
 
 int
@@ -410,7 +410,7 @@ DeletePassiveGrabFromList(GrabPtr pMinuendGrab)
 	for (i = 0; i < nadds; i++)
 	    FreeResource(adds[i]->resource, RT_NONE);
 	for (i = 0; i < nups; i++)
-	    xfree(details[i]);
+	    free(details[i]);
     }
     else
     {
@@ -424,7 +424,7 @@ DeletePassiveGrabFromList(GrabPtr pMinuendGrab)
 	}
 	for (i = 0; i < nups; i++)
 	{
-	    xfree(*updates[i]);
+	    free(*updates[i]);
 	    *updates[i] = details[i];
 	}
     }
diff --git a/nx-X11/programs/Xserver/dix/main.c b/nx-X11/programs/Xserver/dix/main.c
index 25fbb8b65..9d0197e3d 100644
--- a/nx-X11/programs/Xserver/dix/main.c
+++ b/nx-X11/programs/Xserver/dix/main.c
@@ -474,7 +474,7 @@ main(int argc, char *argv[], char *envp[])
 #endif
 	FreeAuditTimer();
 
-	xfree(serverClient->devPrivates);
+	free(serverClient->devPrivates);
 	serverClient->devPrivates = NULL;
 
 	if (dispatchException & DE_TERMINATE)
@@ -490,7 +490,7 @@ main(int argc, char *argv[], char *envp[])
 	    break;
 	}
 
-	xfree(ConnectionInfo);
+	free(ConnectionInfo);
 	ConnectionInfo = NULL;
     }
     return(0);
@@ -621,7 +621,7 @@ CreateConnectionBlock()
 	    pBuf = (char *)xrealloc(ConnectionInfo, lenofblock);
 	    if (!pBuf)
 	    {
-		xfree(ConnectionInfo);
+		free(ConnectionInfo);
 		return FALSE;
 	    }
 	    ConnectionInfo = pBuf;
@@ -697,7 +697,7 @@ AddScreen(
 						screenPrivateCount);
     if (!pScreen->devPrivates && screenPrivateCount)
     {
-	xfree(pScreen);
+	free(pScreen);
 	return -1;
     }
     pScreen->myNum = i;
@@ -782,11 +782,11 @@ static void
 FreeScreen(ScreenPtr pScreen)
 {
     pScreen->root = NullWindow;
-    xfree(pScreen->WindowPrivateSizes);
-    xfree(pScreen->GCPrivateSizes);
+    free(pScreen->WindowPrivateSizes);
+    free(pScreen->GCPrivateSizes);
 #ifdef PIXPRIV
-    xfree(pScreen->PixmapPrivateSizes);
+    free(pScreen->PixmapPrivateSizes);
 #endif
-    xfree(pScreen->devPrivates);
-    xfree(pScreen);
+    free(pScreen->devPrivates);
+    free(pScreen);
 }
diff --git a/nx-X11/programs/Xserver/dix/privates.c b/nx-X11/programs/Xserver/dix/privates.c
index d08883d1d..3455fb21c 100644
--- a/nx-X11/programs/Xserver/dix/privates.c
+++ b/nx-X11/programs/Xserver/dix/privates.c
@@ -66,7 +66,7 @@ ResetClientPrivates()
 {
     clientPrivateCount = 0;
     clientPrivateLen = 0;
-    xfree(clientPrivateSizes);
+    free(clientPrivateSizes);
     clientPrivateSizes = (unsigned *)NULL;
     totalClientSize =
 	((sizeof(ClientRec) + sizeof(long) - 1) / sizeof(long)) * sizeof(long);
diff --git a/nx-X11/programs/Xserver/dix/property.c b/nx-X11/programs/Xserver/dix/property.c
index b3b650dda..4476141e5 100644
--- a/nx-X11/programs/Xserver/dix/property.c
+++ b/nx-X11/programs/Xserver/dix/property.c
@@ -290,7 +290,7 @@ ChangeWindowProperty(WindowPtr pWin, Atom property, Atom type, int format,
         data = (void *)xalloc(totalSize);
 	if (!data && len)
 	{
-	    xfree(pProp);
+	    free(pProp);
 	    return(BadAlloc);
 	}
         pProp->propertyName = property;
@@ -353,7 +353,7 @@ ChangeWindowProperty(WindowPtr pWin, Atom property, Atom type, int format,
 	    memmove(&((char *)data)[totalSize], (char *)pProp->data, 
 		  (int)(pProp->size * sizeInBytes));
             memmove((char *)data, (char *)value, totalSize);
-	    xfree(pProp->data);
+	    free(pProp->data);
             pProp->data = data;
             pProp->size += len;
 	}
@@ -404,8 +404,8 @@ DeleteProperty(WindowPtr pWin, Atom propName)
         event.u.property.atom = pProp->propertyName;
 	event.u.property.time = currentTime.milliseconds;
 	DeliverEvents(pWin, &event, 1, (WindowPtr)NULL);
-	xfree(pProp->data);
-        xfree(pProp);
+	free(pProp->data);
+        free(pProp);
     }
     return(Success);
 }
@@ -426,8 +426,8 @@ DeleteAllWindowProperties(WindowPtr pWin)
 	event.u.property.time = currentTime.milliseconds;
 	DeliverEvents(pWin, &event, 1, (WindowPtr)NULL);
 	pNextProp = pProp->next;
-        xfree(pProp->data);
-        xfree(pProp);
+        free(pProp->data);
+        free(pProp);
 	pProp = pNextProp;
     }
 }
@@ -599,8 +599,8 @@ ProcGetProperty(ClientPtr client)
 	}
 	else
 	    prevProp->next = pProp->next;
-	xfree(pProp->data);
-	xfree(pProp);
+	free(pProp->data);
+	free(pProp);
     }
     return(client->noClientException);
 }
diff --git a/nx-X11/programs/Xserver/dix/region.c b/nx-X11/programs/Xserver/dix/region.c
index e927b9fde..4c2bc4695 100644
--- a/nx-X11/programs/Xserver/dix/region.c
+++ b/nx-X11/programs/Xserver/dix/region.c
@@ -172,7 +172,7 @@ Equipment Corporation.
         ((r1)->y1 <= (r2)->y1) && \
         ((r1)->y2 >= (r2)->y2) )
 
-#define xfreeData(reg) if ((reg)->data && (reg)->data->size) xfree((reg)->data)
+#define xfreeData(reg) if ((reg)->data && (reg)->data->size) free((reg)->data)
 
 #define RECTALLOC_BAIL(pReg,n,bail) \
 if (!(pReg)->data || (((pReg)->data->numRects + (n)) > (pReg)->data->size)) \
@@ -342,7 +342,7 @@ RegionDestroy(pReg)
     good(pReg);
     xfreeData(pReg);
     if (pReg != &RegionBrokenRegion)
-	xfree(pReg);
+	free(pReg);
 }
 
 Bool
@@ -795,7 +795,7 @@ RegionOp(
     }
 
     if (oldData)
-	xfree(oldData);
+	free(oldData);
 
     if (!(numRects = newReg->data->numRects))
     {
@@ -1355,13 +1355,13 @@ NextRect: ;
 	numRI -= half;
     }
     *badreg = ri[0].reg;
-    xfree(ri);
+    free(ri);
     good(badreg);
     return ret;
 bail:
     for (i = 0; i < numRI; i++)
 	xfreeData(&ri[i].reg);
-    xfree (ri);
+    free (ri);
     return RegionBreak (badreg);
 }
 
@@ -1443,7 +1443,7 @@ RegionFromRects(nrects, prect, ctype)
     }
     else
     {
-	xfree (pData);
+	free (pData);
     }
     return pRgn;
 }
diff --git a/nx-X11/programs/Xserver/dix/resource.c b/nx-X11/programs/Xserver/dix/resource.c
index b0edbb2aa..0c5b6dd29 100644
--- a/nx-X11/programs/Xserver/dix/resource.c
+++ b/nx-X11/programs/Xserver/dix/resource.c
@@ -231,7 +231,7 @@ InitClientResources(ClientPtr client)
 	lastResourceClass = RC_LASTPREDEF;
 	TypeMask = RC_LASTPREDEF - 1;
 	if (DeleteFuncs)
-	    xfree(DeleteFuncs);
+	    free(DeleteFuncs);
 	DeleteFuncs = (DeleteType *)xalloc((lastResourceType + 1) *
 					   sizeof(DeleteType));
 	if (!DeleteFuncs)
@@ -249,7 +249,7 @@ InitClientResources(ClientPtr client)
 
 #ifdef XResExtension
         if(ResourceNames)
-            xfree(ResourceNames);
+            free(ResourceNames);
         ResourceNames = xalloc((lastResourceType + 1) * sizeof(Atom));
         if(!ResourceNames)
            return FALSE;
@@ -505,7 +505,7 @@ RebuildTable(int client)
     }
     DEALLOCATE_LOCAL(tails);
     clientTable[client].buckets *= 2;
-    xfree(clientTable[client].resources);
+    free(clientTable[client].resources);
     clientTable[client].resources = resources;
 }
 
@@ -535,7 +535,7 @@ FreeResource(XID id, RESTYPE skipDeleteFuncType)
 		elements = --*eltptr;
 		if (rtype != skipDeleteFuncType)
 		    (*DeleteFuncs[rtype & TypeMask])(res->value, res->id);
-		xfree(res);
+		free(res);
 		if (*eltptr != elements)
 		    prev = head; /* prev may no longer be valid */
 		gotOne = TRUE;
@@ -568,7 +568,7 @@ FreeResourceByType(XID id, RESTYPE type, Bool skipFree)
 		*prev = res->next;
 		if (!skipFree)
 		    (*DeleteFuncs[type & TypeMask])(res->value, res->id);
-		xfree(res);
+		free(res);
 		break;
 	    }
 	    else
@@ -723,7 +723,7 @@ FreeClientNeverRetainResources(ClientPtr client)
 	    {
 		*prev = this->next;
 		(*DeleteFuncs[rtype & TypeMask])(this->value, this->id);
-		xfree(this);	    
+		free(this);	    
 	    }
 	    else
 		prev = &this->next;
@@ -767,10 +767,10 @@ FreeClientResources(ClientPtr client)
 	    RESTYPE rtype = this->type;
 	    *head = this->next;
 	    (*DeleteFuncs[rtype & TypeMask])(this->value, this->id);
-	    xfree(this);	    
+	    free(this);	    
 	}
     }
-    xfree(clientTable[client->index].resources);
+    free(clientTable[client->index].resources);
     clientTable[client->index].resources = NULL;
     clientTable[client->index].buckets = 0;
 }
diff --git a/nx-X11/programs/Xserver/dix/window.c b/nx-X11/programs/Xserver/dix/window.c
index 708b67aa1..945dde7cf 100644
--- a/nx-X11/programs/Xserver/dix/window.c
+++ b/nx-X11/programs/Xserver/dix/window.c
@@ -682,7 +682,7 @@ CreateWindow(Window wid, register WindowPtr pParent, int x, int y, unsigned w,
     {
 	if (!MakeWindowOptional (pWin))
 	{
-	    xfree (pWin);
+	    free (pWin);
 	    *error = BadAlloc;
 	    return NullWindow;
 	}
@@ -864,7 +864,7 @@ CrushTree(WindowPtr pWin)
 		(*UnrealizeWindow)(pChild);
 	    }
 	    FreeWindowResources(pChild);
-	    xfree(pChild);
+	    free(pChild);
 	    if ( (pChild = pSib) )
 		break;
 	    pChild = pParent;
@@ -916,7 +916,7 @@ DeleteWindow(void * value, XID wid)
 	if (pWin->prevSib)
 	    pWin->prevSib->nextSib = pWin->nextSib;
     }
-    xfree(pWin);
+    free(pWin);
     return Success;
 }
 #endif /* NXAGENT_SERVER */
@@ -3147,7 +3147,7 @@ HandleSaveSet(register ClientPtr client)
 		MapWindow(pWin, client);
 	}
     }
-    xfree(client->saveSet);
+    free(client->saveSet);
     client->numSaved = 0;
     client->saveSet = (SaveSetElt *)NULL;
 }
@@ -3449,8 +3449,8 @@ TileScreenSaver(int i, int kind)
     mskbits = (unsigned char *)xalloc( BitmapBytePad(32)*16);
     if (!srcbits || !mskbits)
     {
-	xfree(srcbits);
-	xfree(mskbits);
+	free(srcbits);
+	free(mskbits);
 	cursor = 0;
     }
     else
@@ -3471,8 +3471,8 @@ TileScreenSaver(int i, int kind)
 	}
 	else
 	{
-	    xfree (srcbits);
-	    xfree (mskbits);
+	    free (srcbits);
+	    free (mskbits);
 	}
     }
 
@@ -3660,7 +3660,7 @@ DisposeWindowOptional (register WindowPtr pWin)
     }
     else
 	pWin->cursorIsNone = TRUE;
-    xfree (pWin->optional);
+    free (pWin->optional);
     pWin->optional = NULL;
 }
 
diff --git a/nx-X11/programs/Xserver/fb/fbcmap.c b/nx-X11/programs/Xserver/fb/fbcmap.c
index a7c8ca638..9fdffdeff 100644
--- a/nx-X11/programs/Xserver/fb/fbcmap.c
+++ b/nx-X11/programs/Xserver/fb/fbcmap.c
@@ -491,8 +491,8 @@ fbInitVisuals (VisualPtr    *visualp,
     visual = (VisualPtr) xalloc (nvisual * sizeof (VisualRec));
     if (!depth || !visual)
     {
-	xfree (depth);
-	xfree (visual);
+	free (depth);
+	free (visual);
 	return FALSE;
     }
     *depthp = depth;
@@ -549,7 +549,7 @@ fbInitVisuals (VisualPtr    *visualp,
 	    vid++;
 	    visual++;
 	}
-	xfree (visuals);
+	free (visuals);
     }
     fbVisuals = NULL;
     visual = *visualp;
diff --git a/nx-X11/programs/Xserver/fb/fbcopy.c b/nx-X11/programs/Xserver/fb/fbcopy.c
index f68811ebb..d1fb63828 100644
--- a/nx-X11/programs/Xserver/fb/fbcopy.c
+++ b/nx-X11/programs/Xserver/fb/fbcopy.c
@@ -282,7 +282,7 @@ fbCopyNto1 (DrawablePtr	pSrcDrawable,
     
 		      pPriv->and, pPriv->xor,
 		      pPriv->bgand, pPriv->bgxor);
-	    xfree (tmp);
+	    free (tmp);
 	}
 	pbox++;
     }
diff --git a/nx-X11/programs/Xserver/fb/fbpixmap.c b/nx-X11/programs/Xserver/fb/fbpixmap.c
index 99c03862b..c562da221 100644
--- a/nx-X11/programs/Xserver/fb/fbpixmap.c
+++ b/nx-X11/programs/Xserver/fb/fbpixmap.c
@@ -104,7 +104,7 @@ fbDestroyPixmap (PixmapPtr pPixmap)
 {
     if(--pPixmap->refcnt)
 	return TRUE;
-    xfree(pPixmap);
+    free(pPixmap);
     return TRUE;
 }
 
@@ -309,7 +309,7 @@ fbPixmapToRegion(PixmapPtr pPix)
 	pReg->extents.y2 = RegionEnd(pReg)->y2;
 	if (pReg->data->numRects == 1)
 	{
-	    xfree(pReg->data);
+	    free(pReg->data);
 	    pReg->data = (RegDataPtr)NULL;
 	}
     }
diff --git a/nx-X11/programs/Xserver/fb/fbpseudocolor.c b/nx-X11/programs/Xserver/fb/fbpseudocolor.c
index 51f21ed21..bc1c091ed 100644
--- a/nx-X11/programs/Xserver/fb/fbpseudocolor.c
+++ b/nx-X11/programs/Xserver/fb/fbpseudocolor.c
@@ -277,7 +277,7 @@ xxCreateScreenResources(ScreenPtr pScreen)
     
     pPixmap = (*pScreen->CreatePixmap)(pScreen, 0, 0, depth);
     if (!pPixmap) {
-	xfree(pBits);
+	free(pBits);
 	return FALSE;
     }
     if (!(*pScreen->ModifyPixmapHeader)(pPixmap, pScreen->width,
@@ -285,7 +285,7 @@ xxCreateScreenResources(ScreenPtr pScreen)
 					BitsPerPixel(depth),
 					PixmapBytePad(pScreen->width, depth),
 					pBits)) {
-	xfree(pBits);
+	free(pBits);
 	return FALSE;
     }
     if (pScreen->rootDepth == pScrPriv->myDepth) {
@@ -295,7 +295,7 @@ xxCreateScreenResources(ScreenPtr pScreen)
 					    PixmapBytePad(pScreen->width,
 							  pScrPriv->depth),
 					    0)) {
-	    xfree(pBits);
+	    free(pBits);
 	    return FALSE;
 	}
     }
@@ -328,9 +328,9 @@ xxCloseScreen (int iScreen, ScreenPtr pScreen)
     unwrap (pScrPriv,pScreen, CloseScreen);
     ret = pScreen->CloseScreen(iScreen,pScreen);
 
-    xfree(pScrPriv->pBits);
-    xfree(pScrPriv->InstalledCmaps);
-    xfree(pScrPriv);
+    free(pScrPriv->pBits);
+    free(pScrPriv->InstalledCmaps);
+    free(pScrPriv);
     
     return TRUE;
 }
@@ -456,8 +456,8 @@ xxDestroyColormap(ColormapPtr pmap)
 	    tmpCmapPriv = tmpCmapPriv->next;
 	}
 	
-	xfree(pCmapPriv->cmap);
-	xfree(pCmapPriv);
+	free(pCmapPriv->cmap);
+	free(pCmapPriv);
     }
 
     unwrap(pScrPriv,pmap->pScreen, DestroyColormap);
diff --git a/nx-X11/programs/Xserver/fb/fbscreen.c b/nx-X11/programs/Xserver/fb/fbscreen.c
index 342fd5784..0600cebfe 100644
--- a/nx-X11/programs/Xserver/fb/fbscreen.c
+++ b/nx-X11/programs/Xserver/fb/fbscreen.c
@@ -36,12 +36,12 @@ fbCloseScreen (int index, ScreenPtr pScreen)
     DepthPtr	depths = pScreen->allowedDepths;
 
     for (d = 0; d < pScreen->numDepths; d++)
-	xfree (depths[d].vids);
-    xfree (depths);
-    xfree (pScreen->visuals);
-    xfree (pScreen->devPrivate);
+	free (depths[d].vids);
+    free (depths);
+    free (pScreen->visuals);
+    free (pScreen->devPrivate);
 #ifdef FB_SCREEN_PRIVATE
-    xfree (pScreen->devPrivates[fbScreenPrivateIndex].ptr);
+    free (pScreen->devPrivates[fbScreenPrivateIndex].ptr);
 #endif
     return TRUE;
 }
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Args.c b/nx-X11/programs/Xserver/hw/nxagent/Args.c
index 6e6d61772..4f0173db0 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Args.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Args.c
@@ -355,7 +355,7 @@ int ddxProcessArgument(int argc, char *argv[], int i)
 
       if (nxagentOptionFile != NULL)
       {
-        xfree(nxagentOptionFile);
+        free(nxagentOptionFile);
 
         nxagentOptionFile = NULL;
       }
@@ -719,7 +719,7 @@ int ddxProcessArgument(int argc, char *argv[], int i)
 
       if (nxagentKeyboard != NULL)
       {
-        xfree(nxagentKeyboard);
+        free(nxagentKeyboard);
 
         nxagentKeyboard = NULL;
       }
@@ -1591,7 +1591,7 @@ nxagentProcessOptionsFileFree:
 
   if (data != NULL)
   {
-    Xfree(data);
+    free(data);
   }
 
 nxagentProcessOptionsFileClose:
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Clipboard.c b/nx-X11/programs/Xserver/hw/nxagent/Clipboard.c
index a0dfbf602..5249d8550 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Clipboard.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Clipboard.c
@@ -745,7 +745,7 @@ void nxagentCollectPropertyEvent(int resource)
 
         if (pszReturnData != NULL)
         {
-          Xfree(pszReturnData);
+          free(pszReturnData);
         }
 
         return;
@@ -787,7 +787,7 @@ void nxagentCollectPropertyEvent(int resource)
 
         if (pszReturnData != NULL)
         {
-          Xfree(pszReturnData);
+          free(pszReturnData);
         }
 
         return;
@@ -1487,7 +1487,7 @@ int nxagentInitClipboard(WindowPtr pWin)
 
   if (lastSelectionOwner != NULL)
   {
-    xfree(lastSelectionOwner);
+    free(lastSelectionOwner);
     lastSelectionOwner = NULL;
   }
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Colormap.c b/nx-X11/programs/Xserver/hw/nxagent/Colormap.c
index fe3b6ce1d..18c4c67a6 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Colormap.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Colormap.c
@@ -112,7 +112,7 @@ Bool nxagentCreateColormap(ColormapPtr pCmap)
       pCmap->red[i].co.local.green = colors[i].red;
       pCmap->red[i].co.local.blue = colors[i].red;
     }
-    xfree(colors);
+    free(colors);
     break;
 
   case StaticColor: /* read only */
@@ -125,7 +125,7 @@ Bool nxagentCreateColormap(ColormapPtr pCmap)
       pCmap->red[i].co.local.green = colors[i].green;
       pCmap->red[i].co.local.blue = colors[i].blue;
     }
-    xfree(colors);
+    free(colors);
     break;
 
   case TrueColor: /* read only */
@@ -149,7 +149,7 @@ Bool nxagentCreateColormap(ColormapPtr pCmap)
       pCmap->green[i].co.local.green = colors[i].green;
       pCmap->blue[i].co.local.blue = colors[i].blue;
     }
-    xfree(colors);
+    free(colors);
     break;
 
   case GrayScale: /* read and write */
@@ -168,7 +168,7 @@ Bool nxagentCreateColormap(ColormapPtr pCmap)
 void nxagentDestroyColormap(ColormapPtr pCmap)
 {
   XFreeColormap(nxagentDisplay, nxagentColormap(pCmap));
-  xfree(pCmap->devPriv);
+  free(pCmap->devPriv);
 }
 
 #define SEARCH_PREDICATE \
@@ -246,11 +246,11 @@ void nxagentSetInstalledColormapWindows(ScreenPtr pScreen)
     numWindows = 0;
   }
 
-  xfree(icws.cmapIDs);
+  free(icws.cmapIDs);
 
   if (!nxagentSameInstalledColormapWindows(icws.windows, icws.numWindows)) {
     if (nxagentOldInstalledColormapWindows)
-      xfree(nxagentOldInstalledColormapWindows);
+      free(nxagentOldInstalledColormapWindows);
 
 #ifdef _XSERVER64
     {
@@ -261,7 +261,7 @@ void nxagentSetInstalledColormapWindows(ScreenPtr pScreen)
 	  windows[i] = icws.windows[i];
       XSetWMColormapWindows(nxagentDisplay, nxagentDefaultWindows[pScreen->myNum],
 			    windows, numWindows);
-      xfree(windows);
+      free(windows);
     }
 #else
     XSetWMColormapWindows(nxagentDisplay, nxagentDefaultWindows[pScreen->myNum],
@@ -310,13 +310,13 @@ void nxagentSetInstalledColormapWindows(ScreenPtr pScreen)
 #endif /* DUMB_WINDOW_MANAGERS */
   }
   else
-    if (icws.windows) xfree(icws.windows);
+    if (icws.windows) free(icws.windows);
 }
 
 void nxagentSetScreenSaverColormapWindow(ScreenPtr pScreen)
 {
   if (nxagentOldInstalledColormapWindows)
-    xfree(nxagentOldInstalledColormapWindows);
+    free(nxagentOldInstalledColormapWindows);
 
 #ifdef _XSERVER64
   {
@@ -448,7 +448,7 @@ void nxagentStoreColors(ColormapPtr pCmap, int nColors, xColorItem *pColors)
       pColors64[i].flags = pColors[i].flags;
     }
     XStoreColors(nxagentDisplay, nxagentColormap(pCmap), pColors64, nColors);
-    xfree(pColors64);
+    free(pColors64);
   }
 #else
     XStoreColors(nxagentDisplay, nxagentColormap(pCmap),
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Cursor.c b/nx-X11/programs/Xserver/hw/nxagent/Cursor.c
index 62095d5b3..b1449bf13 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Cursor.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Cursor.c
@@ -267,7 +267,7 @@ Bool nxagentUnrealizeCursor(ScreenPtr pScreen, CursorPtr pCursor)
     nxagentCursor(pCursor, pScreen) = None;
   }
 
-  xfree(nxagentCursorPriv(pCursor, pScreen));
+  free(nxagentCursorPriv(pCursor, pScreen));
 
   return True;
 }
@@ -366,7 +366,7 @@ void nxagentReconnectCursor(void * p0, XID x1, void * p2)
     }
     else
     {
-      xfree(nxagentCursorPriv(pCursor, nxagentDefaultScreen));
+      free(nxagentCursorPriv(pCursor, nxagentDefaultScreen));
       if (!nxagentRealizeCursor(nxagentDefaultScreen, pCursor))
       {
         fprintf(stderr, "nxagentReconnectCursor: nxagentRealizeCursor failed\n");
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Display.c b/nx-X11/programs/Xserver/hw/nxagent/Display.c
index 31ea7c2a0..27cd0859a 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Display.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Display.c
@@ -1814,13 +1814,13 @@ void nxagentCloseDisplay()
    * traffic
    */
 
-  xfree(nxagentDefaultColormaps);
+  free(nxagentDefaultColormaps);
   nxagentDefaultColormaps = NULL;
 
   XFree(nxagentVisuals);
   nxagentVisuals = NULL;
 
-  xfree(nxagentDepths);
+  free(nxagentDepths);
   nxagentDepths = NULL;
 
   XFree(nxagentPixmapFormats);
@@ -2060,7 +2060,7 @@ void nxagentBackupDisplayInfo(void)
   nxagentNumVisualsRecBackup = nxagentNumVisuals;
   if (nxagentVisualHasBeenIgnored)
   {
-    xfree(nxagentVisualHasBeenIgnored);
+    free(nxagentVisualHasBeenIgnored);
     nxagentVisualHasBeenIgnored = NULL;
   }
   nxagentVisualHasBeenIgnored = xalloc(nxagentNumVisuals * sizeof(Bool));
@@ -2074,17 +2074,17 @@ void nxagentBackupDisplayInfo(void)
 
 void nxagentCleanupBackupDisplayInfo(void)
 {
-  xfree(nxagentDepthsRecBackup);
+  free(nxagentDepthsRecBackup);
   nxagentNumDepthsRecBackup = 0;
 
   nxagentNumDefaultColormapsRecBackup = 0;
 
-  xfree(nxagentVisualsRecBackup);
+  free(nxagentVisualsRecBackup);
   nxagentNumVisualsRecBackup = 0;
 
   if (nxagentVisualHasBeenIgnored)
   {
-    xfree(nxagentVisualHasBeenIgnored);
+    free(nxagentVisualHasBeenIgnored);
     nxagentVisualHasBeenIgnored = NULL;
   }
 
@@ -2107,7 +2107,7 @@ void nxagentCleanupBackupDisplayInfo(void)
     }
     else
     {
-      xfree(nxagentBitmapGCBackup);
+      free(nxagentBitmapGCBackup);
     }
 
     nxagentBitmapGCBackup = NULL;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Drawable.c b/nx-X11/programs/Xserver/hw/nxagent/Drawable.c
index 377e119ab..a73040eeb 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Drawable.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Drawable.c
@@ -359,7 +359,7 @@ nxagentSynchronizeDrawableDataFree:
 
   if (data != NULL)
   {
-    xfree(data);
+    free(data);
   }
 
 nxagentSynchronizeDrawableDataEnd:
@@ -860,7 +860,7 @@ int nxagentSynchronizeRegion(DrawablePtr pDrawable, RegionPtr pRegion, unsigned
 
             if (cmpData != NULL)
             {
-              xfree(cmpData);
+              free(cmpData);
             }
           }
         }
@@ -1060,7 +1060,7 @@ nxagentSynchronizeRegionFree:
 
   if (data != NULL)
   {
-    xfree(data);
+    free(data);
   }
 
   RegionUninit(&exposeRegion);
@@ -2161,7 +2161,7 @@ unsigned long nxagentGetColor(DrawablePtr pDrawable, int xPixel, int yPixel)
     fprintf(stderr, "nxagentGetColor: WARNING! Failed to create the XImage.\n");
     #endif
 
-    xfree(data);
+    free(data);
 
     return -1;
   }
@@ -2387,7 +2387,7 @@ void nxagentFillRemoteRegion(DrawablePtr pDrawable, RegionPtr pRegion)
     XFillRectangles(nxagentDisplay, nxagentDrawable(pDrawable), nxagentGC(pGC),
                         pRects, nrects);
 
-    xfree(pRects);
+    free(pRects);
   }
 }
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Font.c b/nx-X11/programs/Xserver/hw/nxagent/Font.c
index 8f692eb85..22b3e6c88 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Font.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Font.c
@@ -196,11 +196,11 @@ void nxagentFreeFontCache(void)
       nxagentFreeFont(CACHE_FSTRUCT(i));
     }
 
-    xfree(CACHE_NAME(i));
-    xfree(CACHE_ENTRY(i));
+    free(CACHE_NAME(i));
+    free(CACHE_ENTRY(i));
   }
 
-  xfree(CACHE_ENTRY_PTR);
+  free(CACHE_ENTRY_PTR);
   CACHE_ENTRY_PTR = NULL;
   CACHE_INDEX = 0;
   CACHE_SIZE = 0;
@@ -364,10 +364,10 @@ static void nxagentFreeRemoteFontList(nxagentFontList *listRec)
   {
     if (listRec -> list[l])
     {
-      xfree(listRec -> list[l] -> name);
+      free(listRec -> list[l] -> name);
       listRec -> list[l] -> name = NULL;
 
-      xfree(listRec -> list[l]);
+      free(listRec -> list[l]);
       listRec -> list[l] = NULL;
     }
   }
@@ -686,7 +686,7 @@ Bool nxagentUnrealizeFont(ScreenPtr pScreen, FontPtr pFont)
     if (nxagentFontPriv(pFont) -> mirrorID)
       FreeResource(nxagentFontPriv(pFont) -> mirrorID, RT_NONE);
 
-    xfree(nxagentFontPriv(pFont));
+    free(nxagentFontPriv(pFont));
     FontSetPrivate(pFont, nxagentFontPrivateIndex, NULL);
   }
 
@@ -1640,7 +1640,7 @@ XFontStruct* nxagentLoadQueryFont(register Display *dpy, char *name, FontPtr pFo
     fprintf(stderr, "nxagentLoadQueryFont: WARNING! Font not found '%s'.\n", name);
     #endif
 
-    Xfree(fs);
+    free(fs);
 
     return (XFontStruct *) NULL;
   }
@@ -1674,7 +1674,7 @@ XFontStruct* nxagentLoadQueryFont(register Display *dpy, char *name, FontPtr pFo
       fprintf(stderr, "nxagentLoadQueryFont: WARNING! Failed allocation of XFontProp.");
       #endif
 
-      Xfree((char *) fs);
+      free((char *) fs);
       return (XFontStruct *) NULL;
     }
 
@@ -1714,13 +1714,13 @@ int nxagentFreeFont(XFontStruct *fs)
     #ifdef USE_XF86BIGFONT
     _XF86BigfontFreeFontMetrics(fs);
     #else
-    Xfree ((char *) fs->per_char);
+    free ((char *) fs->per_char);
     #endif
   }
 
   if (fs -> properties)
   {
-    Xfree (fs->properties);
+    free (fs->properties);
   }
 
   XFree(fs);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/GC.c b/nx-X11/programs/Xserver/hw/nxagent/GC.c
index 7450c1e6c..21e828769 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/GC.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/GC.c
@@ -686,7 +686,7 @@ void nxagentChangeClip(GCPtr pGC, int type, void * pValue, int nRects)
 
         XSetClipRectangles(nxagentDisplay, nxagentGC(pGC), pGC -> clipOrg.x, pGC -> clipOrg.y,
                                pRects, nRects, Unsorted);
-        xfree((char *) pRects);
+        free((char *) pRects);
       }
 
       break;
@@ -770,7 +770,7 @@ void nxagentChangeClip(GCPtr pGC, int type, void * pValue, int nRects)
 
       pGC->clientClip = (void *) RegionFromRects(nRects,
                                                   (xRectangle *)pValue, type);
-      xfree(pValue);
+      free(pValue);
 
       pValue = pGC->clientClip;
 
@@ -904,7 +904,7 @@ static void nxagentFreeGCRec(struct nxagentGCRec *t)
               (void *) t, (void *) t -> gc);
   #endif
 
-  xfree(t -> gc);
+  free(t -> gc);
 
   free(t);
 }
@@ -918,7 +918,7 @@ static void nxagentRestoreGCRec(struct nxagentGCRec *t)
 
   if (nxagentGC(t -> pGC))
   {
-    xfree(nxagentGC(t -> pGC));
+    free(nxagentGC(t -> pGC));
   }
 
   nxagentGC(t -> pGC) = t -> gc;
@@ -1298,7 +1298,7 @@ static void nxagentReconnectClip(GCPtr pGC, int type, void * pValue, int nRects)
 
         XSetClipRectangles(nxagentDisplay, nxagentGC(pGC), pGC -> clipOrg.x, pGC -> clipOrg.y,
                            pRects, nRects, Unsorted);
-        xfree((char *) pRects);
+        free((char *) pRects);
       }
       else
       {
@@ -1369,7 +1369,7 @@ static void nxagentReconnectClip(GCPtr pGC, int type, void * pValue, int nRects)
 
       pGC->clientClip = (void *) RegionFromRects(nRects,
                                                   (xRectangle *)pValue, type);
-      xfree(pValue);
+      free(pValue);
       pValue = pGC->clientClip;
       type = CT_REGION;
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/GCOps.c b/nx-X11/programs/Xserver/hw/nxagent/GCOps.c
index 634bbf2ce..01a3f6a93 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/GCOps.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/GCOps.c
@@ -779,7 +779,7 @@ RegionPtr nxagentCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
                    srcx, srcy, width, height);
     #endif
 
-    xfree(data);
+    free(data);
 
     /*
      * If the source is a shared memory pixmap, the
@@ -999,7 +999,7 @@ RegionPtr nxagentCopyPlane(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
                    srcx, srcy, width, height);
     #endif
 
-    xfree(data);
+    free(data);
 
     /*
      * If the source is a shared memory pixmap, the
@@ -1539,7 +1539,7 @@ void nxagentFillPolygon(DrawablePtr pDrawable, GCPtr pGC, int shape,
 
   if (newPoints != NULL)
   {
-    xfree(newPoints);
+    free(newPoints);
   }
 }
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Image.c b/nx-X11/programs/Xserver/hw/nxagent/Image.c
index a158a11db..b7c3135d0 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Image.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Image.c
@@ -447,7 +447,7 @@ FIXME: Here the split trap is always set and so the caching of
 
     if (nxagentUnpackAlpha[resource] != NULL)
     {
-      Xfree(nxagentUnpackAlpha[resource] -> data);
+      free(nxagentUnpackAlpha[resource] -> data);
     }
     else if ((nxagentUnpackAlpha[resource] = Xmalloc(sizeof(UnpackAlphaRec))) == NULL)
     {
@@ -455,7 +455,7 @@ FIXME: Here the split trap is always set and so the caching of
       fprintf(stderr, "nxagentSetUnpackAlpha: PANIC! Can't allocate data for the alpha structure.\n");
       #endif
 
-      Xfree(data);
+      free(data);
 
       return;
     }
@@ -475,7 +475,7 @@ FIXME: Here the split trap is always set and so the caching of
                 resource, size);
     #endif
 
-    Xfree(data);
+    free(data);
   }
 }
 
@@ -1561,7 +1561,7 @@ nxagentPutSubImageEnd:
 
   if (packedChecksum != NULL)
   {
-    Xfree(packedChecksum);
+    free(packedChecksum);
   }
 
   if (packedImage != NULL)
@@ -1569,13 +1569,13 @@ nxagentPutSubImageEnd:
     if (packedImage -> data != NULL &&
             packedImage -> data != plainImage -> data)
     {
-      Xfree(packedImage -> data);
+      free(packedImage -> data);
     }
 
-    Xfree(packedImage);
+    free(packedImage);
   }
 
-  Xfree(plainImage);
+  free(plainImage);
 }
 
 void nxagentGetImage(DrawablePtr pDrawable, int x, int y, int w, int h,
@@ -1629,9 +1629,9 @@ void nxagentResetAlphaCache()
   {
     if (nxagentUnpackAlpha[i])
     {
-      Xfree(nxagentUnpackAlpha[i] -> data);
+      free(nxagentUnpackAlpha[i] -> data);
 
-      Xfree(nxagentUnpackAlpha[i]);
+      free(nxagentUnpackAlpha[i]);
 
       nxagentUnpackAlpha[i] = NULL;
     }
@@ -1711,7 +1711,7 @@ int nxagentScaleImage(int x, int y, unsigned xRatio, unsigned yRatio,
 
   if (newImage -> data == NULL)
   {
-    Xfree(newImage);
+    free(newImage);
     
     #ifdef PANIC
     fprintf(stderr, "nxagentScaleImage: PANIC! Failed to create the target image data.\n");
@@ -1781,10 +1781,10 @@ int nxagentScaleImage(int x, int y, unsigned xRatio, unsigned yRatio,
 
   if (image -> obdata != NULL)
   {
-    Xfree((char *) image -> obdata);
+    free((char *) image -> obdata);
   }
 
-  Xfree((char *) image);
+  free((char *) image);
 
   *pImage = newImage;
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c b/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c
index 852771492..6bd201d70 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c
@@ -1138,7 +1138,7 @@ Reply   Total	Cached	Bits In			Bits Out		Bits/Reply	  Ratio
       #endif
 
 #ifdef _XSERVER64
-      xfree(keymap);
+      free(keymap);
 #else
       XFree(keymap);
 #endif
@@ -1473,17 +1473,17 @@ static int nxagentFreeKeyboardDeviceData(DeviceIntPtr dev)
       }
       #endif
 
-      xfree(dev->key->curKeySyms.map);
-      xfree(dev->key->modifierKeyMap);
-      xfree(dev->key);
+      free(dev->key->curKeySyms.map);
+      free(dev->key->modifierKeyMap);
+      free(dev->key);
 
       dev->key=NULL;
   }
 
   if (dev->focus)
   {
-      xfree(dev->focus->trace);
-      xfree(dev->focus);
+      free(dev->focus->trace);
+      free(dev->focus);
       dev->focus=NULL;
   }
 
@@ -1494,7 +1494,7 @@ static int nxagentFreeKeyboardDeviceData(DeviceIntPtr dev)
       if (k->xkb_sli)
           XkbFreeSrvLedInfo(k->xkb_sli);
       #endif
-      xfree(k);
+      free(k);
   }
 
   #ifdef DEBUG
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c b/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c
index b68f01b8d..d1923106d 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c
@@ -197,7 +197,7 @@ void
 InitSelections()
 {
     if (CurrentSelections)
-	xfree(CurrentSelections);
+	free(CurrentSelections);
     CurrentSelections = (Selection *)NULL;
     NumCurrentSelections = 0;
 
@@ -1316,7 +1316,7 @@ CloseDownClient(register ClientPtr client)
 #ifdef SMART_SCHEDULE
 	SmartLastClient = NullClient;
 #endif
-	xfree(client);
+	free(client);
 
 	while (!clients[currentMaxClients-1])
 	    currentMaxClients--;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c b/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c
index 77f21e495..d15df9513 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c
@@ -326,9 +326,9 @@ bail:
     for (i = 0; i < c->num_fpes; i++) {
 	FreeFPE(c->fpe_list[i]);
     }
-    xfree(c->fpe_list);
-    xfree(c->fontname);
-    xfree(c);
+    free(c->fpe_list);
+    free(c->fontname);
+    free(c);
     return TRUE;
 }
 
@@ -441,7 +441,7 @@ doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
 		    return TRUE;
 		}
 		if (err == FontNameAlias) {
-		    if (resolved) xfree(resolved);
+		    if (resolved) free(resolved);
 		    resolved = (char *) xalloc(resolvedlen + 1);
 		    if (resolved)
 			memmove(resolved, tmpname, resolvedlen + 1);
@@ -496,7 +496,7 @@ doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
 		    c->saved = c->current;
 		    c->haveSaved = TRUE;
 		    if (c->savedName)
-			xfree(c->savedName);
+			free(c->savedName);
 		    c->savedName = (char *)xalloc(namelen + 1);
 		    if (c->savedName)
 			memmove(c->savedName, name, namelen + 1);
@@ -614,11 +614,11 @@ bail:
     }
     for (i = 0; i < c->num_fpes; i++)
 	FreeFPE(c->fpe_list[i]);
-    xfree(c->fpe_list);
-    if (c->savedName) xfree(c->savedName);
+    free(c->fpe_list);
+    if (c->savedName) free(c->savedName);
     FreeFontNames(names);
-    xfree(c);
-    if (resolved) xfree(resolved);
+    free(c);
+    if (resolved) free(resolved);
     return TRUE;
 }
 
@@ -643,14 +643,14 @@ ListFonts(ClientPtr client, unsigned char *pattern, unsigned length,
     c->fpe_list = (FontPathElementPtr *)
 	xalloc(sizeof(FontPathElementPtr) * num_fpes);
     if (!c->fpe_list) {
-	xfree(c);
+	free(c);
 	return BadAlloc;
     }
     c->names = MakeFontNamesRecord(max_names < nxagentMaxFontNames ? max_names : nxagentMaxFontNames);
     if (!c->names)
     {
-	xfree(c->fpe_list);
-	xfree(c);
+	free(c->fpe_list);
+	free(c);
 	return BadAlloc;
     }
     memmove( c->current.pattern, pattern, length);
@@ -785,7 +785,7 @@ doListFontsWithInfo(ClientPtr client, LFWIclosurePtr c)
 		c->haveSaved = TRUE;
 		c->savedNumFonts = numFonts;
 		if (c->savedName)
-		  xfree(c->savedName);
+		  free(c->savedName);
 		c->savedName = (char *)xalloc(namelen + 1);
 		if (c->savedName)
 		  memmove(c->savedName, name, namelen + 1);
@@ -886,8 +886,8 @@ doListFontsWithInfo(ClientPtr client, LFWIclosurePtr c)
 	    (void) WriteToClient(client, namelen, name);
 	    if (pFontInfo == &fontInfo)
  	    {
-		xfree(fontInfo.props);
-		xfree(fontInfo.isStringProp);
+		free(fontInfo.props);
+		free(fontInfo.isStringProp);
 	    }
 	    --c->current.max_names;
 	}
@@ -910,10 +910,10 @@ bail:
     }
     for (i = 0; i < c->num_fpes; i++)
 	FreeFPE(c->fpe_list[i]);
-    xfree(c->reply);
-    xfree(c->fpe_list);
-    if (c->savedName) xfree(c->savedName);
-    xfree(c);
+    free(c->reply);
+    free(c->fpe_list);
+    if (c->savedName) free(c->savedName);
+    free(c);
     return TRUE;
 }
 
@@ -1085,7 +1085,7 @@ nxdoListFontsAndAliases(client, fss)
 		    return TRUE;
 		}
 		if (err == FontNameAlias) {
-		    if (resolved) xfree(resolved);
+		    if (resolved) free(resolved);
 		    resolved = (char *) xalloc(resolvedlen + 1);
 		    if (resolved)
                     {
@@ -1154,7 +1154,7 @@ nxdoListFontsAndAliases(client, fss)
 		    c->saved = c->current;
 		    c->haveSaved = TRUE;
 		    if (c->savedName)
-			xfree(c->savedName);
+			free(c->savedName);
 		    c->savedName = (char *)xalloc(namelen + 1);
 		    if (c->savedName)
                     {
@@ -1249,12 +1249,12 @@ finish:
     }
     for (i = 0; i < c->num_fpes; i++)
 	FreeFPE(c->fpe_list[i]);
-    xfree(c->fpe_list);
-    if (c->savedName) xfree(c->savedName);
+    free(c->fpe_list);
+    if (c->savedName) free(c->savedName);
     FreeFontNames(c->names);
-    xfree(c);
-    xfree(fss);
-    if (resolved) xfree(resolved);
+    free(c);
+    free(fss);
+    if (resolved) free(resolved);
 
     return doOpenFont(client, oc);
 }
@@ -1279,7 +1279,7 @@ nxOpenFont(client, fid, flags, lenfname, pfontname)
     memmove(f, pfontname, lenfname);
     f[lenfname] = '\0';
     ErrorF("OpenFont: fontname is \"%s\"\n", f);
-    xfree(f);
+    free(f);
 #endif
     if (!lenfname || lenfname > XLFDMAXFONTNAMELEN)
 	return BadName;
@@ -1317,22 +1317,22 @@ nxOpenFont(client, fid, flags, lenfname, pfontname)
 
     if (!(c = (LFclosurePtr) xalloc(sizeof *c)))
     {
-	xfree(fss);
+	free(fss);
 	return BadAlloc;
     }
         c->fpe_list = (FontPathElementPtr *)
 	xalloc(sizeof(FontPathElementPtr) * num_fpes);
     if (!c->fpe_list) {
-	xfree(c);
-	xfree(fss);
+	free(c);
+	free(fss);
 	return BadAlloc;
     }
     c->names = MakeFontNamesRecord(100);
     if (!c->names)
     {
-	xfree(c->fpe_list);
-	xfree(c);
-	xfree(fss);
+	free(c->fpe_list);
+	free(c);
+	free(fss);
 	return BadAlloc;
     }
     memmove( c->current.pattern, pfontname, lenfname);
@@ -1356,9 +1356,9 @@ nxOpenFont(client, fid, flags, lenfname, pfontname)
     {
       for (i = 0; i < c->num_fpes; i++)
         FreeFPE(c->fpe_list[i]);
-      xfree(c->fpe_list);
-      xfree(c);
-      xfree(fss);
+      free(c->fpe_list);
+      free(c);
+      free(fss);
       return BadAlloc;
     }
     oc->fontname = (char *) xalloc(256);/* I don't want to deal with future reallocs errors */
@@ -1367,10 +1367,10 @@ nxOpenFont(client, fid, flags, lenfname, pfontname)
     if (!oc->fontname) {
       for (i = 0; i < c->num_fpes; i++)
         FreeFPE(c->fpe_list[i]);
-      xfree(c->fpe_list);
-      xfree(c);
-      xfree(oc);
-      xfree(fss);
+      free(c->fpe_list);
+      free(c);
+      free(oc);
+      free(fss);
       return BadAlloc;
     }
     /*
@@ -1380,13 +1380,13 @@ nxOpenFont(client, fid, flags, lenfname, pfontname)
     oc->fpe_list = (FontPathElementPtr *)
 	xalloc(sizeof(FontPathElementPtr) * num_fpes);
     if (!oc->fpe_list) {
-	xfree(oc->fontname);
-	xfree(oc);
+	free(oc->fontname);
+	free(oc);
       for (i = 0; i < c->num_fpes; i++)
          FreeFPE(c->fpe_list[i]);
-       xfree(c->fpe_list);
-       xfree(c);
-       xfree(fss);
+       free(c->fpe_list);
+       free(c);
+       free(fss);
        return BadAlloc;
     }
     memmove(oc->fontname, pfontname, lenfname);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXglyph.c b/nx-X11/programs/Xserver/hw/nxagent/NXglyph.c
index 4359a552b..f2885d39c 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXglyph.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXglyph.c
@@ -65,7 +65,7 @@ AddGlyph (GlyphSetPtr glyphSet, GlyphPtr glyph, Glyph id)
     gr = FindGlyphRef (&globalGlyphs[glyphSet->fdepth], hash, TRUE, glyph);
     if (gr->glyph && gr->glyph != DeletedGlyph)
     {
-	xfree (glyph);
+	free (glyph);
 	glyph = gr->glyph;
     }
     else
@@ -175,7 +175,7 @@ ResizeGlyphHash (GlyphHashPtr hash, CARD32 change, Bool global)
 		++newHash.tableEntries;
 	    }
 	}
-	xfree (hash->table);
+	free (hash->table);
     }
     *hash = newHash;
     if (global)
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXglyphcurs.c b/nx-X11/programs/Xserver/hw/nxagent/NXglyphcurs.c
index 33492a6d6..53a5a8d68 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXglyphcurs.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXglyphcurs.c
@@ -115,7 +115,7 @@ ServerBitsFromGlyph(FontPtr pfont, unsigned ch, register CursorMetricPtr cm, uns
 	    fbDestroyPixmap(ppix);
 	if (pGC)
 	    FreeScratchGC(pGC);
-	xfree(pbits);
+	free(pbits);
 	return BadAlloc;
     }
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXpicture.c b/nx-X11/programs/Xserver/hw/nxagent/NXpicture.c
index a47e158df..44248bc1b 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXpicture.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXpicture.c
@@ -284,7 +284,7 @@ CreateSolidPicture (Picture pid, xRenderColor *color, int *error)
     pPicture->pSourcePict = (SourcePictPtr) xalloc(sizeof(PictSolidFill));
     if (!pPicture->pSourcePict) {
         *error = BadAlloc;
-        xfree(pPicture);
+        free(pPicture);
         return 0;
     }
     pPicture->pSourcePict->type = SourcePictTypeSolidFill;
@@ -361,12 +361,12 @@ FreePicture (void *	value,
         nxagentDestroyPicture(pPicture);
 
 	if (pPicture->transform)
-	    xfree (pPicture->transform);
+	    free (pPicture->transform);
         if (!pPicture->pDrawable) {
             if (pPicture->pSourcePict) {
                 if (pPicture->pSourcePict->type != SourcePictTypeSolidFill)
-                    xfree(pPicture->pSourcePict->linear.stops);
-                xfree(pPicture->pSourcePict);
+                    free(pPicture->pSourcePict->linear.stops);
+                free(pPicture->pSourcePict);
             }
         } else {
             ScreenPtr	    pScreen = pPicture->pDrawable->pScreen;
@@ -397,7 +397,7 @@ FreePicture (void *	value,
                 (*pScreen->DestroyPixmap) ((PixmapPtr)pPicture->pDrawable);
             }
         }
-	xfree (pPicture);
+	free (pPicture);
     }
     return Success;
 }
@@ -502,7 +502,7 @@ Bool nxagentReconnectAllPictFormat(void *p)
     }
   }
 
-  xfree(formats);
+  free(formats);
 
   /* TODO: Perhaps do i have to do PictureFinishInit ?. */
   /* TODO: We have to check for new Render protocol version. */
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXproperty.c b/nx-X11/programs/Xserver/hw/nxagent/NXproperty.c
index 2458c12d0..0ace2fbd2 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXproperty.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXproperty.c
@@ -233,7 +233,7 @@ ChangeWindowProperty(WindowPtr pWin, Atom property, Atom type, int format,
         data = (void *)xalloc(totalSize);
 	if (!data && len)
 	{
-	    xfree(pProp);
+	    free(pProp);
 	    return(BadAlloc);
 	}
         pProp->propertyName = property;
@@ -296,7 +296,7 @@ ChangeWindowProperty(WindowPtr pWin, Atom property, Atom type, int format,
 	    memmove(&((char *)data)[totalSize], (char *)pProp->data, 
 		  (int)(pProp->size * sizeInBytes));
             memmove((char *)data, (char *)value, totalSize);
-	    xfree(pProp->data);
+	    free(pProp->data);
             pProp->data = data;
             pProp->size += len;
 	}
@@ -521,8 +521,8 @@ ProcGetProperty(ClientPtr client)
 	}
 	else
 	    prevProp->next = pProp->next;
-	xfree(pProp->data);
-	xfree(pProp);
+	free(pProp->data);
+	free(pProp);
     }
     return(client->noClientException);
 }
@@ -636,8 +636,8 @@ GetWindowProperty(pWin, property, longOffset, longLength, delete,
 	}
 	else
 	    prevProp->next = pProp->next;
-	xfree(pProp->data);
-	xfree(pProp);
+	free(pProp->data);
+	free(pProp);
     }
     return(Success);
 }
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXrender.c b/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
index 93760f482..b89b835db 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
@@ -362,7 +362,7 @@ ProcRenderQueryPictFormats (ClientPtr client)
 	swapl (&reply->numSubpixel, n);
     }
     WriteToClient(client, rlength, (char *) reply);
-    xfree (reply);
+    free (reply);
     return client->noClientException;
 }
 
@@ -730,7 +730,7 @@ ProcRenderTrapezoids (ClientPtr client)
 
       if (nxagentTrapezoidExtents != NullBox)
       {
-        xfree(nxagentTrapezoidExtents);
+        free(nxagentTrapezoidExtents);
 
         nxagentTrapezoidExtents = NullBox;
       }
@@ -1132,7 +1132,7 @@ ProcRenderCompositeGlyphs (ClientPtr client)
                       glyphsBase);
     }
 
-    xfree(nxagentGlyphsExtents);
+    free(nxagentGlyphsExtents);
     nxagentGlyphsExtents = NullBox;
 
     if (glyphsBase != glyphsLocal)
@@ -1140,7 +1140,7 @@ ProcRenderCompositeGlyphs (ClientPtr client)
     if (listsBase != listsLocal)
 	DEALLOCATE_LOCAL (listsBase);
     
-    xfree(elementsBase);
+    free(elementsBase);
 
     return client->noClientException;
 }
@@ -1228,14 +1228,14 @@ ProcRenderCreateCursor (ClientPtr client)
     srcbits = (unsigned char *)xalloc(nbytes_mono);
     if (!srcbits)
     {
-	xfree (argbbits);
+	free (argbbits);
 	return (BadAlloc);
     }
     mskbits = (unsigned char *)xalloc(nbytes_mono);
     if (!mskbits)
     {
-	xfree(argbbits);
-	xfree(srcbits);
+	free(argbbits);
+	free(srcbits);
 	return (BadAlloc);
     }
     bzero ((char *) mskbits, nbytes_mono);
@@ -1257,26 +1257,26 @@ ProcRenderCreateCursor (ClientPtr client)
 	pFormat = PictureMatchFormat (pScreen, 32, PICT_a8r8g8b8);
 	if (!pFormat)
 	{
-	    xfree (argbbits);
-	    xfree (srcbits);
-	    xfree (mskbits);
+	    free (argbbits);
+	    free (srcbits);
+	    free (mskbits);
 	    return (BadImplementation);
 	}
 	pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height, 32);
 	if (!pPixmap)
 	{
-	    xfree (argbbits);
-	    xfree (srcbits);
-	    xfree (mskbits);
+	    free (argbbits);
+	    free (srcbits);
+	    free (mskbits);
 	    return (BadAlloc);
 	}
 	pPicture = CreatePicture (0, &pPixmap->drawable, pFormat, 0, 0, 
 				  client, &error);
 	if (!pPicture)
 	{
-	    xfree (argbbits);
-	    xfree (srcbits);
-	    xfree (mskbits);
+	    free (argbbits);
+	    free (srcbits);
+	    free (mskbits);
 	    return error;
 	}
 	(*pScreen->DestroyPixmap) (pPixmap);
@@ -1360,7 +1360,7 @@ ProcRenderCreateCursor (ClientPtr client)
     }
     else
     {
-	xfree (argbbits);
+	free (argbbits);
 	argbbits = 0;
     }
     
@@ -1488,7 +1488,7 @@ ProcRenderCreateAnimCursor (ClientPtr client)
 						       RT_CURSOR, SecurityReadAccess);
 	if (!cursors[i])
 	{
-	    xfree (cursors);
+	    free (cursors);
 	    client->errorValue = elt->cursor;
 	    return BadCursor;
 	}
@@ -1496,7 +1496,7 @@ ProcRenderCreateAnimCursor (ClientPtr client)
 	elt++;
     }
     ret = AnimCursorCreate (cursors, deltas, ncursor, &pCursor);
-    xfree (cursors);
+    free (cursors);
     if (ret != Success)
 	return ret;
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXresource.c b/nx-X11/programs/Xserver/hw/nxagent/NXresource.c
index 38bc05e51..4226a4435 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXresource.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXresource.c
@@ -313,7 +313,7 @@ FreeResource(XID id, RESTYPE skipDeleteFuncType)
                 #endif
 		if (rtype != skipDeleteFuncType)
 		    (*DeleteFuncs[rtype & TypeMask])(res->value, res->id);
-		xfree(res);
+		free(res);
 		if (*eltptr != elements)
 		    prev = head; /* prev may no longer be valid */
 		gotOne = TRUE;
@@ -349,7 +349,7 @@ FreeResourceByType(XID id, RESTYPE type, Bool skipFree)
                 #endif
 		if (!skipFree)
 		    (*DeleteFuncs[type & TypeMask])(res->value, res->id);
-		xfree(res);
+		free(res);
 		break;
 	    }
 	    else
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXshm.c b/nx-X11/programs/Xserver/hw/nxagent/NXshm.c
index 1ce72cbbe..08237440f 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXshm.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXshm.c
@@ -239,7 +239,7 @@ fbShmPutImage(dst, pGC, depth, format, w, h, sx, sy, sw, sh, dx, dy, data)
           fbGetImage((DrawablePtr) pPixmap, sx, sy, sw, sh, format, AllPlanes, newdata);
           (*pGC->ops->PutImage)(dst, pGC, depth, dx, dy, sw, sh, 0, format, newdata);
 
-          xfree(newdata);
+          free(newdata);
         }
         else
         {
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c b/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c
index 28aafd644..0071a15d0 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c
@@ -336,7 +336,7 @@ DeleteWindow(void * value, XID wid)
       nxagentSetInstalledColormapWindows(pWin -> drawable.pScreen);
     }
 
-    xfree(pWin);
+    free(pWin);
     return Success;
 }
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Pixmap.c b/nx-X11/programs/Xserver/hw/nxagent/Pixmap.c
index f429f1499..0eabf1262 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Pixmap.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Pixmap.c
@@ -487,7 +487,7 @@ Bool nxagentDestroyPixmap(PixmapPtr pPixmap)
     FreeResource(pPixmapPriv -> mid, RT_NONE);
   }
 
-  xfree(pPixmap);
+  free(pPixmap);
 
   return True;
 }
@@ -1259,7 +1259,7 @@ void nxagentSynchronizeShmPixmap(DrawablePtr pDrawable, int xPict, int yPict,
       nxagentPutImage(pDrawable, pGC, depth, xPict, yPict,
                           width, height, 0, format, data);
 
-      xfree(data);
+      free(data);
     }
     #ifdef WARNING
     else
@@ -1409,7 +1409,7 @@ FIXME: If the pixmap has a different depth from the window, the
 
     if (data != NULL)
     {
-      xfree(data);
+      free(data);
     }
 
     return False;
@@ -1571,7 +1571,7 @@ Bool nxagentFbOnShadowDisplay()
 
     if (data)
     {
-      xfree(data);
+      free(data);
     }
 
     return False;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Reconnect.c b/nx-X11/programs/Xserver/hw/nxagent/Reconnect.c
index 00d434bf4..587e9a564 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Reconnect.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Reconnect.c
@@ -444,7 +444,7 @@ Bool nxagentReconnectSession(void)
 
   if (nxagentKeyboard)
   {
-    xfree(nxagentKeyboard);
+    free(nxagentKeyboard);
 
     nxagentKeyboard = NULL;
   }
@@ -609,7 +609,7 @@ Bool nxagentReconnectSession(void)
 
   if (nxagentOldKeyboard != NULL)
   {
-    xfree(nxagentOldKeyboard);
+    free(nxagentOldKeyboard);
 
     nxagentOldKeyboard = NULL;
   }
@@ -734,7 +734,7 @@ nxagentReconnectError:
 
   if (nxagentOldKeyboard != NULL)
   {
-    xfree(nxagentOldKeyboard);
+    free(nxagentOldKeyboard);
 
     nxagentOldKeyboard = NULL;
   }
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Render.c b/nx-X11/programs/Xserver/hw/nxagent/Render.c
index 8c822319d..36ce6a74f 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Render.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Render.c
@@ -2284,7 +2284,7 @@ void nxagentAddGlyphs(GlyphSetPtr glyphSet, Glyph *gids, xGlyphInfo *gi,
 
   if (normalizedImages != images)
   {
-    xfree(normalizedImages);
+    free(normalizedImages);
   }
 
   #ifdef DEBUG
@@ -2392,7 +2392,7 @@ FIXME: Is this useful or just a waste of bandwidth?
                           nparams);
   #endif
 
-  Xfree(szFilter);
+  free(szFilter);
 }
 
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Rootless.c b/nx-X11/programs/Xserver/hw/nxagent/Rootless.c
index 49877f9d7..6947371ff 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Rootless.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Rootless.c
@@ -389,7 +389,7 @@ void nxagentRootlessRestack(unsigned long children[], unsigned int nchildren)
 
   #endif
 
-  xfree(toplevel);
+  free(toplevel);
 
   return;
 }
@@ -797,7 +797,7 @@ int nxagentExportProperty(pWin, property, type, format, mode, nUnits, value)
 
   if (freeMem)
   {
-    xfree(output);
+    free(output);
   }
 
   return export;
@@ -1104,7 +1104,7 @@ void nxagentImportProperty(Window window,
 
   if (freeMem)
   {
-    xfree(output);
+    free(output);
   }
 
   return;
@@ -1156,7 +1156,7 @@ void nxagentRemovePropertyFromList()
       nxagentPropertyList.last = NULL;
     }
 
-    xfree(tmp);
+    free(tmp);
   }
 }
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Screen.c b/nx-X11/programs/Xserver/hw/nxagent/Screen.c
index de8c97532..a4c6fc2db 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Screen.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Screen.c
@@ -1358,8 +1358,8 @@ Bool nxagentOpenScreen(int index, ScreenPtr pScreen,
      * by fbScreenInit with our own.
      */
 
-    xfree(pScreen -> visuals);
-    xfree(pScreen -> allowedDepths);
+    free(pScreen -> visuals);
+    free(pScreen -> allowedDepths);
 
     pScreen -> visuals = visuals;
     pScreen -> allowedDepths = depths;
@@ -2079,18 +2079,18 @@ Bool nxagentCloseScreen(int index, ScreenPtr pScreen)
 
   for (i = 0; i < pScreen->numDepths; i++)
   {
-    xfree(pScreen->allowedDepths[i].vids);
+    free(pScreen->allowedDepths[i].vids);
   }
 
   /*
    * Free the frame buffer.
    */
 
-  xfree(((PixmapPtr)pScreen -> devPrivate) -> devPrivate.ptr);
+  free(((PixmapPtr)pScreen -> devPrivate) -> devPrivate.ptr);
 
-  xfree(pScreen->allowedDepths);
-  xfree(pScreen->visuals);
-  xfree(pScreen->devPrivate);
+  free(pScreen->allowedDepths);
+  free(pScreen->visuals);
+  free(pScreen->devPrivate);
 
   /*
    * Reset the geometry and alpha information
@@ -3065,7 +3065,7 @@ int nxagentShadowPoll(PixmapPtr nxagentShadowPixmapPtr, GCPtr nxagentShadowGCPtr
 
       if (tBuffer)
       {
-        xfree(tBuffer);
+        free(tBuffer);
       }
 
       tBuffer = xalloc(length);
@@ -3125,7 +3125,7 @@ int nxagentShadowPoll(PixmapPtr nxagentShadowPixmapPtr, GCPtr nxagentShadowGCPtr
 
     if (tBuffer)
     {
-      xfree(tBuffer);
+      free(tBuffer);
     }
 
     RegionUninit(&updateRegion);
@@ -3346,7 +3346,7 @@ void nxagentShadowAdaptDepth(unsigned int width, unsigned int height,
 
   if (cBuffer != NULL)
   {
-    xfree(cBuffer);
+    free(cBuffer);
   }
 }
 
@@ -3529,7 +3529,7 @@ FIXME: The port information is not used at the moment and produces a
                              strlen(local_buf), local_buf, 1);
       }
 
-      xfree(local_buf);
+      free(local_buf);
     }
   }
 }
@@ -3769,7 +3769,7 @@ int nxagentAdjustRandRXinerama(ScreenPtr pScreen)
       number = 1;
 
       if (screeninfo) {
-	xfree(screeninfo);
+	free(screeninfo);
       }
       if (!(screeninfo = xalloc(sizeof(XineramaScreenInfo)))) {
 	return FALSE;
@@ -4061,7 +4061,7 @@ int nxagentAdjustRandRXinerama(ScreenPtr pScreen)
 
     /* release allocated memory */
     if (screeninfo) {
-      xfree(screeninfo);
+      free(screeninfo);
       screeninfo = NULL;
     }
 
@@ -4170,7 +4170,7 @@ void nxagentSaveAreas(PixmapPtr pPixmap, RegionPtr prgnSave, int xorg, int yorg,
 
   XSetClipRectangles(nxagentDisplay, gc, 0, 0, pRects, nRects, Unsorted);
 
-  xfree((char *) pRects);
+  free((char *) pRects);
 
   extents = *RegionExtents(&cleanRegion);
 
@@ -4316,7 +4316,7 @@ void nxagentRestoreAreas(PixmapPtr pPixmap, RegionPtr prgnRestore, int xorg,
 
   XSetClipRectangles(nxagentDisplay, gc, 0, 0, pRects, nRects, Unsorted);
 
-  xfree(pRects);
+  free(pRects);
 
   extents = *RegionExtents(clipRegion);
 
@@ -4537,7 +4537,7 @@ FIXME
 
     if (data)
     {
-      xfree(data);
+      free(data);
     }
 
     return;
@@ -4573,7 +4573,7 @@ FIXME
 
   if (data != NULL)
   {
-    xfree(data);
+    free(data);
   }
 
 /*
@@ -4628,7 +4628,7 @@ void nxagentFbRestoreArea(PixmapPtr pPixmap, WindowPtr pWin, int xSrc, int ySrc,
 
     if (data)
     {
-      xfree(data);
+      free(data);
     }
 
     return;
@@ -4691,7 +4691,7 @@ FIXME
 FIXME
   if (data)
   {
-    xfree(data);
+    free(data);
   }
 */
 }
diff --git a/nx-X11/programs/Xserver/include/os.h b/nx-X11/programs/Xserver/include/os.h
index aff2952fa..3b6a40b46 100644
--- a/nx-X11/programs/Xserver/include/os.h
+++ b/nx-X11/programs/Xserver/include/os.h
@@ -53,7 +53,7 @@ SOFTWARE.
 
 #include "misc.h"
 #define ALLOCATE_LOCAL_FALLBACK(_size) Xalloc((unsigned long)(_size))
-#define DEALLOCATE_LOCAL_FALLBACK(_ptr) Xfree((void *)(_ptr))
+#define DEALLOCATE_LOCAL_FALLBACK(_ptr) free((void *)(_ptr))
 #include <nx-X11/Xalloca.h>
 #ifndef IN_MODULE
 #include <stdarg.h>
diff --git a/nx-X11/programs/Xserver/mi/miarc.c b/nx-X11/programs/Xserver/mi/miarc.c
index 8db188a6e..b268c1140 100644
--- a/nx-X11/programs/Xserver/mi/miarc.c
+++ b/nx-X11/programs/Xserver/mi/miarc.c
@@ -450,7 +450,7 @@ miFreeArcCache (data, id)
 	{
 	    cent->lrustamp = 0;
 	    cent->lw = 0;
-	    xfree(cent->spdata);
+	    free(cent->spdata);
 	    cent->spdata = NULL;
 	}
     }
@@ -911,7 +911,7 @@ miComputeWideEllipse(
     if (!spdata || spdata->k != k)
     {
 	if (spdata)
-	    xfree(spdata);
+	    free(spdata);
 	spdata = (miArcSpanData *)xalloc(sizeof(miArcSpanData) +
 					 sizeof(miArcSpan) * (k + 2));
 	lruent->spdata = spdata;
@@ -1054,7 +1054,7 @@ miFillWideEllipse(
 	}
     }
     if (mustFree)
-	xfree(spdata);
+	free(spdata);
     (*pGC->ops->FillSpans)(pDraw, pGC, pts - points, points, widths, FALSE);
 
     DEALLOCATE_LOCAL(widths);
@@ -1412,7 +1412,7 @@ miArcJoin(DrawablePtr pDraw, GCPtr pGC, miArcFacePtr pLeft,
 			 * rest of the line */
 			miFillSppPoly(pDraw, pGC, cpt, pArcPts, xOrg, yOrg, xFtrans, yFtrans);
 		}
-		xfree(pArcPts);
+		free(pArcPts);
 		return;
 	case JoinMiter:
 		/*
@@ -1543,7 +1543,7 @@ miRoundCap(
 	 * rest of the line */
 	miFillSppPoly(pDraw, pGC, cpt, pArcPts, -xOrg, -yOrg, xFtrans, yFtrans);
     }
-    xfree(pArcPts);
+    free(pArcPts);
 }
 
 /*
@@ -1840,13 +1840,13 @@ miFreeArcs(
 	     iphase--)
 	{
 	    if (arcs[iphase].narcs > 0)
-		xfree(arcs[iphase].arcs);
+		free(arcs[iphase].arcs);
 	    if (arcs[iphase].njoins > 0)
-		xfree(arcs[iphase].joins);
+		free(arcs[iphase].joins);
 	    if (arcs[iphase].ncaps > 0)
-		xfree(arcs[iphase].caps);
+		free(arcs[iphase].caps);
 	}
-	xfree(arcs);
+	free(arcs);
 }
 
 /*
@@ -3169,11 +3169,11 @@ disposeFinalSpans (void)
 
 	for (chunk = chunks; chunk; chunk = next) {
 		next = chunk->next;
-		xfree (chunk);
+		free (chunk);
 	}
 	chunks = 0;
 	freeFinalSpans = 0;
-	xfree(finalSpans);
+	free(finalSpans);
 	finalSpans = 0;
 }
 
@@ -3265,7 +3265,7 @@ realFindSpan (int y)
 			memmove(((char *) newSpans) + (finalMiny-newMiny) * sizeof (struct finalSpan *),
 				(char *) finalSpans,
 			       finalSize * sizeof (struct finalSpan *));
-			xfree (finalSpans);
+			free (finalSpans);
 		}
 		if ((i = finalMiny - newMiny) > 0)
 			bzero ((char *)newSpans, i * sizeof (struct finalSpan *));
@@ -3610,7 +3610,7 @@ drawArc (
 		}
 	}
 	if (mustFree)
-	    xfree(spdata);
+	    free(spdata);
 }
 
 static void
diff --git a/nx-X11/programs/Xserver/mi/mibank.c b/nx-X11/programs/Xserver/mi/mibank.c
index b607af1c1..754b0916f 100644
--- a/nx-X11/programs/Xserver/mi/mibank.c
+++ b/nx-X11/programs/Xserver/mi/mibank.c
@@ -1709,7 +1709,7 @@ miBankCloseScreen(
         if (pScreenPriv->pBanks[i])
             RegionDestroy(pScreenPriv->pBanks[i]);
 
-    Xfree(pScreenPriv->pBanks);
+    free(pScreenPriv->pBanks);
 
     SCREEN_UNWRAP(CreateScreenResources);
     SCREEN_UNWRAP(ModifyPixmapHeader);
@@ -1722,7 +1722,7 @@ miBankCloseScreen(
     SCREEN_UNWRAP(CopyWindow);
     SCREEN_UNWRAP(BackingStoreFuncs);
 
-    Xfree(pScreenPriv);
+    free(pScreenPriv);
     return (*pScreen->CloseScreen)(nIndex, pScreen);
 }
 
@@ -2249,7 +2249,7 @@ miInitializeBanking(
     if (!(pScreenPriv->pBanks =                 /* Allocate and clear */
         (RegionPtr *)Xcalloc(nBanks * sizeof(RegionPtr))))
     {
-        Xfree(pScreenPriv);
+        free(pScreenPriv);
         return FALSE;
     }
 
@@ -2360,8 +2360,8 @@ miInitializeBanking(
             if (pScreenPriv->pBanks[i])
                 RegionDestroy(pScreenPriv->pBanks[i]);
 
-        Xfree(pScreenPriv->pBanks);
-        Xfree(pScreenPriv);
+        free(pScreenPriv->pBanks);
+        free(pScreenPriv);
 
         return FALSE;
     }
diff --git a/nx-X11/programs/Xserver/mi/mibitblt.c b/nx-X11/programs/Xserver/mi/mibitblt.c
index b19a15900..ae30d5238 100644
--- a/nx-X11/programs/Xserver/mi/mibitblt.c
+++ b/nx-X11/programs/Xserver/mi/mibitblt.c
@@ -258,7 +258,7 @@ miCopyArea(pSrcDrawable, pDstDrawable,
 
 	    (*pGC->ops->SetSpans)(pDstDrawable, pGC, (char *)pbits, pptFirst,
 				  (int *)pwidthFirst, height, TRUE);
-	    xfree(pbits);
+	    free(pbits);
 	}
     }
     prgnExposed = miHandleExposures(pSrcDrawable, pDstDrawable, pGC, xIn, yIn,
@@ -622,7 +622,7 @@ miCopyPlane(pSrcDrawable, pDstDrawable,
 	    miOpqStipDrawable(pDstDrawable, pGC, prgnSrc, ptile, 0,
 			      box.x2 - box.x1, box.y2 - box.y1,
 			      dstx + box.x1 - srcx, dsty + box.y1 - srcy);
-	    xfree(ptile);
+	    free(ptile);
 	}
     }
     prgnExposed = miHandleExposures(pSrcDrawable, pDstDrawable, pGC, srcx, srcy,
diff --git a/nx-X11/programs/Xserver/mi/mibstore.c b/nx-X11/programs/Xserver/mi/mibstore.c
index a24e2cbcd..d3dc11603 100644
--- a/nx-X11/programs/Xserver/mi/mibstore.c
+++ b/nx-X11/programs/Xserver/mi/mibstore.c
@@ -433,7 +433,7 @@ miBSCloseScreen (i, pScreen)
     pScreen->ChangeWindowAttributes = pScreenPriv->ChangeWindowAttributes;
     pScreen->CreateGC = pScreenPriv->CreateGC;
 
-    xfree ((void *) pScreenPriv);
+    free ((void *) pScreenPriv);
 
     return (*pScreen->CloseScreen) (i, pScreen);
 }
@@ -931,7 +931,7 @@ miBSDestroyGCPrivate (GCPtr pGC)
 	pGC->ops = pPriv->wrapOps;
 	if (pPriv->pBackingGC)
 	    FreeGC (pPriv->pBackingGC, (GContext) 0);
-	xfree ((void *) pPriv);
+	free ((void *) pPriv);
     }
 }
 
@@ -2685,7 +2685,7 @@ miBSFree(pWin)
 
 	RegionUninit(&pBackingStore->SavedRegion);
 
-	xfree(pBackingStore);
+	free(pBackingStore);
 	pWin->backStorage = NULL;
     }
 }
@@ -3615,7 +3615,7 @@ miBSDestroyGC (pGC)
 
     FUNC_EPILOGUE (pGC, pPriv);
 
-    xfree(pPriv);
+    free(pPriv);
 }
 
 static void
diff --git a/nx-X11/programs/Xserver/mi/micmap.c b/nx-X11/programs/Xserver/mi/micmap.c
index 15d3f7f46..607ecec3b 100644
--- a/nx-X11/programs/Xserver/mi/micmap.c
+++ b/nx-X11/programs/Xserver/mi/micmap.c
@@ -393,7 +393,7 @@ miClearVisualTypes()
 
     while ((v = miVisuals)) {
 	miVisuals = v->next;
-	xfree(v);
+	free(v);
     }
 }
 
@@ -565,9 +565,9 @@ miDoInitVisuals(VisualPtr *visualp, DepthPtr *depthp, int *nvisualp,
     preferredCVCs = (int *)xalloc(ndepth * sizeof(int));
     if (!depth || !visual || !preferredCVCs)
     {
-	xfree (depth);
-	xfree (visual);
-	xfree (preferredCVCs);
+	free (depth);
+	free (visual);
+	free (preferredCVCs);
 	return FALSE;
     }
     *depthp = depth;
@@ -628,7 +628,7 @@ miDoInitVisuals(VisualPtr *visualp, DepthPtr *depthp, int *nvisualp,
 	    vid++;
 	    visual++;
 	}
-	xfree (visuals);
+	free (visuals);
     }
     miVisuals = NULL;
     visual = *visualp;
@@ -684,7 +684,7 @@ miDoInitVisuals(VisualPtr *visualp, DepthPtr *depthp, int *nvisualp,
     }
     *rootDepthp = depth[i].depth;
     *defaultVisp = depth[i].vids[j];
-    xfree(preferredCVCs);
+    free(preferredCVCs);
 
     return TRUE;
 }
diff --git a/nx-X11/programs/Xserver/mi/midash.c b/nx-X11/programs/Xserver/mi/midash.c
index 5def4d9c8..2cf2704ea 100644
--- a/nx-X11/programs/Xserver/mi/midash.c
+++ b/nx-X11/programs/Xserver/mi/midash.c
@@ -269,7 +269,7 @@ CheckDashStorage(
 				       (*pnsegMax)*sizeof(miDashRec));
 	if (!newppseg)
 	{
-	    xfree(*ppseg);
+	    free(*ppseg);
 	    return (miDashPtr)NULL;
 	}
 	*ppseg = newppseg;
diff --git a/nx-X11/programs/Xserver/mi/midispcur.c b/nx-X11/programs/Xserver/mi/midispcur.c
index 6ffb9efea..5d4b3023a 100644
--- a/nx-X11/programs/Xserver/mi/midispcur.c
+++ b/nx-X11/programs/Xserver/mi/midispcur.c
@@ -155,7 +155,7 @@ miDCInitialize (pScreen, screenFuncs)
 
     if (!miSpriteInitialize (pScreen, &miDCFuncs, screenFuncs))
     {
-	xfree ((void *) pScreenPriv);
+	free ((void *) pScreenPriv);
 	return FALSE;
     }
     return TRUE;
@@ -187,7 +187,7 @@ miDCCloseScreen (index, pScreen)
     tossPict (pScreenPriv->pRootPicture);
     tossPict (pScreenPriv->pTempPicture);
 #endif
-    xfree ((void *) pScreenPriv);
+    free ((void *) pScreenPriv);
     return (*pScreen->CloseScreen) (index, pScreen);
 }
 
@@ -263,7 +263,7 @@ miDCRealize (
 	pFormat = PictureMatchFormat (pScreen, 32, PICT_a8r8g8b8);
 	if (!pFormat)
 	{
-	    xfree ((void *) pPriv);
+	    free ((void *) pPriv);
 	    return (miDCCursorPtr)NULL;
 	}
 	
@@ -273,14 +273,14 @@ miDCRealize (
 					    pCursor->bits->height, 32);
 	if (!pPixmap)
 	{
-	    xfree ((void *) pPriv);
+	    free ((void *) pPriv);
 	    return (miDCCursorPtr)NULL;
 	}
 	pGC = GetScratchGC (32, pScreen);
 	if (!pGC)
 	{
 	    (*pScreen->DestroyPixmap) (pPixmap);
-	    xfree ((void *) pPriv);
+	    free ((void *) pPriv);
 	    return (miDCCursorPtr)NULL;
 	}
 	ValidateGC (&pPixmap->drawable, pGC);
@@ -294,7 +294,7 @@ miDCRealize (
         (*pScreen->DestroyPixmap) (pPixmap);
 	if (!pPriv->pPicture)
 	{
-	    xfree ((void *) pPriv);
+	    free ((void *) pPriv);
 	    return (miDCCursorPtr)NULL;
 	}
 	pCursor->bits->devPriv[pScreen->myNum] = (void *) pPriv;
@@ -305,14 +305,14 @@ miDCRealize (
     pPriv->sourceBits = (*pScreen->CreatePixmap) (pScreen, pCursor->bits->width, pCursor->bits->height, 1);
     if (!pPriv->sourceBits)
     {
-	xfree ((void *) pPriv);
+	free ((void *) pPriv);
 	return (miDCCursorPtr)NULL;
     }
     pPriv->maskBits =  (*pScreen->CreatePixmap) (pScreen, pCursor->bits->width, pCursor->bits->height, 1);
     if (!pPriv->maskBits)
     {
 	(*pScreen->DestroyPixmap) (pPriv->sourceBits);
-	xfree ((void *) pPriv);
+	free ((void *) pPriv);
 	return (miDCCursorPtr)NULL;
     }
     pCursor->bits->devPriv[pScreen->myNum] = (void *) pPriv;
@@ -372,7 +372,7 @@ miDCUnrealizeCursor (pScreen, pCursor)
 	if (pPriv->pPicture)
 	    FreePicture (pPriv->pPicture, 0);
 #endif
-	xfree ((void *) pPriv);
+	free ((void *) pPriv);
 	pCursor->bits->devPriv[pScreen->myNum] = (void *)NULL;
     }
     return TRUE;
diff --git a/nx-X11/programs/Xserver/mi/migc.c b/nx-X11/programs/Xserver/mi/migc.c
index 167163686..0ca7872a3 100644
--- a/nx-X11/programs/Xserver/mi/migc.c
+++ b/nx-X11/programs/Xserver/mi/migc.c
@@ -85,7 +85,7 @@ miDestroyGCOps(ops)
     GCOpsPtr        ops;
 {
     if (ops->devPrivate.val)
-	xfree(ops);
+	free(ops);
 }
 
 
@@ -136,7 +136,7 @@ miChangeClip(pGC, type, pvalue, nrects)
 	pGC->clientClip = (void *) RegionFromRects(nrects,
 						      (xRectangle *) pvalue,
 								    type);
-	xfree(pvalue);
+	free(pvalue);
     }
     pGC->clientClipType = (type != CT_NONE && pGC->clientClip) ? CT_REGION : CT_NONE;
     pGC->stateChanges |= GCClipMask;
diff --git a/nx-X11/programs/Xserver/mi/mioverlay.c b/nx-X11/programs/Xserver/mi/mioverlay.c
index e89ce8fa0..1c0402892 100644
--- a/nx-X11/programs/Xserver/mi/mioverlay.c
+++ b/nx-X11/programs/Xserver/mi/mioverlay.c
@@ -178,7 +178,7 @@ miOverlayCloseScreen(int i, ScreenPtr pScreen)
    pScreen->UnrealizeWindow = pScreenPriv->UnrealizeWindow;
    pScreen->RealizeWindow = pScreenPriv->RealizeWindow;
 
-   xfree(pScreenPriv);
+   free(pScreenPriv);
 
    return (*pScreen->CloseScreen)(i, pScreen);
 }
@@ -224,7 +224,7 @@ miOverlayCreateWindow(WindowPtr pWin)
 		RegionInit(&(pTree->borderClip), &fullBox, 1);
 		RegionInit(&(pTree->clipList), &fullBox, 1);
 	    }
-	} else xfree(pTree);
+	} else free(pTree);
     }
 
     return TRUE;
@@ -252,7 +252,7 @@ miOverlayDestroyWindow(WindowPtr pWin)
 
 	RegionUninit(&(pTree->borderClip));
 	RegionUninit(&(pTree->clipList));
-	xfree(pTree);
+	free(pTree);
     }
 
     if(pScreenPriv->DestroyWindow) {
@@ -874,7 +874,7 @@ miOverlayHandleExposures(WindowPtr pWin)
 		    (*WindowExposures)(pTree->pWin,&mival->exposed,NullRegion);
 		    RegionUninit(&mival->exposed);
 		}
-		xfree(mival);
+		free(mival);
 		pTree->valdata = NULL;
 		if (pTree->firstChild) {
 		    pTree = pTree->firstChild;
@@ -912,7 +912,7 @@ miOverlayHandleExposures(WindowPtr pWin)
 	    }
 	    RegionUninit(&val->after.borderExposed);
 	    RegionUninit(&val->after.exposed);
-	    xfree(val);
+	    free(val);
 	    pChild->valdata = (ValidatePtr)NULL;
 	    if (pChild->firstChild)
 	    {
diff --git a/nx-X11/programs/Xserver/mi/mipointer.c b/nx-X11/programs/Xserver/mi/mipointer.c
index 0320a5930..48da4b6c3 100644
--- a/nx-X11/programs/Xserver/mi/mipointer.c
+++ b/nx-X11/programs/Xserver/mi/mipointer.c
@@ -146,7 +146,7 @@ miPointerCloseScreen (index, pScreen)
     if (pScreen == miPointer.pSpriteScreen)
 	miPointer.pSpriteScreen = 0;
     pScreen->CloseScreen = pScreenPriv->CloseScreen;
-    xfree ((void *) pScreenPriv);
+    free ((void *) pScreenPriv);
     return (*pScreen->CloseScreen) (index, pScreen);
 }
 
diff --git a/nx-X11/programs/Xserver/mi/mipolyutil.c b/nx-X11/programs/Xserver/mi/mipolyutil.c
index be62250ee..7a9794fe3 100644
--- a/nx-X11/programs/Xserver/mi/mipolyutil.c
+++ b/nx-X11/programs/Xserver/mi/mipolyutil.c
@@ -395,7 +395,7 @@ miFreeStorage(pSLLBlock)
     while (pSLLBlock) 
     {
         tmpSLLBlock = pSLLBlock->next;
-        xfree(pSLLBlock);
+        free(pSLLBlock);
         pSLLBlock = tmpSLLBlock;
     }
 }
diff --git a/nx-X11/programs/Xserver/mi/mipushpxl.c b/nx-X11/programs/Xserver/mi/mipushpxl.c
index 44834db50..83821b266 100644
--- a/nx-X11/programs/Xserver/mi/mipushpxl.c
+++ b/nx-X11/programs/Xserver/mi/mipushpxl.c
@@ -252,7 +252,7 @@ miPushPixels(pGC, pBitMap, pDrawable, dx, dy, xOrg, yOrg)
 	    }
 	}
     }
-    xfree(pwLineStart);
+    free(pwLineStart);
     /* Flush any remaining spans */
     if (ipt)
     {
diff --git a/nx-X11/programs/Xserver/mi/miscrinit.c b/nx-X11/programs/Xserver/mi/miscrinit.c
index da80932ad..c0df4a072 100644
--- a/nx-X11/programs/Xserver/mi/miscrinit.c
+++ b/nx-X11/programs/Xserver/mi/miscrinit.c
@@ -180,7 +180,7 @@ miCreateScreenResources(pScreen)
     {
 	value = pScrInitParms->pbits;
     }
-    xfree(pScreen->devPrivate); /* freeing miScreenInitParmsRec */
+    free(pScreen->devPrivate); /* freeing miScreenInitParmsRec */
     pScreen->devPrivate = value; /* pPixmap or pbits */
     return TRUE;
 }
diff --git a/nx-X11/programs/Xserver/mi/mispans.c b/nx-X11/programs/Xserver/mi/mispans.c
index 48252f323..107476df3 100644
--- a/nx-X11/programs/Xserver/mi/mispans.c
+++ b/nx-X11/programs/Xserver/mi/mispans.c
@@ -216,15 +216,15 @@ void miAppendSpans(spanGroup, otherGroup, spans)
     }
     else
     {
-	xfree (spans->points);
-	xfree (spans->widths);
+	free (spans->points);
+	free (spans->widths);
     }
 } /* AppendSpans */
 
 void miFreeSpanGroup(spanGroup)
     SpanGroup   *spanGroup;
 {
-    if (spanGroup->group != NULL) xfree(spanGroup->group);
+    if (spanGroup->group != NULL) free(spanGroup->group);
 }
 
 static void QuickSortSpansX(
@@ -376,8 +376,8 @@ miDisposeSpanGroup (spanGroup)
     for (i = 0; i < spanGroup->count; i++)
     {
 	spans = spanGroup->group + i;
-	xfree (spans->points);
-	xfree (spans->widths);
+	free (spans->points);
+	free (spans->widths);
     }
 }
 
@@ -404,8 +404,8 @@ void miFillUniqueSpanGroup(pDraw, pGC, spanGroup)
 	spans = spanGroup->group;
 	(*pGC->ops->FillSpans)
 	    (pDraw, pGC, spans->count, spans->points, spans->widths, TRUE);
-	xfree(spans->points);
-	xfree(spans->widths);
+	free(spans->points);
+	free(spans->widths);
     }
     else
     {
@@ -424,9 +424,9 @@ void miFillUniqueSpanGroup(pDraw, pGC, spanGroup)
 	if (!yspans || !ysizes)
 	{
 	    if (yspans)
-		xfree (yspans);
+		free (yspans);
 	    if (ysizes)
-		xfree (ysizes);
+		free (ysizes);
 	    miDisposeSpanGroup (spanGroup);
 	    return;
 	}
@@ -468,11 +468,11 @@ void miFillUniqueSpanGroup(pDraw, pGC, spanGroup)
 
 			    for (i = 0; i < ylength; i++)
 			    {
-				xfree (yspans[i].points);
-				xfree (yspans[i].widths);
+				free (yspans[i].points);
+				free (yspans[i].widths);
 			    }
-			    xfree (yspans);
-			    xfree (ysizes);
+			    free (yspans);
+			    free (ysizes);
 			    miDisposeSpanGroup (spanGroup);
 			    return;
 			}
@@ -485,9 +485,9 @@ void miFillUniqueSpanGroup(pDraw, pGC, spanGroup)
 		} /* if y value of span in range */
 	    } /* for j through spans */
 	    count += spans->count;
-	    xfree(spans->points);
+	    free(spans->points);
 	    spans->points = NULL;
-	    xfree(spans->widths);
+	    free(spans->widths);
 	    spans->widths = NULL;
 	} /* for i thorough Spans */
 
@@ -500,15 +500,15 @@ void miFillUniqueSpanGroup(pDraw, pGC, spanGroup)
 
 	    for (i = 0; i < ylength; i++)
 	    {
-		xfree (yspans[i].points);
-		xfree (yspans[i].widths);
+		free (yspans[i].points);
+		free (yspans[i].widths);
 	    }
-	    xfree (yspans);
-	    xfree (ysizes);
+	    free (yspans);
+	    free (ysizes);
 	    if (points)
-		xfree (points);
+		free (points);
 	    if (widths)
-		xfree (widths);
+		free (widths);
 	    return;
 	}
 	count = 0;
@@ -524,16 +524,16 @@ void miFillUniqueSpanGroup(pDraw, pGC, spanGroup)
 		    widths[count] = yspans[i].widths[0];
 		    count++;
 		}
-		xfree(yspans[i].points);
-		xfree(yspans[i].widths);
+		free(yspans[i].points);
+		free(yspans[i].widths);
 	    }
 	}
 
 	(*pGC->ops->FillSpans) (pDraw, pGC, count, points, widths, TRUE);
-	xfree(points);
-	xfree(widths);
-	xfree(yspans);
-	xfree(ysizes);		/* use (DE)ALLOCATE_LOCAL for these? */
+	free(points);
+	free(widths);
+	free(yspans);
+	free(ysizes);		/* use (DE)ALLOCATE_LOCAL for these? */
     }
 
     spanGroup->count = 0;
@@ -553,8 +553,8 @@ void miFillSpanGroup(pDraw, pGC, spanGroup)
     for (i = 0, spans = spanGroup->group; i != spanGroup->count; i++, spans++) {
 	(*pGC->ops->FillSpans)
 	    (pDraw, pGC, spans->count, spans->points, spans->widths, TRUE);
-	xfree(spans->points);
-	xfree(spans->widths);
+	free(spans->points);
+	free(spans->widths);
     }
 
     spanGroup->count = 0;
diff --git a/nx-X11/programs/Xserver/mi/misprite.c b/nx-X11/programs/Xserver/mi/misprite.c
index c854984fc..2b68ad76a 100644
--- a/nx-X11/programs/Xserver/mi/misprite.c
+++ b/nx-X11/programs/Xserver/mi/misprite.c
@@ -182,7 +182,7 @@ miSpriteInitialize (pScreen, cursorFuncs, screenFuncs)
 
     if (!miPointerInitialize (pScreen, &miSpritePointerFuncs, screenFuncs,TRUE))
     {
-	xfree ((void *) pScreenPriv);
+	free ((void *) pScreenPriv);
 	return FALSE;
     }
     for (pVisual = pScreen->visuals;
@@ -270,7 +270,7 @@ miSpriteCloseScreen (i, pScreen)
     miSpriteIsUpFALSE (pScreen, pScreenPriv);
     DamageDestroy (pScreenPriv->pDamage);
     
-    xfree ((void *) pScreenPriv);
+    free ((void *) pScreenPriv);
 
     return (*pScreen->CloseScreen) (i, pScreen);
 }
diff --git a/nx-X11/programs/Xserver/mi/miwideline.c b/nx-X11/programs/Xserver/mi/miwideline.c
index fa9ef4591..f3e8c691a 100644
--- a/nx-X11/programs/Xserver/mi/miwideline.c
+++ b/nx-X11/programs/Xserver/mi/miwideline.c
@@ -133,7 +133,7 @@ miFillPolyHelper (pDrawable, pGC, pixel, spanData, y, overall_height,
 	spanRec.widths = (int *) xalloc (overall_height * sizeof (int));
 	if (!spanRec.widths)
 	{
-	    xfree (spanRec.points);
+	    free (spanRec.points);
 	    return;
 	}
 	ppt = spanRec.points;
@@ -237,7 +237,7 @@ miFillRectPolyHelper (
 	spanRec.widths = (int *) xalloc (h * sizeof (int));
 	if (!spanRec.widths)
 	{
-	    xfree (spanRec.points);
+	    free (spanRec.points);
 	    return;
 	}
 	ppt = spanRec.points;
@@ -1082,7 +1082,7 @@ miLineArc (
 	widths = (int *) xalloc (pGC->lineWidth * sizeof (int));
 	if (!widths)
 	{
-	    xfree (points);
+	    free (points);
 	    return;
 	}
 	spanRec.points = points;
diff --git a/nx-X11/programs/Xserver/mi/miwindow.c b/nx-X11/programs/Xserver/mi/miwindow.c
index aff7128c3..9e87e7095 100644
--- a/nx-X11/programs/Xserver/mi/miwindow.c
+++ b/nx-X11/programs/Xserver/mi/miwindow.c
@@ -471,7 +471,7 @@ miHandleValidateExposures(pWin)
 	    RegionUninit(&val->after.borderExposed);
 	    (*WindowExposures)(pChild, &val->after.exposed, NullRegion);
 	    RegionUninit(&val->after.exposed);
-	    xfree(val);
+	    free(val);
 	    pChild->valdata = (ValidatePtr)NULL;
 	    if (pChild->firstChild)
 	    {
diff --git a/nx-X11/programs/Xserver/miext/cw/cw.c b/nx-X11/programs/Xserver/miext/cw/cw.c
index 9f39b9650..5b2c65927 100644
--- a/nx-X11/programs/Xserver/miext/cw/cw.c
+++ b/nx-X11/programs/Xserver/miext/cw/cw.c
@@ -693,7 +693,7 @@ cwCloseScreen (int i, ScreenPtr pScreen)
 	cwFiniRender(pScreen);
 #endif
 
-    xfree((void *)pScreenPriv);
+    free((void *)pScreenPriv);
 
     return (*pScreen->CloseScreen)(i, pScreen);
 }
diff --git a/nx-X11/programs/Xserver/miext/cw/cw_render.c b/nx-X11/programs/Xserver/miext/cw/cw_render.c
index 74c52afb0..2710bf60f 100644
--- a/nx-X11/programs/Xserver/miext/cw/cw_render.c
+++ b/nx-X11/programs/Xserver/miext/cw/cw_render.c
@@ -84,7 +84,7 @@ cwCreatePicturePrivate (PicturePtr pPicture)
 						      &error);
     if (!pPicturePrivate->pBackingPicture)
     {
-	xfree (pPicturePrivate);
+	free (pPicturePrivate);
 	return NULL;
     }
 
@@ -108,7 +108,7 @@ cwDestroyPicturePrivate (PicturePtr pPicture)
     {
 	if (pPicturePrivate->pBackingPicture)
 	    FreePicture (pPicturePrivate->pBackingPicture, 0);
-	xfree (pPicturePrivate);
+	free (pPicturePrivate);
 	setCwPicture(pPicture, NULL);
     }
 }
diff --git a/nx-X11/programs/Xserver/miext/damage/damage.c b/nx-X11/programs/Xserver/miext/damage/damage.c
index f28d95820..2d6783204 100755
--- a/nx-X11/programs/Xserver/miext/damage/damage.c
+++ b/nx-X11/programs/Xserver/miext/damage/damage.c
@@ -1726,7 +1726,7 @@ damageCloseScreen (int i, ScreenPtr pScreen)
     unwrap (pScrPriv, pScreen, CopyWindow);
     unwrap (pScrPriv, pScreen, CloseScreen);
     unwrap (pScrPriv, pScreen, BackingStoreFuncs.RestoreAreas);
-    xfree (pScrPriv);
+    free (pScrPriv);
     return (*pScreen->CloseScreen) (i, pScreen);
 }
 
@@ -1913,7 +1913,7 @@ DamageDestroy (DamagePtr    pDamage)
     if (pDamage->damageDestroy)
 	(*pDamage->damageDestroy) (pDamage, pDamage->closure);
     RegionUninit(&pDamage->damage);
-    xfree (pDamage);
+    free (pDamage);
 }
 
 Bool
diff --git a/nx-X11/programs/Xserver/os/WaitFor.c b/nx-X11/programs/Xserver/os/WaitFor.c
index 0a18c28c8..f9037ed3b 100644
--- a/nx-X11/programs/Xserver/os/WaitFor.c
+++ b/nx-X11/programs/Xserver/os/WaitFor.c
@@ -730,7 +730,7 @@ TimerFree(OsTimerPtr timer)
     if (!timer)
 	return;
     TimerCancel(timer);
-    xfree(timer);
+    free(timer);
 }
 
 void
@@ -750,7 +750,7 @@ TimerInit(void)
     while ((timer = timers))
     {
 	timers = timer->next;
-	xfree(timer);
+	free(timer);
     }
 }
 
diff --git a/nx-X11/programs/Xserver/os/access.c b/nx-X11/programs/Xserver/os/access.c
index 7f45e5ec9..dcd2b52af 100644
--- a/nx-X11/programs/Xserver/os/access.c
+++ b/nx-X11/programs/Xserver/os/access.c
@@ -261,7 +261,7 @@ typedef struct _host {
 			   (h)->addr=(unsigned char *) ((h) + 1);\
 			   (h)->requested = FALSE; \
 			}
-#define FreeHost(h)	xfree(h)
+#define FreeHost(h)	free(h)
 static HOST *selfhosts = NULL;
 static HOST *validhosts = NULL;
 static int AccessEnabled = DEFAULT_ACCESS_CONTROL;
@@ -1376,12 +1376,12 @@ Bool LocalClient(ClientPtr client)
 	    &alen, (void **)&addr);
 	if (family == -1)
 	{
-	    xfree ((char *) from);
+	    free ((char *) from);
 	    return FALSE;
 	}
 	if (family == FamilyLocal)
 	{
-	    xfree ((char *) from);
+	    free ((char *) from);
 	    return TRUE;
 	}
 	for (host = selfhosts; host; host = host->next)
@@ -1389,7 +1389,7 @@ Bool LocalClient(ClientPtr client)
 	    if (addrEqual (family, addr, alen, host))
 		return TRUE;
 	}
-	xfree ((char *) from);
+	free ((char *) from);
     }
     return FALSE;
 }
@@ -2327,7 +2327,7 @@ siLocalCredGetId(const char *addr, int len, siLocalCredPrivPtr lcPriv, int *id)
 	}
     }
 
-    xfree(addrbuf);
+    free(addrbuf);
     return parsedOK;
 }
 
@@ -2360,11 +2360,11 @@ siLocalCredAddrMatch(int family, void * addr, int len,
 
 	    for (i = 0 ; i < connNumSuppGids; i++) {
 		if (connSuppGids[i] == siAddrId) {
-		    xfree(connSuppGids);
+		    free(connSuppGids);
 		    return TRUE;
 		}
 	    }
-	    xfree(connSuppGids);
+	    free(connSuppGids);
 	}
     }
     return FALSE;
diff --git a/nx-X11/programs/Xserver/os/connection.c b/nx-X11/programs/Xserver/os/connection.c
index 2df92bf91..4d5826888 100644
--- a/nx-X11/programs/Xserver/os/connection.c
+++ b/nx-X11/programs/Xserver/os/connection.c
@@ -279,7 +279,7 @@ void ClearConnectionTranslation(void)
         {
             struct _ct_node *temp = node;
             node = node->next;
-            xfree(temp);
+            free(temp);
         }
     }
 }
@@ -713,7 +713,7 @@ ClientAuthorized(ClientPtr client,
 			proto_n, auth_proto, auth_id);
 	    }
 
-	    xfree ((char *) from);
+	    free ((char *) from);
 	}
 
 	if (auth_id == (XID) ~0L) {
@@ -731,7 +731,7 @@ ClientAuthorized(ClientPtr client,
 	    AuthAudit(client, TRUE, (struct sockaddr *) from, fromlen,
 		      proto_n, auth_proto, auth_id);
 
-	    xfree ((char *) from);
+	    free ((char *) from);
 	}
     }
     priv->auth_id = auth_id;
@@ -775,7 +775,7 @@ AllocNewConnection (XtransConnInfo trans_conn, int fd, CARD32 conn_time)
     oc->conn_time = conn_time;
     if (!(client = NextAvailableClient((void *)oc)))
     {
-	xfree (oc);
+	free (oc);
 	return NullClient;
     }
     {
@@ -962,7 +962,7 @@ CloseDownFileDescriptor(OsCommPtr oc)
 	_XSERVTransClose(oc->trans_conn);
     }
     FreeOsBuffers(oc);
-    xfree(oc);
+    free(oc);
 #ifndef WIN32
     ConnectionTranslation[connection] = 0;
 #else
diff --git a/nx-X11/programs/Xserver/os/io.c b/nx-X11/programs/Xserver/os/io.c
index fefe3007f..b8f05d939 100644
--- a/nx-X11/programs/Xserver/os/io.c
+++ b/nx-X11/programs/Xserver/os/io.c
@@ -222,8 +222,8 @@ ReadRequestFromClient(ClientPtr client)
 	    register ConnectionInputPtr aci = AvailableInput->input;
 	    if (aci->size > BUFWATERMARK)
 	    {
-		xfree(aci->buffer);
-		xfree(aci);
+		free(aci->buffer);
+		free(aci);
 	    }
 	    else
 	    {
@@ -504,8 +504,8 @@ InsertFakeRequest(ClientPtr client, char *data, int count)
 	    ConnectionInputPtr aci = AvailableInput->input;
 	    if (aci->size > BUFWATERMARK)
 	    {
-		xfree(aci->buffer);
-		xfree(aci);
+		free(aci->buffer);
+		free(aci);
 	    }
 	    else
 	    {
@@ -1154,8 +1154,8 @@ FlushClient(ClientPtr who, OsCommPtr oc, char *extraBuf, int extraCount)
     }
     if (oco->size > BUFWATERMARK)
     {
-	xfree(oco->buf);
-	xfree(oco);
+	free(oco->buf);
+	free(oco);
     }
     else
     {
@@ -1177,7 +1177,7 @@ AllocateInputBuffer(void)
     oci->buffer = (char *)xalloc(BUFSIZE);
     if (!oci->buffer)
     {
-	xfree(oci);
+	free(oci);
 	return (ConnectionInputPtr)NULL;
     }
     oci->size = BUFSIZE;
@@ -1198,7 +1198,7 @@ AllocateOutputBuffer(void)
     oco->buf = (unsigned char *) xalloc(BUFSIZE);
     if (!oco->buf)
     {
-	xfree(oco);
+	free(oco);
 	return (ConnectionOutputPtr)NULL;
     }
     oco->size = BUFSIZE;
@@ -1218,8 +1218,8 @@ FreeOsBuffers(OsCommPtr oc)
     {
 	if (FreeInputs)
 	{
-	    xfree(oci->buffer);
-	    xfree(oci);
+	    free(oci->buffer);
+	    free(oci);
 	}
 	else
 	{
@@ -1234,8 +1234,8 @@ FreeOsBuffers(OsCommPtr oc)
     {
 	if (FreeOutputs)
 	{
-	    xfree(oco->buf);
-	    xfree(oco);
+	    free(oco->buf);
+	    free(oco);
 	}
 	else
 	{
@@ -1255,13 +1255,13 @@ ResetOsBuffers(void)
     while ((oci = FreeInputs))
     {
 	FreeInputs = oci->next;
-	xfree(oci->buffer);
-	xfree(oci);
+	free(oci->buffer);
+	free(oci);
     }
     while ((oco = FreeOutputs))
     {
 	FreeOutputs = oco->next;
-	xfree(oco->buf);
-	xfree(oco);
+	free(oco->buf);
+	free(oco);
     }
 }
diff --git a/nx-X11/programs/Xserver/os/log.c b/nx-X11/programs/Xserver/os/log.c
index 84381dbf2..12827cbe0 100644
--- a/nx-X11/programs/Xserver/os/log.c
+++ b/nx-X11/programs/Xserver/os/log.c
@@ -236,7 +236,7 @@ LogInit(const char *fname, const char *backup)
      * needed.
      */
     if (saveBuffer && bufferSize > 0) {
-	free(saveBuffer);	/* Must be free(), not xfree() */
+	free(saveBuffer);	/* Must be free(), not free() */
 	saveBuffer = NULL;
 	bufferSize = 0;
     }
diff --git a/nx-X11/programs/Xserver/os/mitauth.c b/nx-X11/programs/Xserver/os/mitauth.c
index abf7976af..4c1ae9cf6 100644
--- a/nx-X11/programs/Xserver/os/mitauth.c
+++ b/nx-X11/programs/Xserver/os/mitauth.c
@@ -62,7 +62,7 @@ MitAddCookie (
 	return 0;
     new->data = (char *) xalloc ((unsigned) data_length);
     if (!new->data) {
-	xfree(new);
+	free(new);
 	return 0;
     }
     new->next = mit_auth;
@@ -98,8 +98,8 @@ MitResetCookie (void)
 
     for (auth = mit_auth; auth; auth=next) {
 	next = auth->next;
-	xfree (auth->data);
-	xfree (auth);
+	free (auth->data);
+	free (auth);
     }
     mit_auth = 0;
     return 0;
@@ -154,8 +154,8 @@ MitRemoveCookie (
 		prev->next = auth->next;
 	    else
 		mit_auth = auth->next;
-	    xfree (auth->data);
-	    xfree (auth);
+	    free (auth->data);
+	    free (auth);
 	    return 1;
 	}
     }
diff --git a/nx-X11/programs/Xserver/os/oscolor.c b/nx-X11/programs/Xserver/os/oscolor.c
index a8b01b4b9..8f737eaba 100644
--- a/nx-X11/programs/Xserver/os/oscolor.c
+++ b/nx-X11/programs/Xserver/os/oscolor.c
@@ -152,7 +152,7 @@ OsLookupColor(int screen, char *name, unsigned int len,
 #endif
 
     if (len >= sizeof(buf))
-	xfree(lowername);
+	free(lowername);
 
     if(dbent.dptr)
     {
diff --git a/nx-X11/programs/Xserver/os/rpcauth.c b/nx-X11/programs/Xserver/os/rpcauth.c
index 91823553c..1b3db1e0e 100644
--- a/nx-X11/programs/Xserver/os/rpcauth.c
+++ b/nx-X11/programs/Xserver/os/rpcauth.c
@@ -121,7 +121,7 @@ authdes_ezdecode(char *inmsg, int len)
     return (((struct authdes_cred *) r.rq_clntcred)->adc_fullname.name); 
 
 bad2:
-    xfree(r.rq_clntcred);
+    free(r.rq_clntcred);
 bad1:
     return ((char *)0); /* ((struct authdes_cred *) NULL); */
 }
diff --git a/nx-X11/programs/Xserver/os/utils.c b/nx-X11/programs/Xserver/os/utils.c
index 90cf55d1a..03deb811a 100644
--- a/nx-X11/programs/Xserver/os/utils.c
+++ b/nx-X11/programs/Xserver/os/utils.c
@@ -1812,7 +1812,7 @@ Popen(char *command, char *type)
 	return NULL;
 
     if (pipe(pdes) < 0) {
-	xfree(cur);
+	free(cur);
 	return NULL;
     }
 
@@ -1826,7 +1826,7 @@ Popen(char *command, char *type)
     case -1: 	/* error */
 	close(pdes[0]);
 	close(pdes[1]);
-	xfree(cur);
+	free(cur);
 #ifdef NX_TRANS_EXIT
 	if (OsVendorEndRedirectErrorFProc != NULL) {
 	    OsVendorEndRedirectErrorFProc();
@@ -1950,7 +1950,7 @@ Fopen(char *file, char *type)
 	return NULL;
 
     if (pipe(pdes) < 0) {
-	xfree(cur);
+	free(cur);
 	return NULL;
     }
 
@@ -1958,7 +1958,7 @@ Fopen(char *file, char *type)
     case -1: 	/* error */
 	close(pdes[0]);
 	close(pdes[1]);
-	xfree(cur);
+	free(cur);
 	return NULL;
     case 0:	/* child */
 	if (setgid(getgid()) == -1)
@@ -2052,7 +2052,7 @@ Pclose(void * iop)
 	pidlist = cur->next;
     else
 	last->next = cur->next;
-    xfree(cur);
+    free(cur);
 
     /* allow EINTR again */
     OsReleaseSignals ();
diff --git a/nx-X11/programs/Xserver/os/xdmauth.c b/nx-X11/programs/Xserver/os/xdmauth.c
index 92fbde478..b55f75a36 100644
--- a/nx-X11/programs/Xserver/os/xdmauth.c
+++ b/nx-X11/programs/Xserver/os/xdmauth.c
@@ -240,7 +240,7 @@ XdmClientAuthTimeout (long now)
 		prev->next = next;
 	    else
 		xdmClients = next;
-	    xfree (client);
+	    free (client);
 	}
 	else
 	    prev = client;
@@ -266,14 +266,14 @@ XdmAuthorizationValidate (unsigned char *plain, int length,
     XdmClientAuthDecode (plain, client);
     if (!XdmcpCompareKeys (&client->rho, rho))
     {
-	xfree (client);
+	free (client);
 	if (reason)
 	    *reason = "Invalid XDM-AUTHORIZATION-1 key (failed key comparison)";
 	return NULL;
     }
     for (i = 18; i < 24; i++)
 	if (plain[i] != 0) {
-	    xfree (client);
+	    free (client);
 	    if (reason)
 		*reason = "Invalid XDM-AUTHORIZATION-1 key (failed NULL check)";
 	    return NULL;
@@ -288,15 +288,15 @@ XdmAuthorizationValidate (unsigned char *plain, int length,
 #if defined(TCPCONN) || defined(STREAMSCONN)
 	    if (family == FamilyInternet &&
 		memcmp((char *)addr, client->client, 4) != 0) {
-		xfree (client);
-		xfree (addr);
+		free (client);
+		free (addr);
 		if (reason)
 		    *reason = "Invalid XDM-AUTHORIZATION-1 key (failed address comparison)";
 		return NULL;
 
 	    }
 #endif
-	    xfree (addr);
+	    free (addr);
 	}
     }
     now = time(0);
@@ -309,7 +309,7 @@ XdmAuthorizationValidate (unsigned char *plain, int length,
     XdmClientAuthTimeout (now);
     if (abs (client->time - now) > TwentyMinutes)
     {
-	xfree (client);
+	free (client);
 	if (reason)
 	    *reason = "Excessive XDM-AUTHORIZATION-1 time offset";
 	return NULL;
@@ -318,7 +318,7 @@ XdmAuthorizationValidate (unsigned char *plain, int length,
     {
 	if (XdmClientAuthCompare (existing, client))
 	{
-	    xfree (client);
+	    free (client);
 	    if (reason)
 		*reason = "XDM authorization key matches an existing client!";
 	    return NULL;
@@ -395,11 +395,11 @@ XdmCheckCookie (unsigned short cookie_length, char *cookie,
 	{
 	    client->next = xdmClients;
 	    xdmClients = client;
-	    xfree (plain);
+	    free (plain);
 	    return auth->id;
 	}
     }
-    xfree (plain);
+    free (plain);
     return (XID) -1;
 }
 
@@ -412,13 +412,13 @@ XdmResetCookie (void)
     for (auth = xdmAuth; auth; auth=next_auth)
     {
 	next_auth = auth->next;
-	xfree (auth);
+	free (auth);
     }
     xdmAuth = 0;
     for (client = xdmClients; client; client=next_client)
     {
 	next_client = client->next;
-	xfree (client);
+	free (client);
     }
     xdmClients = (XdmClientAuthPtr) 0;
     return 1;
@@ -438,12 +438,12 @@ XdmToID (unsigned short cookie_length, char *cookie)
 	XdmcpUnwrap (cookie, (unsigned char *)&auth->key, plain, cookie_length);
 	if ((client = XdmAuthorizationValidate (plain, cookie_length, &auth->rho, NULL, NULL)) != NULL)
 	{
-	    xfree (client);
-	    xfree (cookie);
+	    free (client);
+	    free (cookie);
 	    return auth->id;
 	}
     }
-    xfree (cookie);
+    free (cookie);
     return (XID) -1;
 }
 
@@ -492,7 +492,7 @@ XdmRemoveCookie (unsigned short data_length, char *data)
 		prev->next = auth->next;
 	    else
 		xdmAuth = auth->next;
-	    xfree (auth);
+	    free (auth);
 	    return 1;
 	}
     }
diff --git a/nx-X11/programs/Xserver/os/xdmcp.c b/nx-X11/programs/Xserver/os/xdmcp.c
index 4181e52ce..29785f48e 100644
--- a/nx-X11/programs/Xserver/os/xdmcp.c
+++ b/nx-X11/programs/Xserver/os/xdmcp.c
@@ -419,7 +419,7 @@ XdmcpRegisterAuthentication (
     newFuncs[AuthenticationNames.length-1].Validator = Validator;
     newFuncs[AuthenticationNames.length-1].Generator = Generator;
     newFuncs[AuthenticationNames.length-1].AddAuth = AddAuth;
-    xfree (AuthenticationFuncsList);
+    free (AuthenticationFuncsList);
     AuthenticationFuncsList = newFuncs;
     AuthenticationNames.data[AuthenticationNames.length-1] = AuthenticationName;
     AuthenticationDatas.data[AuthenticationDatas.length-1] = AuthenticationData;
@@ -512,13 +512,13 @@ XdmcpRegisterConnection (
 	return;
     if (!XdmcpReallocARRAY16 (&ConnectionTypes, ConnectionTypes.length + 1))
     {
-	xfree (newAddress);
+	free (newAddress);
 	return;
     }
     if (!XdmcpReallocARRAYofARRAY8 (&ConnectionAddresses,
 				    ConnectionAddresses.length +  1))
     {
-	xfree (newAddress);
+	free (newAddress);
 	return;
     }
     ConnectionTypes.data[ConnectionTypes.length - 1] = (CARD16) type;
@@ -553,7 +553,7 @@ XdmcpRegisterAuthorization (char *name, int namelen)
 	return;
     if (!XdmcpReallocARRAYofARRAY8 (&AuthorizationNames, AuthorizationNames.length +1))
     {
-	xfree (authName.data);
+	free (authName.data);
 	return;
     }
     for (i = 0; i < namelen; i++)
diff --git a/nx-X11/programs/Xserver/randr/randr.c b/nx-X11/programs/Xserver/randr/randr.c
index b78a947c8..afce35d7d 100644
--- a/nx-X11/programs/Xserver/randr/randr.c
+++ b/nx-X11/programs/Xserver/randr/randr.c
@@ -131,9 +131,9 @@ RRCloseScreen(
 
     RRMonitorClose(pScreen);
 
-    xfree(pScrPriv->crtcs);
-    xfree(pScrPriv->outputs);
-    xfree(pScrPriv);
+    free(pScrPriv->crtcs);
+    free(pScrPriv->outputs);
+    free(pScrPriv);
     RRNScreens -= 1;            /* ok, one fewer screen with RandR running */
     return (*pScreen->CloseScreen) (i, pScreen);
 }
@@ -405,7 +405,7 @@ RRFreeClient(void *data, XID id)
                 *pHead = pRREvent->next;
         }
     }
-    xfree((void *) pRREvent);
+    free((void *) pRREvent);
     return 1;
 }
 
@@ -418,9 +418,9 @@ RRFreeEvents(void *data, XID id)
     for (pCur = *pHead; pCur; pCur = pNext) {
         pNext = pCur->next;
         FreeResource(pCur->clientResource, RRClientType);
-        xfree((void *) pCur);
+        free((void *) pCur);
     }
-    xfree((void *) pHead);
+    free((void *) pHead);
     return 1;
 }
 
diff --git a/nx-X11/programs/Xserver/randr/rrcrtc.c b/nx-X11/programs/Xserver/randr/rrcrtc.c
index d69b5ec08..6fb6e02e6 100644
--- a/nx-X11/programs/Xserver/randr/rrcrtc.c
+++ b/nx-X11/programs/Xserver/randr/rrcrtc.c
@@ -215,7 +215,7 @@ RRCrtcNotify(RRCrtcPtr crtc,
                 return FALSE;
         }
         else {
-            xfree(crtc->outputs);
+            free(crtc->outputs);
             newoutputs = NULL;
         }
         crtc->outputs = newoutputs;
@@ -391,7 +391,7 @@ RRComputeContiguity(ScreenPtr pScreen)
     discontiguous = FALSE;
 
  out:
-    xfree(reachable);
+    free(reachable);
     pScrPriv->discontiguous = discontiguous;
 }
 
@@ -778,10 +778,10 @@ RRCrtcDestroyResource(void *value, XID pid)
 
     if (crtc->scanout_pixmap)
         RRCrtcDetachScanoutPixmap(crtc);
-    xfree(crtc->gammaRed);
+    free(crtc->gammaRed);
     if (crtc->mode)
         RRModeDestroy(crtc->mode);
-    xfree(crtc);
+    free(crtc);
     return 1;
 }
 
@@ -899,7 +899,7 @@ RRCrtcGammaSetSize(RRCrtcPtr crtc, int size)
     }
     else
         gamma = NULL;
-    xfree(crtc->gammaRed);
+    free(crtc->gammaRed);
     crtc->gammaRed = gamma;
     crtc->gammaGreen = gamma + size;
     crtc->gammaBlue = gamma + size * 2;
@@ -1089,7 +1089,7 @@ ProcRRGetCrtcInfo(ClientPtr client)
     WriteToClient(client, sizeof(xRRGetCrtcInfoReply), (char *) &rep);
     if (extraLen) {
         WriteToClient(client, extraLen, (char *) extra);
-        xfree(extra);
+        free(extra);
     }
 
     return Success;
@@ -1151,7 +1151,7 @@ ProcRRSetCrtcConfig(ClientPtr client)
                                       RROutputType, client, DixSetAttrAccess);
 
         if (ret != Success) {
-            xfree(outputs);
+            free(outputs);
             return ret;
         }
 #else                           /* !defined(NXAGENT_SERVER) */
@@ -1159,7 +1159,7 @@ ProcRRSetCrtcConfig(ClientPtr client)
         if (!outputs[i]) {
             client->errorValue = outputIds[i];
             if (outputs)
-                xfree(outputs);
+                free(outputs);
             return RRErrorBase + BadRROutput;
         }
 #endif                          /* !defined(NXAGENT_SERVER) */
@@ -1168,7 +1168,7 @@ ProcRRSetCrtcConfig(ClientPtr client)
             if (outputs[i]->crtcs[j] == crtc)
                 break;
         if (j == outputs[i]->numCrtcs) {
-            xfree(outputs);
+            free(outputs);
             return BadMatch;
         }
         /* validate mode for this output */
@@ -1180,7 +1180,7 @@ ProcRRSetCrtcConfig(ClientPtr client)
                 break;
         }
         if (j == outputs[i]->numModes + outputs[i]->numUserModes) {
-            xfree(outputs);
+            free(outputs);
             return BadMatch;
         }
     }
@@ -1196,7 +1196,7 @@ ProcRRSetCrtcConfig(ClientPtr client)
                     break;
             }
             if (k == outputs[i]->numClones) {
-                xfree(outputs);
+                free(outputs);
                 return BadMatch;
             }
         }
@@ -1230,7 +1230,7 @@ ProcRRSetCrtcConfig(ClientPtr client)
          * Invalid rotation
          */
         client->errorValue = stuff->rotation;
-        xfree(outputs);
+        free(outputs);
         return BadValue;
     }
 
@@ -1240,7 +1240,7 @@ ProcRRSetCrtcConfig(ClientPtr client)
              * requested rotation or reflection not supported by screen
              */
             client->errorValue = stuff->rotation;
-            xfree(outputs);
+            free(outputs);
             return BadMatch;
         }
 
@@ -1282,13 +1282,13 @@ ProcRRSetCrtcConfig(ClientPtr client)
                                  &source_height);
             if (stuff->x + source_width > width) {
                 client->errorValue = stuff->x;
-                xfree(outputs);
+                free(outputs);
                 return BadValue;
             }
 
             if (stuff->y + source_height > height) {
                 client->errorValue = stuff->y;
-                xfree(outputs);
+                free(outputs);
                 return BadValue;
             }
         }
@@ -1304,7 +1304,7 @@ ProcRRSetCrtcConfig(ClientPtr client)
     pScrPriv->lastSetTime = time;
 
  sendReply:
-    xfree(outputs);
+    free(outputs);
 
     rep = (xRRSetCrtcConfigReply) {
         .type = X_Reply,
@@ -1535,7 +1535,7 @@ ProcRRGetCrtcGamma(ClientPtr client)
         memcpy(extra, crtc->gammaRed, len);
         client->pSwapReplyFunc = (ReplySwapPtr) CopySwap16Write;
         WriteSwappedDataToClient(client, len, extra);
-        xfree(extra);
+        free(extra);
     }
     return Success;
 }
@@ -1700,7 +1700,7 @@ ProcRRGetCrtcTransform(ClientPtr client)
     }
     WriteToClient(client, sizeof(xRRGetCrtcTransformReply) + nextra,
                   (char *) reply);
-    xfree(reply);
+    free(reply);
     return Success;
 }
 
@@ -1894,7 +1894,7 @@ RRReplaceScanoutPixmap(DrawablePtr pDrawable, PixmapPtr pPixmap, Bool enable)
         else
             crtc->scanout_pixmap = saved_scanout_pixmap[i];
     }
-    xfree(saved_scanout_pixmap);
+    free(saved_scanout_pixmap);
 
     return ret;
 }
diff --git a/nx-X11/programs/Xserver/randr/rrdispatch.c b/nx-X11/programs/Xserver/randr/rrdispatch.c
index b15d1ad20..271d5d939 100644
--- a/nx-X11/programs/Xserver/randr/rrdispatch.c
+++ b/nx-X11/programs/Xserver/randr/rrdispatch.c
@@ -212,7 +212,7 @@ ProcRRSelectInput(ClientPtr client)
                     pNewRREvent->next = pRREvent->next;
                 else
                     *pHead = pRREvent->next;
-                xfree(pRREvent);
+                free(pRREvent);
             }
         }
     }
diff --git a/nx-X11/programs/Xserver/randr/rrinfo.c b/nx-X11/programs/Xserver/randr/rrinfo.c
index df9b79986..4c47fb903 100644
--- a/nx-X11/programs/Xserver/randr/rrinfo.c
+++ b/nx-X11/programs/Xserver/randr/rrinfo.c
@@ -132,7 +132,7 @@ RRScanOldConfig(ScreenPtr pScreen, Rotation rotations)
                     newMode = mode;
                 }
             }
-            xfree(size->pRates);
+            free(size->pRates);
         }
         else {
             mode = RROldModeAdd(output, size, 0);
@@ -141,7 +141,7 @@ RRScanOldConfig(ScreenPtr pScreen, Rotation rotations)
         }
     }
     if (pScrPriv->nSizes)
-        xfree(pScrPriv->pSizes);
+        free(pScrPriv->pSizes);
     pScrPriv->pSizes = NULL;
     pScrPriv->nSizes = 0;
 
diff --git a/nx-X11/programs/Xserver/randr/rrmode.c b/nx-X11/programs/Xserver/randr/rrmode.c
index 918e0f221..3d84a0516 100644
--- a/nx-X11/programs/Xserver/randr/rrmode.c
+++ b/nx-X11/programs/Xserver/randr/rrmode.c
@@ -106,13 +106,13 @@ RRModeCreate(xRRModeInfo * modeInfo, const char *name, ScreenPtr userScreen)
         newModes = xalloc(sizeof(RRModePtr));
 
     if (!newModes) {
-        xfree(mode);
+        free(mode);
         return NULL;
     }
 
     mode->mode.id = FakeClientID(0);
     if (!AddResource(mode->mode.id, RRModeType, (void *) mode)) {
-        xfree(newModes);
+        free(newModes);
         return NULL;
     }
     modes = newModes;
@@ -285,14 +285,14 @@ RRModeDestroy(RRModePtr mode)
                     (num_modes - m - 1) * sizeof(RRModePtr));
             num_modes--;
             if (!num_modes) {
-                xfree(modes);
+                free(modes);
                 modes = NULL;
             }
             break;
         }
     }
 
-    xfree(mode);
+    free(mode);
 }
 
 static int
diff --git a/nx-X11/programs/Xserver/randr/rrmonitor.c b/nx-X11/programs/Xserver/randr/rrmonitor.c
index fc9b9295b..36543cb4c 100644
--- a/nx-X11/programs/Xserver/randr/rrmonitor.c
+++ b/nx-X11/programs/Xserver/randr/rrmonitor.c
@@ -298,7 +298,7 @@ RRMonitorInitList(ScreenPtr screen, RRMonitorListPtr mon_list, Bool get_active)
 static void
 RRMonitorFiniList(RRMonitorListPtr list)
 {
-    xfree(list->server_crtc);
+    free(list->server_crtc);
 }
 
 /* Construct a complete list of protocol-visible monitors, including
@@ -401,7 +401,7 @@ RRMonitorCountList(ScreenPtr screen)
 void
 RRMonitorFree(RRMonitorPtr monitor)
 {
-    xfree(monitor);
+    free(monitor);
 }
 
 RRMonitorPtr
@@ -573,8 +573,8 @@ RRMonitorFreeList(RRMonitorPtr monitors, int nmon)
     int m;
 
     for (m = 0; m < nmon; m++)
-        xfree(monitors[m].outputs);
-    xfree(monitors);
+        free(monitors[m].outputs);
+    free(monitors);
 }
 
 void
@@ -600,7 +600,7 @@ RRMonitorClose(ScreenPtr screen)
 
     for (m = 0; m < pScrPriv->numMonitors; m++)
         RRMonitorFree(pScrPriv->monitors[m]);
-    xfree(pScrPriv->monitors);
+    free(pScrPriv->monitors);
     pScrPriv->monitors = NULL;
     pScrPriv->numMonitors = 0;
 }
diff --git a/nx-X11/programs/Xserver/randr/rroutput.c b/nx-X11/programs/Xserver/randr/rroutput.c
index 2628fabb0..46948c577 100644
--- a/nx-X11/programs/Xserver/randr/rroutput.c
+++ b/nx-X11/programs/Xserver/randr/rroutput.c
@@ -154,7 +154,7 @@ RROutputSetClones(RROutputPtr output, RROutputPtr * clones, int numClones)
     }
     else
         newClones = NULL;
-    xfree(output->clones);
+    free(output->clones);
     memcpy(newClones, clones, numClones * sizeof(RROutputPtr));
     output->clones = newClones;
     output->numClones = numClones;
@@ -194,7 +194,7 @@ RROutputSetModes(RROutputPtr output,
     if (output->modes) {
         for (i = 0; i < output->numModes; i++)
             RRModeDestroy(output->modes[i]);
-        xfree(output->modes);
+        free(output->modes);
     }
     memcpy(newModes, modes, numModes * sizeof(RRModePtr));
     output->modes = newModes;
@@ -299,7 +299,7 @@ RROutputSetCrtcs(RROutputPtr output, RRCrtcPtr * crtcs, int numCrtcs)
     }
     else
         newCrtcs = NULL;
-    xfree(output->crtcs);
+    free(output->crtcs);
     memcpy(newCrtcs, crtcs, numCrtcs * sizeof(RRCrtcPtr));
     output->crtcs = newCrtcs;
     output->numCrtcs = numCrtcs;
@@ -404,17 +404,17 @@ RROutputDestroyResource(void *value, XID pid)
     if (output->modes) {
         for (m = 0; m < output->numModes; m++)
             RRModeDestroy(output->modes[m]);
-        xfree(output->modes);
+        free(output->modes);
     }
 
     for (m = 0; m < output->numUserModes; m++)
         RRModeDestroy(output->userModes[m]);
-    xfree(output->userModes);
+    free(output->userModes);
 
-    xfree(output->crtcs);
-    xfree(output->clones);
+    free(output->crtcs);
+    free(output->clones);
     RRDeleteAllOutputProperties(output);
-    xfree(output);
+    free(output);
     return 1;
 }
 
@@ -541,7 +541,7 @@ ProcRRGetOutputInfo(ClientPtr client)
     WriteToClient(client, sizeof(xRRGetOutputInfoReply), (char *) &rep);
     if (extraLen) {
         WriteToClient(client, extraLen, (char *) extra);
-        xfree(extra);
+        free(extra);
     }
 
     return Success;
diff --git a/nx-X11/programs/Xserver/randr/rrproperty.c b/nx-X11/programs/Xserver/randr/rrproperty.c
index 741d0310e..7275cd34f 100644
--- a/nx-X11/programs/Xserver/randr/rrproperty.c
+++ b/nx-X11/programs/Xserver/randr/rrproperty.c
@@ -63,10 +63,10 @@ RRDeliverPropertyEvent(ScreenPtr pScreen, xEvent *event)
 static void
 RRDestroyOutputProperty(RRPropertyPtr prop)
 {
-    xfree(prop->valid_values);
-    xfree(prop->current.data);
-    xfree(prop->pending.data);
-    xfree(prop);
+    free(prop->valid_values);
+    free(prop->current.data);
+    free(prop->pending.data);
+    free(prop);
 }
 
 static void
@@ -225,12 +225,12 @@ RRChangeOutputProperty(RROutputPtr output, Atom property, Atom type,
         if (pending && pScrPriv->rrOutputSetProperty &&
             !pScrPriv->rrOutputSetProperty(output->pScreen, output,
                                            prop->propertyName, &new_value)) {
-            xfree(new_value.data);
+            free(new_value.data);
             if (add)
                 RRDestroyOutputProperty(prop);
             return BadValue;
         }
-        xfree(prop_value->data);
+        free(prop_value->data);
         *prop_value = new_value;
     }
 
@@ -377,7 +377,7 @@ RRConfigureOutputProperty(RROutputPtr output, Atom property,
      * loses any pending values
      */
     if (prop->is_pending && !pending) {
-        xfree(prop->pending.data);
+        free(prop->pending.data);
         RRInitOutputPropertyValue(&prop->pending);
     }
 
@@ -385,7 +385,7 @@ RRConfigureOutputProperty(RROutputPtr output, Atom property,
     prop->range = range;
     prop->immutable = immutable;
     prop->num_valid = num_values;
-    xfree(prop->valid_values);
+    free(prop->valid_values);
     prop->valid_values = new_values;
 
     if (add) {
@@ -442,7 +442,7 @@ ProcRRListOutputProperties(ClientPtr client)
 
         client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
         WriteSwappedDataToClient(client, numProps * sizeof(Atom), pAtoms);
-        xfree(pAtoms);
+        free(pAtoms);
     }
     return Success;
 }
@@ -493,7 +493,7 @@ ProcRRQueryOutputProperty(ClientPtr client)
         client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
         WriteSwappedDataToClient(client, prop->num_valid * sizeof(INT32),
                                  extra);
-        xfree(extra);
+        free(extra);
     }
     return Success;
 }
@@ -749,7 +749,7 @@ ProcRRGetOutputProperty(ClientPtr client)
             break;
         }
         WriteSwappedDataToClient(client, len, extra);
-        xfree(extra);
+        free(extra);
     }
 
     if (stuff->delete && (reply.bytesAfter == 0)) {     /* delete the Property */
diff --git a/nx-X11/programs/Xserver/randr/rrprovider.c b/nx-X11/programs/Xserver/randr/rrprovider.c
index b2251b682..4911f8fd8 100644
--- a/nx-X11/programs/Xserver/randr/rrprovider.c
+++ b/nx-X11/programs/Xserver/randr/rrprovider.c
@@ -152,7 +152,7 @@ ProcRRGetProviders(ClientPtr client)
     if (extraLen)
     {
         WriteToClient(client, extraLen, (char *) extra);
-        xfree(extra);
+        free(extra);
     }
     return Success;
 }
@@ -295,7 +295,7 @@ ProcRRGetProviderInfo(ClientPtr client)
     if (extraLen)
     {
         WriteToClient(client, extraLen, (char *) extra);
-        xfree(extra);
+        free(extra);
     }
     return Success;
 }
@@ -427,7 +427,7 @@ RRProviderDestroyResource(void *value, XID pid)
             (*pScrPriv->rrProviderDestroy) (pScreen, provider);
         pScrPriv->provider = NULL;
     }
-    xfree(provider);
+    free(provider);
     return 1;
 }
 
diff --git a/nx-X11/programs/Xserver/randr/rrproviderproperty.c b/nx-X11/programs/Xserver/randr/rrproviderproperty.c
index a68a94ff2..9aa2135df 100644
--- a/nx-X11/programs/Xserver/randr/rrproviderproperty.c
+++ b/nx-X11/programs/Xserver/randr/rrproviderproperty.c
@@ -60,10 +60,10 @@ RRDeliverPropertyEvent(ScreenPtr pScreen, xEvent *event)
 static void
 RRDestroyProviderProperty(RRPropertyPtr prop)
 {
-    xfree(prop->valid_values);
-    xfree(prop->current.data);
-    xfree(prop->pending.data);
-    xfree(prop);
+    free(prop->valid_values);
+    free(prop->current.data);
+    free(prop->pending.data);
+    free(prop);
 }
 
 static void
@@ -222,10 +222,10 @@ RRChangeProviderProperty(RRProviderPtr provider, Atom property, Atom type,
                                              prop->propertyName, &new_value)) {
             if (add)
                 RRDestroyProviderProperty(prop);
-            xfree(new_value.data);
+            free(new_value.data);
             return BadValue;
         }
-        xfree(prop_value->data);
+        free(prop_value->data);
         *prop_value = new_value;
     }
 
@@ -373,7 +373,7 @@ RRConfigureProviderProperty(RRProviderPtr provider, Atom property,
      * loses any pending values
      */
     if (prop->is_pending && !pending) {
-        xfree(prop->pending.data);
+        free(prop->pending.data);
         RRInitProviderPropertyValue(&prop->pending);
     }
 
@@ -381,7 +381,7 @@ RRConfigureProviderProperty(RRProviderPtr provider, Atom property,
     prop->range = range;
     prop->immutable = immutable;
     prop->num_valid = num_values;
-    xfree(prop->valid_values);
+    free(prop->valid_values);
     prop->valid_values = new_values;
 
     if (add) {
@@ -437,7 +437,7 @@ ProcRRListProviderProperties(ClientPtr client)
     if (numProps) {
         client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
         WriteSwappedDataToClient(client, numProps * sizeof(Atom), pAtoms);
-        xfree(pAtoms);
+        free(pAtoms);
     }
     return Success;
 }
@@ -487,7 +487,7 @@ ProcRRQueryProviderProperty(ClientPtr client)
         client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
         WriteSwappedDataToClient(client, prop->num_valid * sizeof(INT32),
                                  extra);
-        xfree(extra);
+        free(extra);
     }
     return Success;
 }
@@ -741,7 +741,7 @@ ProcRRGetProviderProperty(ClientPtr client)
             break;
         }
         WriteSwappedDataToClient(client, len, extra);
-        xfree(extra);
+        free(extra);
     }
 
     if (stuff->delete && (reply.bytesAfter == 0)) {     /* delete the Property */
diff --git a/nx-X11/programs/Xserver/randr/rrscreen.c b/nx-X11/programs/Xserver/randr/rrscreen.c
index af54d66f5..7047d80a5 100644
--- a/nx-X11/programs/Xserver/randr/rrscreen.c
+++ b/nx-X11/programs/Xserver/randr/rrscreen.c
@@ -334,7 +334,7 @@ ProcRRSetScreenSize(ClientPtr client)
     for (j = 0; j < num_modes; j++)                   \
         total_name_len += modes[j]->mode.nameLength;  \
     total_modes += num_modes;                         \
-    xfree(modes);                                      \
+    free(modes);                                      \
 } while(0)
 
 static inline void
@@ -388,7 +388,7 @@ swap_modeinfos(xRRModeInfo * modeinfos, int i)
             names += mode->mode.nameLength;                \
             mode_count++;                                  \
         }                                                  \
-        xfree(modes);                                       \
+        free(modes);                                       \
     }                                                      \
     } while (0)
 
@@ -504,7 +504,7 @@ rrGetMultiScreenResources(ClientPtr client, Bool query, ScreenPtr pScreen)
     WriteToClient(client, sizeof(xRRGetScreenResourcesReply), (char *) &rep);
     if (extraLen) {
         WriteToClient(client, extraLen, (char *) extra);
-        xfree(extra);
+        free(extra);
     }
     return Success;
 }
@@ -597,7 +597,7 @@ rrGetScreenResources(ClientPtr client, Bool query)
         if (extraLen) {
             extra = xalloc(extraLen);
             if (!extra) {
-                xfree(modes);
+                free(modes);
                 return BadAlloc;
             }
         }
@@ -655,7 +655,7 @@ rrGetScreenResources(ClientPtr client, Bool query)
             memcpy(names, mode->name, mode->mode.nameLength);
             names += mode->mode.nameLength;
         }
-        xfree(modes);
+        free(modes);
         assert(bytes_to_int32((char *) names - (char *) extra) == rep.length);
     }
 
@@ -673,7 +673,7 @@ rrGetScreenResources(ClientPtr client, Bool query)
                   (char *) (char *) &rep);
     if (extraLen) {
         WriteToClient(client, extraLen, (char *) (char *) extra);
-        xfree(extra);
+        free(extra);
     }
     return Success;
 }
@@ -876,7 +876,7 @@ ProcRRGetScreenInfo(ClientPtr client)
         if (extraLen) {
             extra = (CARD8 *) xalloc(extraLen);
             if (!extra) {
-                xfree(pData);
+                free(pData);
                 return BadAlloc;
             }
         }
@@ -916,7 +916,7 @@ ProcRRGetScreenInfo(ClientPtr client)
                 }
             }
         }
-        xfree(pData);
+        free(pData);
 
         data8 = (CARD8 *) rates;
 
@@ -939,7 +939,7 @@ ProcRRGetScreenInfo(ClientPtr client)
     WriteToClient(client, sizeof(xRRGetScreenInfoReply), (char *) &rep);
     if (extraLen) {
         WriteToClient(client, extraLen, (char *) extra);
-        xfree(extra);
+        free(extra);
     }
     return Success;
 }
@@ -1035,7 +1035,7 @@ ProcRRSetScreenConfig(ClientPtr client)
          * Invalid size ID
          */
         client->errorValue = stuff->sizeID;
-        xfree(pData);
+        free(pData);
         return BadValue;
     }
     pSize = &pData->sizes[stuff->sizeID];
@@ -1057,7 +1057,7 @@ ProcRRSetScreenConfig(ClientPtr client)
          * Invalid rotation
          */
         client->errorValue = stuff->rotation;
-        xfree(pData);
+        free(pData);
         return BadValue;
     }
 
@@ -1066,7 +1066,7 @@ ProcRRSetScreenConfig(ClientPtr client)
          * requested rotation or reflection not supported by screen
          */
         client->errorValue = stuff->rotation;
-        xfree(pData);
+        free(pData);
         return BadMatch;
     }
 
@@ -1088,7 +1088,7 @@ ProcRRSetScreenConfig(ClientPtr client)
              * Invalid rate
              */
             client->errorValue = rate;
-            xfree(pData);
+            free(pData);
             return BadValue;
         }
         mode = pSize->pRates[i].mode;
@@ -1113,12 +1113,12 @@ ProcRRSetScreenConfig(ClientPtr client)
     height = mode->mode.height;
     if (width < pScrPriv->minWidth || pScrPriv->maxWidth < width) {
         client->errorValue = width;
-        xfree(pData);
+        free(pData);
         return BadValue;
     }
     if (height < pScrPriv->minHeight || pScrPriv->maxHeight < height) {
         client->errorValue = height;
-        xfree(pData);
+        free(pData);
         return BadValue;
     }
 
@@ -1159,7 +1159,7 @@ ProcRRSetScreenConfig(ClientPtr client)
 
  sendReply:
 
-    xfree(pData);
+    free(pData);
 
     rep = (xRRSetScreenConfigReply) {
         .type = X_Reply,
@@ -1202,7 +1202,7 @@ RR10CurrentSizeID(ScreenPtr pScreen)
                     sizeID = (CARD16) i;
                     break;
                 }
-            xfree(data);
+            free(data);
         }
     }
     return sizeID;
diff --git a/nx-X11/programs/Xserver/randr/rrtransform.c b/nx-X11/programs/Xserver/randr/rrtransform.c
index 4377d09aa..743e227ea 100644
--- a/nx-X11/programs/Xserver/randr/rrtransform.c
+++ b/nx-X11/programs/Xserver/randr/rrtransform.c
@@ -37,7 +37,7 @@ RRTransformInit(RRTransformPtr transform)
 void
 RRTransformFini(RRTransformPtr transform)
 {
-    xfree(transform->params);
+    free(transform->params);
 }
 
 Bool
@@ -81,7 +81,7 @@ RRTransformSetFilter(RRTransformPtr dst,
     }
     else
         new_params = NULL;
-    xfree(dst->params);
+    free(dst->params);
     dst->filter = filter;
     dst->params = new_params;
     dst->nparams = nparams;
diff --git a/nx-X11/programs/Xserver/record/record.c b/nx-X11/programs/Xserver/record/record.c
index 590a343a0..7fabf79c6 100644
--- a/nx-X11/programs/Xserver/record/record.c
+++ b/nx-X11/programs/Xserver/record/record.c
@@ -1126,7 +1126,7 @@ RecordUninstallHooks(pRCAP, oneclient)
 		{ /* nobody needs it, so free it */
 		    pClient->requestVector = pClientPriv->originalVector;
 		    pClient->devPrivates[RecordClientPrivateIndex].ptr = NULL;
-		    xfree(pClientPriv);
+		    free(pClientPriv);
 		}
 	    } /* end if this RCAP specifies any requests */
 	} /* end if not future clients */
@@ -1197,8 +1197,8 @@ RecordDeleteClientFromRCAP(pRCAP, position)
 	}
 	/* free the RCAP */
 	if (pRCAP->clientIDsSeparatelyAllocated)
-	    xfree(pRCAP->pClientIDs);
-	xfree(pRCAP);
+	    free(pRCAP->pClientIDs);
+	free(pRCAP);
     }
 } /* RecordDeleteClientFromRCAP */
 
@@ -1979,11 +1979,11 @@ bailout:
     {
 	for (i = 0; i < maxSets; i++)
 	    if (si[i].intervals)
-		xfree(si[i].intervals);
+		free(si[i].intervals);
 	DEALLOCATE_LOCAL(si);
     }
     if (pCanonClients && pCanonClients != (XID *)&stuff[1])
-	xfree(pCanonClients);
+	free(pCanonClients);
     return err;
 } /* RecordRegisterClients */
 
@@ -2068,7 +2068,7 @@ ProcRecordCreateContext(client)
     }
 bailout:
     if (pContext)
-	xfree(pContext);
+	free(pContext);
     return err;
 } /* ProcRecordCreateContext */
 
@@ -2119,7 +2119,7 @@ ProcRecordUnregisterClients(client)
 	RecordDeleteClientFromContext(pContext, pCanonClients[i]);
     }
     if (pCanonClients != (XID *)&stuff[1])
-	xfree(pCanonClients);
+	free(pCanonClients);
     return Success;
 } /* ProcRecordUnregisterClients */
 
@@ -2471,7 +2471,7 @@ ProcRecordGetContext(client)
 bailout:
     for (i = 0; i < nRCAPs; i++)
     {
-	if (pRangeInfo[i].pRanges) xfree(pRangeInfo[i].pRanges);
+	if (pRangeInfo[i].pRanges) free(pRangeInfo[i].pRanges);
     }
     DEALLOCATE_LOCAL(pRangeInfo);
     return err;
@@ -2646,7 +2646,7 @@ RecordDeleteContext(value, id)
 	}
     }
 
-    xfree(pContext);
+    free(pContext);
 
     /* remove context from AllContexts list */
 
@@ -2655,7 +2655,7 @@ RecordDeleteContext(value, id)
 	ppAllContexts[i] = ppAllContexts[numContexts - 1];
 	if (--numContexts == 0)
 	{
-	    xfree(ppAllContexts);
+	    free(ppAllContexts);
 	    ppAllContexts = NULL;
 	}
     }
diff --git a/nx-X11/programs/Xserver/record/set.c b/nx-X11/programs/Xserver/record/set.c
index 83fb0e7d7..28547f3d0 100644
--- a/nx-X11/programs/Xserver/record/set.c
+++ b/nx-X11/programs/Xserver/record/set.c
@@ -73,7 +73,6 @@ typedef int Bool;
 typedef unsigned short CARD16;
 
 #define xalloc malloc
-#define xfree free
 #define ALLOCATE_LOCAL malloc
 #define DEALLOCATE_LOCAL free
 
@@ -135,7 +134,7 @@ static void
 BitVectorDestroySet(pSet)
     RecordSetPtr pSet;
 {
-    xfree(pSet);
+    free(pSet);
 }
 
 static unsigned long
@@ -295,7 +294,7 @@ static void
 IntervalListDestroySet(pSet)
     RecordSetPtr pSet;
 {
-    xfree(pSet);
+    free(pSet);
 }
 
 static unsigned long
@@ -702,7 +701,7 @@ int main(argc, argv)
 
 	if (testcount & 1)
 	{
-	    xfree(bs);
+	    free(bs);
 	}
     }
 }
diff --git a/nx-X11/programs/Xserver/render/animcur.c b/nx-X11/programs/Xserver/render/animcur.c
index 27e5ab949..993800c7e 100644
--- a/nx-X11/programs/Xserver/render/animcur.c
+++ b/nx-X11/programs/Xserver/render/animcur.c
@@ -128,7 +128,7 @@ AnimCurCloseScreen (int index, ScreenPtr pScreen)
     Unwrap(as, pScreen, RecolorCursor);
     SetAnimCurScreen(pScreen,0);
     ret = (*pScreen->CloseScreen) (index, pScreen);
-    xfree (as);
+    free (as);
     if (index == 0)
 	AnimCurScreenPrivateIndex = -1;
     return ret;
diff --git a/nx-X11/programs/Xserver/render/filter.c b/nx-X11/programs/Xserver/render/filter.c
index 57a21a8c0..31d5481c9 100644
--- a/nx-X11/programs/Xserver/render/filter.c
+++ b/nx-X11/programs/Xserver/render/filter.c
@@ -73,7 +73,7 @@ PictureGetFilterId (char *filter, int len, Bool makeit)
 	names = xalloc (sizeof (char *));
     if (!names)
     {
-	xfree (name);
+	free (name);
 	return -1;
     }
     filterNames = names;
@@ -119,8 +119,8 @@ PictureFreeFilterIds (void)
     int	    i;
 
     for (i = 0; i < nfilterNames; i++)
-	xfree (filterNames[i]);
-    xfree (filterNames);
+	free (filterNames[i]);
+    free (filterNames);
     nfilterNames = 0;
     filterNames = 0;
 }
@@ -272,8 +272,8 @@ PictureResetFilters (ScreenPtr pScreen)
 {
     PictureScreenPtr    ps = GetPictureScreen(pScreen);
 
-    xfree (ps->filters);
-    xfree (ps->filterAliases);
+    free (ps->filters);
+    free (ps->filterAliases);
     PictureFreeFilterIds ();
 }
 
@@ -340,7 +340,7 @@ SetPicturePictFilter (PicturePtr pPicture, PictFilterPtr pFilter,
 
         if (!new_params && nparams)
             return BadAlloc;
-        xfree (pPicture->filter_params);
+        free (pPicture->filter_params);
         pPicture->filter_params = new_params;
         pPicture->filter_nparams = nparams;
     }
diff --git a/nx-X11/programs/Xserver/render/glyph.c b/nx-X11/programs/Xserver/render/glyph.c
index 854a9069d..f956c44b2 100644
--- a/nx-X11/programs/Xserver/render/glyph.c
+++ b/nx-X11/programs/Xserver/render/glyph.c
@@ -264,7 +264,7 @@ FreeGlyph (GlyphPtr glyph, int format)
 	    gr->signature = 0;
 	    globalGlyphs[format].tableEntries--;
 	}
-	xfree (glyph);
+	free (glyph);
     }
 }
 
@@ -281,7 +281,7 @@ AddGlyph (GlyphSetPtr glyphSet, GlyphPtr glyph, Glyph id)
     gr = FindGlyphRef (&globalGlyphs[glyphSet->fdepth], hash, TRUE, glyph);
     if (gr->glyph && gr->glyph != DeletedGlyph)
     {
-	xfree (glyph);
+	free (glyph);
 	glyph = gr->glyph;
     }
     else
@@ -404,7 +404,7 @@ ResizeGlyphHash (GlyphHashPtr hash, CARD32 change, Bool global)
 		++newHash.tableEntries;
 	    }
 	}
-	xfree (hash->table);
+	free (hash->table);
     }
     *hash = newHash;
     if (global)
@@ -444,7 +444,7 @@ AllocateGlyphSet (int fdepth, PictFormatPtr format)
 
     if (!AllocateGlyphHash (&glyphSet->hash, &glyphHashSets[0]))
     {
-	xfree (glyphSet);
+	free (glyphSet);
 	return FALSE;
     }
     glyphSet->refcnt = 1;
@@ -473,19 +473,19 @@ FreeGlyphSet (void	*value,
 	}
 	if (!globalGlyphs[glyphSet->fdepth].tableEntries)
 	{
-	    xfree (globalGlyphs[glyphSet->fdepth].table);
+	    free (globalGlyphs[glyphSet->fdepth].table);
 	    globalGlyphs[glyphSet->fdepth].table = 0;
 	    globalGlyphs[glyphSet->fdepth].hashSet = 0;
 	}
 	else
 	    ResizeGlyphHash (&globalGlyphs[glyphSet->fdepth], 0, TRUE);
-	xfree (table);
+	free (table);
 
 	if (glyphSet->devPrivates &&
 	    glyphSet->devPrivates != (void *)(&glyphSet[1]))
-	    xfree(glyphSet->devPrivates);
+	    free(glyphSet->devPrivates);
 
-	xfree (glyphSet);
+	free (glyphSet);
     }
     return Success;
 }
diff --git a/nx-X11/programs/Xserver/render/miindex.c b/nx-X11/programs/Xserver/render/miindex.c
index 03e2857a2..ad2653c14 100644
--- a/nx-X11/programs/Xserver/render/miindex.c
+++ b/nx-X11/programs/Xserver/render/miindex.c
@@ -267,7 +267,7 @@ miInitIndexed (ScreenPtr	pScreen,
     pFormat->index.pValues = xalloc (num * sizeof (xIndexValue));
     if (!pFormat->index.pValues)
     {
-	xfree (pIndexed);
+	free (pIndexed);
 	return FALSE;
     }
     
@@ -323,12 +323,12 @@ miCloseIndexed (ScreenPtr	pScreen,
 {
     if (pFormat->index.devPrivate)
     {
-	xfree (pFormat->index.devPrivate);
+	free (pFormat->index.devPrivate);
 	pFormat->index.devPrivate = 0;
     }
     if (pFormat->index.pValues)
     {
-	xfree (pFormat->index.pValues);
+	free (pFormat->index.pValues);
 	pFormat->index.pValues = 0;
     }
 }
diff --git a/nx-X11/programs/Xserver/render/mipict.c b/nx-X11/programs/Xserver/render/mipict.c
index ae7cf5a6d..5bd449d44 100644
--- a/nx-X11/programs/Xserver/render/mipict.c
+++ b/nx-X11/programs/Xserver/render/mipict.c
@@ -107,7 +107,7 @@ miChangePictureClip (PicturePtr    pPicture,
 	if (!clientClip)
 	    return BadAlloc;
 	clientClipType = CT_REGION;
-	xfree(value);
+	free(value);
 	break;
     }
     (*ps->DestroyPictureClip) (pPicture);
diff --git a/nx-X11/programs/Xserver/render/picture.c b/nx-X11/programs/Xserver/render/picture.c
index a29a9568c..1e653b0c3 100644
--- a/nx-X11/programs/Xserver/render/picture.c
+++ b/nx-X11/programs/Xserver/render/picture.c
@@ -141,9 +141,9 @@ PictureCloseScreen (int index, ScreenPtr pScreen)
 	    (*ps->CloseIndexed) (pScreen, &ps->formats[n]);
     SetPictureScreen(pScreen, 0);
     if (ps->PicturePrivateSizes)
-	xfree (ps->PicturePrivateSizes);
-    xfree (ps->formats);
-    xfree (ps);
+	free (ps->PicturePrivateSizes);
+    free (ps->formats);
+    free (ps);
     return ret;
 }
 
@@ -660,7 +660,7 @@ PictureInit (ScreenPtr pScreen, PictFormatPtr formats, int nformats)
     {
 	if (!AddResource (formats[n].id, PictFormatType, (void *) (formats+n)))
 	{
-	    xfree (formats);
+	    free (formats);
 	    return FALSE;
 	}
 	if (formats[n].type == PictTypeIndexed)
@@ -692,15 +692,15 @@ PictureInit (ScreenPtr pScreen, PictFormatPtr formats, int nformats)
     ps = (PictureScreenPtr) xalloc (sizeof (PictureScreenRec));
     if (!ps)
     {
-	xfree (formats);
+	free (formats);
 	return FALSE;
     }
     SetPictureScreen(pScreen, ps);
     if (!GlyphInit (pScreen))
     {
 	SetPictureScreen(pScreen, 0);
-	xfree (formats);
-	xfree (ps);
+	free (formats);
+	free (ps);
 	return FALSE;
     }
 
@@ -730,8 +730,8 @@ PictureInit (ScreenPtr pScreen, PictFormatPtr formats, int nformats)
     {
 	PictureResetFilters (pScreen);
 	SetPictureScreen(pScreen, 0);
-	xfree (formats);
-	xfree (ps);
+	free (formats);
+	free (ps);
 	return FALSE;
     }
 
@@ -1003,7 +1003,7 @@ CreateSolidPicture (Picture pid, xRenderColor *color, int *error)
     pPicture->pSourcePict = (SourcePictPtr) xalloc(sizeof(PictSolidFill));
     if (!pPicture->pSourcePict) {
         *error = BadAlloc;
-        xfree(pPicture);
+        free(pPicture);
         return 0;
     }
     pPicture->pSourcePict->type = SourcePictTypeSolidFill;
@@ -1037,7 +1037,7 @@ CreateLinearGradientPicture (Picture pid, xPointFixed *p1, xPointFixed *p2,
     pPicture->pSourcePict = (SourcePictPtr) xalloc(sizeof(PictLinearGradient));
     if (!pPicture->pSourcePict) {
         *error = BadAlloc;
-        xfree(pPicture);
+        free(pPicture);
         return 0;
     }
 
@@ -1047,7 +1047,7 @@ CreateLinearGradientPicture (Picture pid, xPointFixed *p1, xPointFixed *p2,
 
     initGradient(pPicture->pSourcePict, nStops, stops, colors, error);
     if (*error) {
-        xfree(pPicture);
+        free(pPicture);
         return 0;
     }
     return pPicture;
@@ -1086,7 +1086,7 @@ CreateRadialGradientPicture (Picture pid, xPointFixed *inner, xPointFixed *outer
     pPicture->pSourcePict = (SourcePictPtr) xalloc(sizeof(PictRadialGradient));
     if (!pPicture->pSourcePict) {
         *error = BadAlloc;
-        xfree(pPicture);
+        free(pPicture);
         return 0;
     }
     radial = &pPicture->pSourcePict->radial;
@@ -1110,7 +1110,7 @@ CreateRadialGradientPicture (Picture pid, xPointFixed *inner, xPointFixed *outer
 
     initGradient(pPicture->pSourcePict, nStops, stops, colors, error);
     if (*error) {
-        xfree(pPicture);
+        free(pPicture);
         return 0;
     }
     return pPicture;
@@ -1137,7 +1137,7 @@ CreateConicalGradientPicture (Picture pid, xPointFixed *center, xFixed angle,
     pPicture->pSourcePict = (SourcePictPtr) xalloc(sizeof(PictConicalGradient));
     if (!pPicture->pSourcePict) {
         *error = BadAlloc;
-        xfree(pPicture);
+        free(pPicture);
         return 0;
     }
 
@@ -1147,7 +1147,7 @@ CreateConicalGradientPicture (Picture pid, xPointFixed *center, xFixed angle,
 
     initGradient(pPicture->pSourcePict, nStops, stops, colors, error);
     if (*error) {
-        xfree(pPicture);
+        free(pPicture);
         return 0;
     }
     return pPicture;
@@ -1487,7 +1487,7 @@ SetPictureTransform (PicturePtr	    pPicture,
     {
 	if (pPicture->transform)
 	{
-	    xfree (pPicture->transform);
+	    free (pPicture->transform);
 	    pPicture->transform = 0;
 	}
     }
@@ -1611,12 +1611,12 @@ FreePicture (void *	value,
     if (--pPicture->refcnt == 0)
     {
 	if (pPicture->transform)
-	    xfree (pPicture->transform);
+	    free (pPicture->transform);
         if (!pPicture->pDrawable) {
             if (pPicture->pSourcePict) {
                 if (pPicture->pSourcePict->type != SourcePictTypeSolidFill)
-                    xfree(pPicture->pSourcePict->linear.stops);
-                xfree(pPicture->pSourcePict);
+                    free(pPicture->pSourcePict->linear.stops);
+                free(pPicture->pSourcePict);
             }
         } else {
             ScreenPtr	    pScreen = pPicture->pDrawable->pScreen;
@@ -1647,7 +1647,7 @@ FreePicture (void *	value,
                 (*pScreen->DestroyPixmap) ((PixmapPtr)pPicture->pDrawable);
             }
         }
-	xfree (pPicture);
+	free (pPicture);
     }
     return Success;
 }
diff --git a/nx-X11/programs/Xserver/render/render.c b/nx-X11/programs/Xserver/render/render.c
index 5a4114adc..58b3dbc88 100644
--- a/nx-X11/programs/Xserver/render/render.c
+++ b/nx-X11/programs/Xserver/render/render.c
@@ -552,7 +552,7 @@ ProcRenderQueryPictFormats (ClientPtr client)
 	swapl (&reply->numSubpixel, n);
     }
     WriteToClient(client, rlength, (char *) reply);
-    xfree (reply);
+    free (reply);
     return client->noClientException;
 }
 #endif /* NXAGENT_SERVER */
@@ -617,7 +617,7 @@ ProcRenderQueryPictIndexValues (ClientPtr client)
     }
 
     WriteToClient(client, rlength, (char *) reply);
-    xfree(reply);
+    free(reply);
     return (client->noClientException);
 }
 
@@ -1196,16 +1196,16 @@ ProcRenderAddGlyphs (ClientPtr client)
     }
 
     if (glyphsBase != glyphsLocal)
-	Xfree (glyphsBase);
+	free (glyphsBase);
     return client->noClientException;
 bail:
     while (glyphs != glyphsBase)
     {
 	--glyphs;
-	xfree (glyphs->glyph);
+	free (glyphs->glyph);
     }
     if (glyphsBase != glyphsLocal)
-	Xfree (glyphsBase);
+	free (glyphsBase);
     return err;
 }
 
@@ -1542,14 +1542,14 @@ ProcRenderCreateCursor (ClientPtr client)
     srcbits = (unsigned char *)xalloc(nbytes_mono);
     if (!srcbits)
     {
-	xfree (argbbits);
+	free (argbbits);
 	return (BadAlloc);
     }
     mskbits = (unsigned char *)xalloc(nbytes_mono);
     if (!mskbits)
     {
-	xfree(argbbits);
-	xfree(srcbits);
+	free(argbbits);
+	free(srcbits);
 	return (BadAlloc);
     }
     bzero ((char *) mskbits, nbytes_mono);
@@ -1571,26 +1571,26 @@ ProcRenderCreateCursor (ClientPtr client)
 	pFormat = PictureMatchFormat (pScreen, 32, PICT_a8r8g8b8);
 	if (!pFormat)
 	{
-	    xfree (argbbits);
-	    xfree (srcbits);
-	    xfree (mskbits);
+	    free (argbbits);
+	    free (srcbits);
+	    free (mskbits);
 	    return (BadImplementation);
 	}
 	pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height, 32);
 	if (!pPixmap)
 	{
-	    xfree (argbbits);
-	    xfree (srcbits);
-	    xfree (mskbits);
+	    free (argbbits);
+	    free (srcbits);
+	    free (mskbits);
 	    return (BadAlloc);
 	}
 	pPicture = CreatePicture (0, &pPixmap->drawable, pFormat, 0, 0, 
 				  client, &error);
 	if (!pPicture)
 	{
-	    xfree (argbbits);
-	    xfree (srcbits);
-	    xfree (mskbits);
+	    free (argbbits);
+	    free (srcbits);
+	    free (mskbits);
 	    return error;
 	}
 	(*pScreen->DestroyPixmap) (pPixmap);
@@ -1674,7 +1674,7 @@ ProcRenderCreateCursor (ClientPtr client)
     }
     else
     {
-	xfree (argbbits);
+	free (argbbits);
 	argbbits = 0;
     }
     
@@ -1819,7 +1819,7 @@ ProcRenderQueryFilters (ClientPtr client)
 	swapl(&reply->numFilters, n);
     }
     WriteToClient(client, total_bytes, (char *) reply);
-    xfree (reply);
+    free (reply);
     
     return(client->noClientException);
 }
@@ -1873,7 +1873,7 @@ ProcRenderCreateAnimCursor (ClientPtr client)
 						       RT_CURSOR, SecurityReadAccess);
 	if (!cursors[i])
 	{
-	    xfree (cursors);
+	    free (cursors);
 	    client->errorValue = elt->cursor;
 	    return BadCursor;
 	}
@@ -1881,7 +1881,7 @@ ProcRenderCreateAnimCursor (ClientPtr client)
 	elt++;
     }
     ret = AnimCursorCreate (cursors, deltas, ncursor, &pCursor);
-    xfree (cursors);
+    free (cursors);
     if (ret != Success)
 	return ret;
     
@@ -2707,7 +2707,7 @@ PanoramiXRenderCreatePicture (ClientPtr client)
     if (result == Success)
 	AddResource(newPict->info[0].id, XRT_PICTURE, newPict);
     else 
-	xfree(newPict);
+	free(newPict);
 
     return (result);
 }
diff --git a/nx-X11/programs/Xserver/xfixes/cursor.c b/nx-X11/programs/Xserver/xfixes/cursor.c
index acdd9cf2e..6618dd45a 100755
--- a/nx-X11/programs/Xserver/xfixes/cursor.c
+++ b/nx-X11/programs/Xserver/xfixes/cursor.c
@@ -124,7 +124,7 @@ CursorCloseScreen (int index, ScreenPtr pScreen)
     Unwrap (cs, pScreen, CloseScreen);
     Unwrap (cs, pScreen, DisplayCursor);
     ret = (*pScreen->CloseScreen) (index, pScreen);
-    xfree (cs);
+    free (cs);
     if (index == 0)
 	CursorScreenPrivateIndex = -1;
     return ret;
@@ -174,7 +174,7 @@ XFixesSelectCursorInput (ClientPtr	pClient,
 	    if (!AddResource (pWindow->drawable.id, CursorWindowType,
 			      (void *) pWindow))
 	    {
-		xfree (e);
+		free (e);
 		return BadAlloc;
 	    }
 
@@ -346,7 +346,7 @@ ProcXFixesGetCursorImage (ClientPtr client)
     }
     (void) WriteToClient(client, sizeof (xXFixesGetCursorImageReply) +
 			 (npixels << 2), (char *) rep);
-    xfree (rep);
+    free (rep);
     return client->noClientException;
 }
 
@@ -502,7 +502,7 @@ ProcXFixesGetCursorImageAndName (ClientPtr client)
     }
     (void) WriteToClient(client, sizeof (xXFixesGetCursorImageAndNameReply) +
 			 (npixels << 2) + nbytesRound, (char *) rep);
-    xfree (rep);
+    free (rep);
     return client->noClientException;
 }
 
@@ -699,7 +699,7 @@ CursorFreeClient (void * data, XID id)
 	if (e == old)
 	{
 	    *prev = e->next;
-	    xfree (e);
+	    free (e);
 	    break;
 	}
     }
diff --git a/nx-X11/programs/Xserver/xfixes/region.c b/nx-X11/programs/Xserver/xfixes/region.c
index 0b1865cf0..ba840f4b3 100755
--- a/nx-X11/programs/Xserver/xfixes/region.c
+++ b/nx-X11/programs/Xserver/xfixes/region.c
@@ -608,7 +608,7 @@ ProcXFixesFetchRegion (ClientPtr client)
     }
     (void) WriteToClient(client, sizeof (xXFixesFetchRegionReply) +
 			 nBox * sizeof (xRectangle), (char *) reply);
-    xfree (reply);
+    free (reply);
     return (client->noClientException);
 }
 
diff --git a/nx-X11/programs/Xserver/xfixes/select.c b/nx-X11/programs/Xserver/xfixes/select.c
index 464979165..4abad3f19 100755
--- a/nx-X11/programs/Xserver/xfixes/select.c
+++ b/nx-X11/programs/Xserver/xfixes/select.c
@@ -174,7 +174,7 @@ XFixesSelectSelectionInput (ClientPtr	pClient,
 	    if (!AddResource (pWindow->drawable.id, SelectionWindowType,
 			      (void *) pWindow))
 	    {
-		xfree (e);
+		free (e);
 		return BadAlloc;
 	    }
 
@@ -250,7 +250,7 @@ SelectionFreeClient (void * data, XID id)
 	if (e == old)
 	{
 	    *prev = e->next;
-	    xfree (e);
+	    free (e);
 	    CheckSelectionCallback ();
 	    break;
 	}
diff --git a/nx-X11/programs/Xserver/xkb/ddxList.c b/nx-X11/programs/Xserver/xkb/ddxList.c
index 3dfb85644..2b8f90bad 100644
--- a/nx-X11/programs/Xserver/xkb/ddxList.c
+++ b/nx-X11/programs/Xserver/xkb/ddxList.c
@@ -169,7 +169,7 @@ char	tmpname[PATH_MAX];
 	if ((list->pattern[what][0]=='*')&&(list->pattern[what][1]=='\0')) {
 	    buf = Xprintf("%s/%s.dir",XkbBaseDirectory,componentDirs[what]);
 	    in= fopen(buf,"r");
-	    xfree (buf);
+	    free (buf);
 	    buf = NULL;
 	}
 	if (!in) {
@@ -186,7 +186,7 @@ char	tmpname[PATH_MAX];
 	if ((list->pattern[what][0]=='*')&&(list->pattern[what][1]=='\0')) {
 	    buf = Xprintf("%s.dir",componentDirs[what]);
 	    in= fopen(buf,"r");
-	    xfree (buf);
+	    free (buf);
 	    buf = NULL;
 	}
 	if (!in) {
@@ -217,7 +217,7 @@ char	tmpname[PATH_MAX];
     if (!in)
     {
         if (buf != NULL)
-	    xfree (buf);
+	    free (buf);
 #ifdef WIN32
 	unlink(tmpname);
 #endif
@@ -277,7 +277,7 @@ char	tmpname[PATH_MAX];
     unlink(tmpname);
 #endif
     if (buf != NULL)
-        xfree (buf);
+        free (buf);
     return status;
 }
 
diff --git a/nx-X11/programs/Xserver/xkb/ddxLoad.c b/nx-X11/programs/Xserver/xkb/ddxLoad.c
index b3ef60f22..9134e4754 100644
--- a/nx-X11/programs/Xserver/xkb/ddxLoad.c
+++ b/nx-X11/programs/Xserver/xkb/ddxLoad.c
@@ -151,7 +151,7 @@ Win32System(const char *cmdline)
 	    LocalFree(buffer);
 	}
 
-	xfree(cmd);
+	free(cmd);
 	return -1;
     }
     /* Wait until child process exits. */
@@ -162,7 +162,7 @@ Win32System(const char *cmdline)
     /* Close process and thread handles. */
     CloseHandle( pi.hProcess );
     CloseHandle( pi.hThread );
-    xfree(cmd);
+    free(cmd);
 
     return dwExitCode;
 }
@@ -620,7 +620,7 @@ char 	*cmd = NULL,file[PATH_MAX],xkm_output_dir[PATH_MAX],*map,*outFile;
 	if (outFile!=NULL)
 	    _XkbFree(outFile);
         if (cmd!=NULL)
-            xfree(cmd);
+            free(cmd);
 	return True;
     } 
 #ifdef DEBUG
@@ -629,7 +629,7 @@ char 	*cmd = NULL,file[PATH_MAX],xkm_output_dir[PATH_MAX],*map,*outFile;
     if (outFile!=NULL)
 	_XkbFree(outFile);
     if (cmd!=NULL)
-        xfree(cmd);
+        free(cmd);
     return False;
 }
 
@@ -802,7 +802,7 @@ char tmpname[PATH_MAX];
 	    }
 #endif
             if (buf != NULL)
-                xfree (buf);
+                free (buf);
 	    return True;
 	}
 #ifdef DEBUG
@@ -826,7 +826,7 @@ char tmpname[PATH_MAX];
     if (nameRtrn)
 	nameRtrn[0]= '\0';
     if (buf != NULL)
-        xfree (buf);
+        free (buf);
     return False;
 }
 
diff --git a/nx-X11/programs/Xserver/xkb/xkb.c b/nx-X11/programs/Xserver/xkb/xkb.c
index 20aab8ef0..7085fbfe4 100644
--- a/nx-X11/programs/Xserver/xkb/xkb.c
+++ b/nx-X11/programs/Xserver/xkb/xkb.c
@@ -4823,16 +4823,16 @@ char *		wire;
 	    return status;
 	status = _GetCountedString(&wire, client, &val);
 	if (status != Success) {
-            xfree(name);
+            free(name);
             return status;
         }
 	if (XkbAddGeomProperty(geom,name,val)==NULL) {
-            xfree(name);
-            xfree(val);
+            free(name);
+            free(val);
 	    return BadAlloc;
         }
-        xfree(name);
-        xfree(val);
+        free(name);
+        free(val);
     }
 
     if (req->nColors<2) {
@@ -4860,10 +4860,10 @@ char *		wire;
 	if (status != Success)
 	    return status;
         if (!XkbAddGeomColor(geom,name,geom->num_colors)) {
-            xfree(name);
+            free(name);
 	    return BadAlloc;
         }
-        xfree(name);
+        free(name);
     }
     if (req->nColors!=geom->num_colors) {
 	client->errorValue= _XkbErrCode3(0x05,req->nColors,geom->num_colors);
-- 
cgit v1.2.3


From 2646fc254e75c4a7fc10d03d1139d0bd708ceae9 Mon Sep 17 00:00:00 2001
From: Mike Gabriel <mike.gabriel@das-netzwerkteam.de>
Date: Sun, 26 Jun 2016 01:51:18 +0200
Subject: nx-X11/programs/Xserver: Drop {X,x}alloc() macros, use malloc()
 instead.

---
 nx-X11/config/cf/X11.tmpl                          |   9 -
 nx-X11/config/cf/host.def                          |   6 -
 nx-X11/config/cf/lnxLib.rules                      |  11 -
 nx-X11/config/cf/xorg.cf                           |   4 -
 nx-X11/config/cf/xorgsite.def                      |  19 -
 nx-X11/include/Xthreads.h                          |   7 +-
 nx-X11/lib/xtrans/Xtrans.c                         |  20 +-
 nx-X11/lib/xtrans/Xtransdnet.c                     |   4 +-
 nx-X11/lib/xtrans/Xtranslcl.c                      |  24 +-
 nx-X11/lib/xtrans/Xtransos2.c                      |  16 +-
 nx-X11/lib/xtrans/Xtranssock.c                     |  14 +-
 nx-X11/lib/xtrans/Xtranstli.c                      |   6 +-
 nx-X11/lib/xtrans/Xtransutil.c                     |  10 +-
 nx-X11/lib/xtrans/transport.c                      |   1 -
 nx-X11/programs/Xserver/GL/glx/glxcmds.c           |   2 +-
 nx-X11/programs/Xserver/GL/glx/glximports.c        |   6 +-
 nx-X11/programs/Xserver/GL/glx/glxutil.c           |   6 +-
 nx-X11/programs/Xserver/GL/mesa/X/xf86glx_util.c   |   2 +-
 nx-X11/programs/Xserver/Xext/extmod/modinit.c      |   2 +-
 nx-X11/programs/Xserver/Xext/panoramiX.c           |  12 +-
 nx-X11/programs/Xserver/Xext/panoramiXprocs.c      |  12 +-
 nx-X11/programs/Xserver/Xext/saver.c               |   4 +-
 nx-X11/programs/Xserver/Xext/security.c            |   8 +-
 nx-X11/programs/Xserver/Xext/shape.c               |   4 +-
 nx-X11/programs/Xserver/Xext/shm.c                 |   4 +-
 nx-X11/programs/Xserver/Xext/sleepuntil.c          |   2 +-
 nx-X11/programs/Xserver/Xext/sync.c                |  12 +-
 nx-X11/programs/Xserver/Xext/xcmisc.c              |   2 +-
 nx-X11/programs/Xserver/Xext/xf86bigfont.c         |   2 +-
 nx-X11/programs/Xserver/Xext/xvdisp.c              |   4 +-
 nx-X11/programs/Xserver/Xext/xvmain.c              |   8 +-
 nx-X11/programs/Xserver/Xext/xvmc.c                |   8 +-
 nx-X11/programs/Xserver/Xi/exevents.c              |  10 +-
 nx-X11/programs/Xserver/Xi/extinit.c               |   2 +-
 nx-X11/programs/Xserver/Xi/getdctl.c               |   2 +-
 nx-X11/programs/Xserver/Xi/getfctl.c               |   2 +-
 nx-X11/programs/Xserver/Xi/getprop.c               |   2 +-
 nx-X11/programs/Xserver/Xi/getselev.c              |   2 +-
 nx-X11/programs/Xserver/Xi/queryst.c               |   2 +-
 nx-X11/programs/Xserver/composite/compalloc.c      |   8 +-
 nx-X11/programs/Xserver/composite/compinit.c       |   2 +-
 nx-X11/programs/Xserver/damageext/damageext.c      |   2 +-
 nx-X11/programs/Xserver/dbe/dbe.c                  |   8 +-
 nx-X11/programs/Xserver/dbe/midbe.c                |   2 +-
 nx-X11/programs/Xserver/dix/atom.c                 |   6 +-
 nx-X11/programs/Xserver/dix/colormap.c             |  16 +-
 nx-X11/programs/Xserver/dix/cursor.c               |  14 +-
 nx-X11/programs/Xserver/dix/devices.c              |  36 +-
 nx-X11/programs/Xserver/dix/dispatch.c             |  10 +-
 nx-X11/programs/Xserver/dix/dixfonts.c             |  36 +-
 nx-X11/programs/Xserver/dix/dixutils.c             |   8 +-
 nx-X11/programs/Xserver/dix/events.c               |   6 +-
 nx-X11/programs/Xserver/dix/extension.c            |   8 +-
 nx-X11/programs/Xserver/dix/gc.c                   |  12 +-
 nx-X11/programs/Xserver/dix/glyphcurs.c            |   2 +-
 nx-X11/programs/Xserver/dix/grabs.c                |   4 +-
 nx-X11/programs/Xserver/dix/main.c                 |   6 +-
 nx-X11/programs/Xserver/dix/pixmap.c               |   4 +-
 nx-X11/programs/Xserver/dix/property.c             |   6 +-
 nx-X11/programs/Xserver/dix/region.c               |  14 +-
 nx-X11/programs/Xserver/dix/resource.c             |  10 +-
 nx-X11/programs/Xserver/dix/window.c               |  10 +-
 nx-X11/programs/Xserver/fb/fballpriv.c             |   2 +-
 nx-X11/programs/Xserver/fb/fbcmap.c                |   8 +-
 nx-X11/programs/Xserver/fb/fbcopy.c                |   2 +-
 nx-X11/programs/Xserver/fb/fboverlay.c             |   2 +-
 nx-X11/programs/Xserver/fb/fbpseudocolor.c         |   8 +-
 nx-X11/programs/Xserver/hw/nxagent/Args.c          |   6 +-
 nx-X11/programs/Xserver/hw/nxagent/Clipboard.c     |   2 +-
 nx-X11/programs/Xserver/hw/nxagent/Colormap.c      |  16 +-
 nx-X11/programs/Xserver/hw/nxagent/Cursor.c        |   2 +-
 nx-X11/programs/Xserver/hw/nxagent/Display.c       |   6 +-
 nx-X11/programs/Xserver/hw/nxagent/Drawable.c      |   6 +-
 nx-X11/programs/Xserver/hw/nxagent/Font.c          |  14 +-
 nx-X11/programs/Xserver/hw/nxagent/GC.c            |   4 +-
 nx-X11/programs/Xserver/hw/nxagent/GCOps.c         |   6 +-
 nx-X11/programs/Xserver/hw/nxagent/Image.c         |   2 +-
 nx-X11/programs/Xserver/hw/nxagent/Keyboard.c      |   4 +-
 nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c    |   6 +-
 nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c    |  28 +-
 nx-X11/programs/Xserver/hw/nxagent/NXglyphcurs.c   |   2 +-
 nx-X11/programs/Xserver/hw/nxagent/NXmiglyph.c     |   2 +-
 nx-X11/programs/Xserver/hw/nxagent/NXmitrap.c      |   2 +-
 nx-X11/programs/Xserver/hw/nxagent/NXpicture.c     |   8 +-
 nx-X11/programs/Xserver/hw/nxagent/NXproperty.c    |   6 +-
 nx-X11/programs/Xserver/hw/nxagent/NXrender.c      |  16 +-
 nx-X11/programs/Xserver/hw/nxagent/NXresource.c    |   2 +-
 nx-X11/programs/Xserver/hw/nxagent/NXshm.c         |   2 +-
 nx-X11/programs/Xserver/hw/nxagent/Pixmap.c        |   6 +-
 nx-X11/programs/Xserver/hw/nxagent/Reconnect.c     |  24 +-
 nx-X11/programs/Xserver/hw/nxagent/Render.c        |   6 +-
 nx-X11/programs/Xserver/hw/nxagent/Rootless.c      |   2 +-
 nx-X11/programs/Xserver/hw/nxagent/Screen.c        |  32 +-
 nx-X11/programs/Xserver/include/os.h               |   2 +-
 nx-X11/programs/Xserver/mi/miarc.c                 |  16 +-
 nx-X11/programs/Xserver/mi/mibitblt.c              |   4 +-
 nx-X11/programs/Xserver/mi/mibstore.c              |   6 +-
 nx-X11/programs/Xserver/mi/micmap.c                |  10 +-
 nx-X11/programs/Xserver/mi/midispcur.c             |   4 +-
 nx-X11/programs/Xserver/mi/migc.c                  |   2 +-
 nx-X11/programs/Xserver/mi/mioverlay.c             |   2 +-
 nx-X11/programs/Xserver/mi/mipointer.c             |   2 +-
 nx-X11/programs/Xserver/mi/mipolyutil.c            |   2 +-
 nx-X11/programs/Xserver/mi/mipushpxl.c             |   2 +-
 nx-X11/programs/Xserver/mi/miscrinit.c             |   2 +-
 nx-X11/programs/Xserver/mi/mispans.c               |   8 +-
 nx-X11/programs/Xserver/mi/misprite.c              |   2 +-
 nx-X11/programs/Xserver/mi/miwideline.c            |  12 +-
 nx-X11/programs/Xserver/miext/cw/cw.c              |   2 +-
 nx-X11/programs/Xserver/miext/cw/cw_render.c       |   2 +-
 nx-X11/programs/Xserver/miext/damage/damage.c      |   4 +-
 nx-X11/programs/Xserver/os/Imakefile               |  17 +-
 nx-X11/programs/Xserver/os/WaitFor.c               |   2 +-
 nx-X11/programs/Xserver/os/access.c                |  12 +-
 nx-X11/programs/Xserver/os/connection.c            |   6 +-
 nx-X11/programs/Xserver/os/io.c                    |   8 +-
 nx-X11/programs/Xserver/os/log.c                   |   4 +-
 nx-X11/programs/Xserver/os/mitauth.c               |   4 +-
 nx-X11/programs/Xserver/os/oscolor.c               |   6 +-
 nx-X11/programs/Xserver/os/rpcauth.c               |   4 +-
 nx-X11/programs/Xserver/os/utils.c                 |  18 +-
 nx-X11/programs/Xserver/os/xalloc.c                | 817 ---------------------
 nx-X11/programs/Xserver/os/xdmauth.c               |   8 +-
 nx-X11/programs/Xserver/os/xdmcp.c                 |   6 +-
 nx-X11/programs/Xserver/os/xprintf.c               |   4 +-
 nx-X11/programs/Xserver/randr/rrcrtc.c             |  14 +-
 nx-X11/programs/Xserver/randr/rrdispatch.c         |   4 +-
 nx-X11/programs/Xserver/randr/rrinfo.c             |   2 +-
 nx-X11/programs/Xserver/randr/rrmode.c             |   6 +-
 nx-X11/programs/Xserver/randr/rrmonitor.c          |   2 +-
 nx-X11/programs/Xserver/randr/rroutput.c           |  14 +-
 nx-X11/programs/Xserver/randr/rrproperty.c         |  12 +-
 nx-X11/programs/Xserver/randr/rrprovider.c         |   4 +-
 nx-X11/programs/Xserver/randr/rrproviderproperty.c |  12 +-
 nx-X11/programs/Xserver/randr/rrscreen.c           |   8 +-
 nx-X11/programs/Xserver/randr/rrtransform.c        |   2 +-
 nx-X11/programs/Xserver/record/record.c            |  14 +-
 nx-X11/programs/Xserver/record/set.c               |   5 +-
 nx-X11/programs/Xserver/render/animcur.c           |   4 +-
 nx-X11/programs/Xserver/render/filter.c            |  10 +-
 nx-X11/programs/Xserver/render/glyph.c             |   8 +-
 nx-X11/programs/Xserver/render/miindex.c           |   4 +-
 nx-X11/programs/Xserver/render/picture.c           |  20 +-
 nx-X11/programs/Xserver/render/render.c            |  18 +-
 nx-X11/programs/Xserver/xfixes/cursor.c            |   8 +-
 nx-X11/programs/Xserver/xfixes/region.c            |   4 +-
 nx-X11/programs/Xserver/xfixes/select.c            |   2 +-
 nx-X11/programs/Xserver/xkb/xkbActions.c           |   2 +-
 148 files changed, 513 insertions(+), 1403 deletions(-)
 delete mode 100644 nx-X11/programs/Xserver/os/xalloc.c

(limited to 'nx-X11/programs/Xserver/xfixes/select.c')

diff --git a/nx-X11/config/cf/X11.tmpl b/nx-X11/config/cf/X11.tmpl
index a6c410512..2b43ca562 100644
--- a/nx-X11/config/cf/X11.tmpl
+++ b/nx-X11/config/cf/X11.tmpl
@@ -336,15 +336,6 @@ XORGRELSTRING = XorgManVersionString
 #ifndef UseMemLeak
 #define UseMemLeak		NO
 #endif
-#ifndef SpecialMalloc
-#define SpecialMalloc		NO
-#endif
-#ifndef UseInternalMalloc
-#define UseInternalMalloc	NO
-#endif
-#ifndef XallocDefines
-#define XallocDefines		/**/
-#endif
 #ifndef ServerErrorDefines
 #define ServerErrorDefines	/**/
 #endif
diff --git a/nx-X11/config/cf/host.def b/nx-X11/config/cf/host.def
index 76f2f6e8b..bc25ca9ff 100644
--- a/nx-X11/config/cf/host.def
+++ b/nx-X11/config/cf/host.def
@@ -290,12 +290,6 @@ XCOMM $XFree86: xc/config/cf/xf86site.def,v 3.186 2003/06/25 18:06:22 eich Exp $
 #define GnuMallocLibrary	-L/usr/local/lib -lgmalloc
  */
 
-/*
- * To enable the internal Xserver malloc, uncomment this
- *
-#define UseInternalMalloc	YES
- */
-
 /*
  * Some Linux releases don't have a libtermcap.  In this case you may need
  * to uncomment the following
diff --git a/nx-X11/config/cf/lnxLib.rules b/nx-X11/config/cf/lnxLib.rules
index f6f5f8d0b..b8a67e2b7 100644
--- a/nx-X11/config/cf/lnxLib.rules
+++ b/nx-X11/config/cf/lnxLib.rules
@@ -17,17 +17,6 @@ XCOMM $XFree86: xc/config/cf/lnxLib.rules,v 3.52 2003/10/31 20:49:03 herrb Exp $
 
 #if UseElfFormat
 
-# if (LinuxCLibMajorVersion >= 5 && LinuxCLibMinorVersion >= 4) || LinuxCLibMajorVersion >= 6
-#  ifndef SpecialMalloc
-#   define SpecialMalloc NO
-#  endif
-#if 0
-#  ifndef UseInternalMalloc
-#   define UseInternalMalloc NO
-#  endif
-#endif
-# endif
-
 # if LinuxCLibMajorVersion <= 5
 /*
  *	#define BaseShLibReqs	-lc
diff --git a/nx-X11/config/cf/xorg.cf b/nx-X11/config/cf/xorg.cf
index 54ca00bc5..3a391b152 100644
--- a/nx-X11/config/cf/xorg.cf
+++ b/nx-X11/config/cf/xorg.cf
@@ -512,10 +512,6 @@ IPLAN2P8_DEFS = -DUSE_IPLAN2P8
 # endif
 #endif
 
-#ifndef UseInternalMalloc
-# define UseInternalMalloc	NO
-#endif
-
 #ifndef HasDlsymBug
 # define HasDlsymBug		NO
 #endif
diff --git a/nx-X11/config/cf/xorgsite.def b/nx-X11/config/cf/xorgsite.def
index 8a0c805c2..86b6abdbc 100644
--- a/nx-X11/config/cf/xorgsite.def
+++ b/nx-X11/config/cf/xorgsite.def
@@ -162,25 +162,6 @@ XCOMM $XFree86: xc/config/cf/xf86site.def,v 3.186 2003/06/25 18:06:22 eich Exp $
 #define LinuxClibMinorVersion	4
  */
 
-/*
- * If you want to use the GNU malloc library, uncomment this
- *
-#define UseGnuMalloc		YES
- */
-
-/*
- * Set this to whatever is required to access the GNU malloc library.
- * The default is '-lgmalloc' unless is specified in the OS's .cf file.
- *
-#define GnuMallocLibrary	-L/usr/local/lib -lgmalloc
- */
-
-/*
- * To enable the internal Xserver malloc, uncomment this
- *
-#define UseInternalMalloc	YES
- */
-
 /*
  * Some Linux releases don't have a libtermcap.  In this case you may need
  * to uncomment the following
diff --git a/nx-X11/include/Xthreads.h b/nx-X11/include/Xthreads.h
index 97fda5948..b0ec7df32 100644
--- a/nx-X11/include/Xthreads.h
+++ b/nx-X11/include/Xthreads.h
@@ -33,9 +33,6 @@ in this Software without prior written authorization from The Open Group.
 /* Redefine these to XtMalloc/XtFree or whatever you want before including
  * this header file.
  */
-#ifndef xmalloc
-#define xmalloc malloc
-#endif
 
 #ifdef CTHREADS
 #include <cthreads.h>
@@ -279,13 +276,13 @@ static xthread_t _X_no_thread_id;
 typedef xcondition_rec *xcondition_t;
 typedef xmutex_rec *xmutex_t;
 #ifndef xcondition_malloc
-#define xcondition_malloc() (xcondition_t)xmalloc(sizeof(xcondition_rec))
+#define xcondition_malloc() (xcondition_t)malloc(sizeof(xcondition_rec))
 #endif
 #ifndef xcondition_free
 #define xcondition_free(c) free((char *)c)
 #endif
 #ifndef xmutex_malloc
-#define xmutex_malloc() (xmutex_t)xmalloc(sizeof(xmutex_rec))
+#define xmutex_malloc() (xmutex_t)malloc(sizeof(xmutex_rec))
 #endif
 #ifndef xmutex_free
 #define xmutex_free(m) free((char *)m)
diff --git a/nx-X11/lib/xtrans/Xtrans.c b/nx-X11/lib/xtrans/Xtrans.c
index f1e5ff966..934335269 100644
--- a/nx-X11/lib/xtrans/Xtrans.c
+++ b/nx-X11/lib/xtrans/Xtrans.c
@@ -221,7 +221,7 @@ TRANS(ParseAddress) (char *address, char **protocol, char **host, char **port)
 
     /* Copy the string so it can be changed */
 
-    tmpptr = mybuf = (char *) xalloc (strlen (address) + 1);
+    tmpptr = mybuf = (char *) malloc (strlen (address) + 1);
     strcpy (mybuf, address);
 
     /* Parse the string to get each component */
@@ -362,7 +362,7 @@ TRANS(ParseAddress) (char *address, char **protocol, char **host, char **port)
      * string space for them.
      */
 
-    if ((*protocol = (char *) xalloc(strlen (_protocol) + 1)) == NULL)
+    if ((*protocol = (char *) malloc(strlen (_protocol) + 1)) == NULL)
     {
 	/* Malloc failed */
 	*port = NULL;
@@ -374,7 +374,7 @@ TRANS(ParseAddress) (char *address, char **protocol, char **host, char **port)
     else
         strcpy (*protocol, _protocol);
 
-    if ((*host = (char *) xalloc (strlen (_host) + 1)) == NULL)
+    if ((*host = (char *) malloc (strlen (_host) + 1)) == NULL)
     {
 	/* Malloc failed */
 	*port = NULL;
@@ -387,7 +387,7 @@ TRANS(ParseAddress) (char *address, char **protocol, char **host, char **port)
     else
         strcpy (*host, _host);
 
-    if ((*port = (char *) xalloc (strlen (_port) + 1)) == NULL)
+    if ((*port = (char *) malloc (strlen (_port) + 1)) == NULL)
     {
 	/* Malloc failed */
 	*port = NULL;
@@ -539,7 +539,7 @@ TRANS(Reopen) (int type, int trans_id, int fd, char *port)
 	return NULL;
     }
 
-    if ((save_port = (char *) xalloc (strlen (port) + 1)) == NULL)
+    if ((save_port = (char *) malloc (strlen (port) + 1)) == NULL)
     {
 	PRMSG (1,"Reopen: Unable to malloc port string\n", 0, 0, 0);
 
@@ -668,7 +668,7 @@ TRANS(GetReopenInfo) (XtransConnInfo ciptr,
 	    *trans_id = Xtransports[i].transport_id;
 	    *fd = ciptr->fd;
 
-	    if ((*port = (char *) xalloc (strlen (ciptr->port) + 1)) == NULL)
+	    if ((*port = (char *) malloc (strlen (ciptr->port) + 1)) == NULL)
 		return 0;
 	    else
 	    {
@@ -966,7 +966,7 @@ TRANS(GetMyAddr) (XtransConnInfo ciptr, int *familyp, int *addrlenp,
     *familyp = ciptr->family;
     *addrlenp = ciptr->addrlen;
 
-    if ((*addrp = (Xtransaddr *) xalloc (ciptr->addrlen)) == NULL)
+    if ((*addrp = (Xtransaddr *) malloc (ciptr->addrlen)) == NULL)
     {
 	PRMSG (1,"GetMyAddr: malloc failed\n", 0, 0, 0);
 	return -1;
@@ -986,7 +986,7 @@ TRANS(GetPeerAddr) (XtransConnInfo ciptr, int *familyp, int *addrlenp,
     *familyp = ciptr->family;
     *addrlenp = ciptr->peeraddrlen;
 
-    if ((*addrp = (Xtransaddr *) xalloc (ciptr->peeraddrlen)) == NULL)
+    if ((*addrp = (Xtransaddr *) malloc (ciptr->peeraddrlen)) == NULL)
     {
 	PRMSG (1,"GetPeerAddr: malloc failed\n", 0, 0, 0);
 	return -1;
@@ -1141,7 +1141,7 @@ TRANS(MakeAllCOTSServerListeners) (char *port, int *partial, int *count_ret,
 
     if (*count_ret > 0)
     {
-	if ((*ciptrs_ret = (XtransConnInfo *) xalloc (
+	if ((*ciptrs_ret = (XtransConnInfo *) malloc (
 	    *count_ret * sizeof (XtransConnInfo))) == NULL)
 	{
 	    return -1;
@@ -1239,7 +1239,7 @@ TRANS(MakeAllCLTSServerListeners) (char *port, int *partial, int *count_ret,
 
     if (*count_ret > 0)
     {
-	if ((*ciptrs_ret = (XtransConnInfo *) xalloc (
+	if ((*ciptrs_ret = (XtransConnInfo *) malloc (
 	    *count_ret * sizeof (XtransConnInfo))) == NULL)
 	{
 	    return -1;
diff --git a/nx-X11/lib/xtrans/Xtransdnet.c b/nx-X11/lib/xtrans/Xtransdnet.c
index 34e191260..161d48099 100644
--- a/nx-X11/lib/xtrans/Xtransdnet.c
+++ b/nx-X11/lib/xtrans/Xtransdnet.c
@@ -121,7 +121,7 @@ TRANS(DNETGetAddr) (XtransConnInfo ciptr)
      * Everything looks good: fill in the XtransConnInfo structure.
      */
 
-    if ((ciptr->addr = (char *) xalloc (namelen)) == NULL)
+    if ((ciptr->addr = (char *) malloc (namelen)) == NULL)
     {
         PRMSG (1, "DNETGetAddr: Can't allocate space for the addr\n",
 	       0, 0, 0);
@@ -161,7 +161,7 @@ TRANS(DNETGetPeerAddr) (XtransConnInfo ciptr)
      * Everything looks good: fill in the XtransConnInfo structure.
      */
 
-    if ((ciptr->peeraddr = (char *) xalloc (namelen)) == NULL)
+    if ((ciptr->peeraddr = (char *) malloc (namelen)) == NULL)
     {
         PRMSG (1,
 	      "DNETGetPeerAddr: Can't allocate space for the addr\n",
diff --git a/nx-X11/lib/xtrans/Xtranslcl.c b/nx-X11/lib/xtrans/Xtranslcl.c
index c1689c654..ebc8518ee 100644
--- a/nx-X11/lib/xtrans/Xtranslcl.c
+++ b/nx-X11/lib/xtrans/Xtranslcl.c
@@ -144,7 +144,7 @@ TRANS(FillAddrInfo)(XtransConnInfo ciptr, char *sun_path, char *peer_sun_path)
     ciptr->family = AF_UNIX;
     ciptr->addrlen = sizeof (struct sockaddr_un);
 
-    if ((sunaddr = (struct sockaddr_un *) xalloc (ciptr->addrlen)) == NULL)
+    if ((sunaddr = (struct sockaddr_un *) malloc (ciptr->addrlen)) == NULL)
     {
 	PRMSG(1,"FillAddrInfo: failed to allocate memory for addr\n", 0, 0, 0);
 	return 0;
@@ -165,7 +165,7 @@ TRANS(FillAddrInfo)(XtransConnInfo ciptr, char *sun_path, char *peer_sun_path)
 
     ciptr->peeraddrlen = sizeof (struct sockaddr_un);
 
-    if ((p_sunaddr = (struct sockaddr_un *) xalloc (
+    if ((p_sunaddr = (struct sockaddr_un *) malloc (
 	ciptr->peeraddrlen)) == NULL)
     {
 	PRMSG(1,
@@ -596,7 +596,7 @@ TRANS(PTSAccept)(XtransConnInfo ciptr, XtransConnInfo newciptr, int *status)
      */
 
     newciptr->addrlen=ciptr->addrlen;
-    if( (newciptr->addr=(char *)xalloc(newciptr->addrlen)) == NULL ) {
+    if( (newciptr->addr=(char *)malloc(newciptr->addrlen)) == NULL ) {
 	PRMSG(1,"PTSAccept: failed to allocate memory for peer addr\n",
 									0,0,0);
 	close(newfd);
@@ -607,7 +607,7 @@ TRANS(PTSAccept)(XtransConnInfo ciptr, XtransConnInfo newciptr, int *status)
     memcpy(newciptr->addr,ciptr->addr,newciptr->addrlen);
 
     newciptr->peeraddrlen=sizeof(struct sockaddr_un);
-    if( (sunaddr=(struct sockaddr_un *)xalloc(newciptr->peeraddrlen)) == NULL ) {
+    if( (sunaddr=(struct sockaddr_un *)malloc(newciptr->peeraddrlen)) == NULL ) {
 	PRMSG(1,"PTSAccept: failed to allocate memory for peer addr\n",
 									0,0,0);
 	free(newciptr->addr);
@@ -818,7 +818,7 @@ TRANS(NAMEDAccept)(XtransConnInfo ciptr, XtransConnInfo newciptr, int *status)
      */
 
     newciptr->addrlen=ciptr->addrlen;
-    if( (newciptr->addr=(char *)xalloc(newciptr->addrlen)) == NULL ) {
+    if( (newciptr->addr=(char *)malloc(newciptr->addrlen)) == NULL ) {
 	PRMSG(1,
 	      "NAMEDAccept: failed to allocate memory for peer addr\n",
 									0,0,0);
@@ -830,7 +830,7 @@ TRANS(NAMEDAccept)(XtransConnInfo ciptr, XtransConnInfo newciptr, int *status)
     memcpy(newciptr->addr,ciptr->addr,newciptr->addrlen);
 
     newciptr->peeraddrlen=newciptr->addrlen;
-    if( (newciptr->peeraddr=(char *)xalloc(newciptr->peeraddrlen)) == NULL ) {
+    if( (newciptr->peeraddr=(char *)malloc(newciptr->peeraddrlen)) == NULL ) {
 	PRMSG(1,
 	"NAMEDAccept: failed to allocate memory for peer addr\n",
 									0,0,0);
@@ -1162,7 +1162,7 @@ TRANS(ISCAccept)(XtransConnInfo ciptr, XtransConnInfo newciptr, int *status)
      */
 
     newciptr->addrlen=ciptr->addrlen;
-    if( (newciptr->addr=(char *)xalloc(newciptr->addrlen)) == NULL ) {
+    if( (newciptr->addr=(char *)malloc(newciptr->addrlen)) == NULL ) {
 	PRMSG(1,
 	      "ISCAccept: failed to allocate memory for peer addr\n",
 	      0,0,0);
@@ -1174,7 +1174,7 @@ TRANS(ISCAccept)(XtransConnInfo ciptr, XtransConnInfo newciptr, int *status)
     memcpy(newciptr->addr,ciptr->addr,newciptr->addrlen);
 
     newciptr->peeraddrlen=newciptr->addrlen;
-    if( (newciptr->peeraddr=(char *)xalloc(newciptr->peeraddrlen)) == NULL ) {
+    if( (newciptr->peeraddr=(char *)malloc(newciptr->peeraddrlen)) == NULL ) {
 	PRMSG(1,
 	      "ISCAccept: failed to allocate memory for peer addr\n",
 	      0,0,0);
@@ -1436,7 +1436,7 @@ TRANS(SCOAccept)(XtransConnInfo ciptr, XtransConnInfo newciptr, int *status)
      */
 
     newciptr->addrlen=ciptr->addrlen;
-    if( (newciptr->addr=(char *)xalloc(newciptr->addrlen)) == NULL ) {
+    if( (newciptr->addr=(char *)malloc(newciptr->addrlen)) == NULL ) {
 	PRMSG(1,
 	      "SCOAccept: failed to allocate memory for peer addr\n",
 	      0,0,0);
@@ -1451,7 +1451,7 @@ TRANS(SCOAccept)(XtransConnInfo ciptr, XtransConnInfo newciptr, int *status)
 #endif
 
     newciptr->peeraddrlen=newciptr->addrlen;
-    if( (newciptr->peeraddr=(char *)xalloc(newciptr->peeraddrlen)) == NULL ) {
+    if( (newciptr->peeraddr=(char *)malloc(newciptr->peeraddrlen)) == NULL ) {
 	PRMSG(1,
 	      "SCOAccept: failed to allocate memory for peer addr\n",
 	      0,0,0);
@@ -1894,7 +1894,7 @@ TRANS(LocalInitTransports)(char *protocol)
 
     if( strcmp(protocol,"local") && strcmp(protocol,"LOCAL") )
     {
-	workingXLOCAL=freeXLOCAL=(char *)xalloc (strlen (protocol) + 1);
+	workingXLOCAL=freeXLOCAL=(char *)malloc (strlen (protocol) + 1);
 	if (workingXLOCAL)
 	    strcpy (workingXLOCAL, protocol);
     }
@@ -1902,7 +1902,7 @@ TRANS(LocalInitTransports)(char *protocol)
 	XLOCAL=(char *)getenv("XLOCAL");
 	if(XLOCAL==NULL)
 	    XLOCAL=DEF_XLOCAL;
-	workingXLOCAL=freeXLOCAL=(char *)xalloc (strlen (XLOCAL) + 1);
+	workingXLOCAL=freeXLOCAL=(char *)malloc (strlen (XLOCAL) + 1);
 	if (workingXLOCAL)
 	    strcpy (workingXLOCAL, XLOCAL);
     }
diff --git a/nx-X11/lib/xtrans/Xtransos2.c b/nx-X11/lib/xtrans/Xtransos2.c
index 807a6029d..9fd5049a0 100644
--- a/nx-X11/lib/xtrans/Xtransos2.c
+++ b/nx-X11/lib/xtrans/Xtransos2.c
@@ -202,7 +202,7 @@ TRANS(Os2OpenClient)(Xtransport *thistrans, char *protocol,
            }
 
         namelen=sizeof(struct sockaddr);
-        if ((ciptr->addr = (char *) xalloc (namelen)) == NULL)
+        if ((ciptr->addr = (char *) malloc (namelen)) == NULL)
           {
                 PRMSG (1, "Os2OpenClient: Can't allocate space for the addr\n",
 	        0, 0, 0);
@@ -214,7 +214,7 @@ TRANS(Os2OpenClient)(Xtransport *thistrans, char *protocol,
         ((struct sockaddr *)ciptr->addr)->sa_family = AF_UNIX;
         strcpy(((struct sockaddr *)ciptr->addr)->sa_data, "local");
 
-        if ((ciptr->peeraddr = (char *) xalloc (namelen)) == NULL)
+        if ((ciptr->peeraddr = (char *) malloc (namelen)) == NULL)
           {
                 PRMSG (1, "Os2OpenCLient: Can't allocate space for the addr\n",
 	        0, 0, 0);
@@ -316,7 +316,7 @@ TRANS(Os2OpenServer)(Xtransport *thistrans, char *protocol,
 /*** Put in info ***/
 
         namelen=sizeof(struct sockaddr);
-        if ((ciptr->addr = (char *) xalloc (namelen)) == NULL)
+        if ((ciptr->addr = (char *) malloc (namelen)) == NULL)
           {
                 PRMSG (1, "Os2OpenServer: Can't allocate space for the addr\n",
 	        0, 0, 0);
@@ -328,7 +328,7 @@ TRANS(Os2OpenServer)(Xtransport *thistrans, char *protocol,
         ((struct sockaddr *)ciptr->addr)->sa_family = AF_UNIX;
         strcpy (((struct sockaddr *)ciptr->addr)->sa_data, "local");
 
-        if ((ciptr->peeraddr = (char *) xalloc (namelen)) == NULL)
+        if ((ciptr->peeraddr = (char *) malloc (namelen)) == NULL)
           {
                 PRMSG (1, "Os2OpenServer: Can't allocate space for the addr\n",
 	        0, 0, 0);
@@ -441,7 +441,7 @@ TRANS(Os2ReopenCOTSServer)(Xtransport *thistrans, int fd, char *port)
 
         strcpy(addr_name,"local");
         namelen=sizeof(addr_name);
-        if ((ciptr->addr = (char *) xalloc (namelen)) == NULL)
+        if ((ciptr->addr = (char *) malloc (namelen)) == NULL)
           {
                 PRMSG (1, "Os2ReopenCOTSServer: Can't allocate space for the addr\n",
 	        0, 0, 0);
@@ -451,7 +451,7 @@ TRANS(Os2ReopenCOTSServer)(Xtransport *thistrans, int fd, char *port)
 
         ciptr->addrlen = namelen;
         memcpy (ciptr->addr, addr_name, ciptr->addrlen);
-        if ((ciptr->peeraddr = (char *) xalloc (namelen)) == NULL)
+        if ((ciptr->peeraddr = (char *) malloc (namelen)) == NULL)
           {
                 PRMSG (1, "Os2ReopenCOTSServer: Can't allocate space for the addr\n",
 	        0, 0, 0);
@@ -605,7 +605,7 @@ TRANS(Os2Accept)(XtransConnInfo ciptr, int *status)
 /* And finally fill-in info in newciptr */
 
         namelen=sizeof(struct sockaddr);
-        if ((newciptr->addr = (char *) xalloc (namelen)) == NULL)
+        if ((newciptr->addr = (char *) malloc (namelen)) == NULL)
           {
                 PRMSG (1, "Os2Accept: Can't allocate space for the addr\n",
 	        0, 0, 0);
@@ -618,7 +618,7 @@ TRANS(Os2Accept)(XtransConnInfo ciptr, int *status)
         ((struct sockaddr *)newciptr->addr)->sa_family = AF_UNIX;
         strcpy (((struct sockaddr *)newciptr->addr)->sa_data, "local");
 
-        if ((newciptr->peeraddr = (char *) xalloc (namelen)) == NULL)
+        if ((newciptr->peeraddr = (char *) malloc (namelen)) == NULL)
           {
                 PRMSG (1, "Os2Accept: Can't allocate space for the addr\n",
 	        0, 0, 0);
diff --git a/nx-X11/lib/xtrans/Xtranssock.c b/nx-X11/lib/xtrans/Xtranssock.c
index 6a6600435..79b95efdc 100644
--- a/nx-X11/lib/xtrans/Xtranssock.c
+++ b/nx-X11/lib/xtrans/Xtranssock.c
@@ -957,7 +957,7 @@ TRANS(SocketINETGetAddr) (XtransConnInfo ciptr)
      * Everything looks good: fill in the XtransConnInfo structure.
      */
 
-    if ((ciptr->addr = (char *) xalloc (namelen)) == NULL)
+    if ((ciptr->addr = (char *) malloc (namelen)) == NULL)
     {
         PRMSG (1,
 	    "SocketINETGetAddr: Can't allocate space for the addr\n",
@@ -1032,7 +1032,7 @@ TRANS(SocketINETGetPeerAddr) (XtransConnInfo ciptr)
      * Everything looks good: fill in the XtransConnInfo structure.
      */
 
-    if ((ciptr->peeraddr = (char *) xalloc (namelen)) == NULL)
+    if ((ciptr->peeraddr = (char *) malloc (namelen)) == NULL)
     {
         PRMSG (1,
 	   "SocketINETGetPeerAddr: Can't allocate space for the addr\n",
@@ -1834,7 +1834,7 @@ TRANS(SocketUNIXCreateListener) (XtransConnInfo ciptr, char *port,
 
     namelen = sizeof (sockname); /* this will always make it the same size */
 
-    if ((ciptr->addr = (char *) xalloc (namelen)) == NULL)
+    if ((ciptr->addr = (char *) malloc (namelen)) == NULL)
     {
         PRMSG (1,
         "SocketUNIXCreateListener: Can't allocate space for the addr\n",
@@ -2058,7 +2058,7 @@ TRANS(SocketUNIXAccept) (XtransConnInfo ciptr, int *status)
      * since this is unix domain.
      */
 
-    if ((newciptr->addr = (char *) xalloc (ciptr->addrlen)) == NULL)
+    if ((newciptr->addr = (char *) malloc (ciptr->addrlen)) == NULL)
     {
         PRMSG (1,
         "SocketUNIXAccept: Can't allocate space for the addr\n",
@@ -2078,7 +2078,7 @@ TRANS(SocketUNIXAccept) (XtransConnInfo ciptr, int *status)
     newciptr->addrlen = ciptr->addrlen;
     memcpy (newciptr->addr, ciptr->addr, newciptr->addrlen);
 
-    if ((newciptr->peeraddr = (char *) xalloc (ciptr->addrlen)) == NULL)
+    if ((newciptr->peeraddr = (char *) malloc (ciptr->addrlen)) == NULL)
     {
         PRMSG (1,
 	      "SocketUNIXAccept: Can't allocate space for the addr\n",
@@ -2827,8 +2827,8 @@ SocketUNIXConnectPost:
      * since this is unix domain.
      */
 
-    if ((ciptr->addr = (char *) xalloc(namelen)) == NULL ||
-       (ciptr->peeraddr = (char *) xalloc(namelen)) == NULL)
+    if ((ciptr->addr = (char *) malloc(namelen)) == NULL ||
+       (ciptr->peeraddr = (char *) malloc(namelen)) == NULL)
     {
         PRMSG (1,
 	"SocketUNIXCreateListener: Can't allocate space for the addr\n",
diff --git a/nx-X11/lib/xtrans/Xtranstli.c b/nx-X11/lib/xtrans/Xtranstli.c
index ab37275dd..521f6a48c 100644
--- a/nx-X11/lib/xtrans/Xtranstli.c
+++ b/nx-X11/lib/xtrans/Xtranstli.c
@@ -173,7 +173,7 @@ TRANS(TLIGetAddr)(XtransConnInfo ciptr)
     if( ciptr->addr )
 	free(ciptr->addr);
     
-    if( (ciptr->addr=(char *)xalloc(netbuf.len)) == NULL )
+    if( (ciptr->addr=(char *)malloc(netbuf.len)) == NULL )
     {
 	PRMSG(1, "TLIGetAddr: Can't allocate space for the addr\n",
 	      0,0,0);
@@ -223,7 +223,7 @@ TRANS(TLIGetPeerAddr)(XtransConnInfo ciptr)
     if( ciptr->peeraddr )
 	free(ciptr->peeraddr);
     
-    if( (ciptr->peeraddr=(char *)xalloc(netbuf.len)) == NULL )
+    if( (ciptr->peeraddr=(char *)malloc(netbuf.len)) == NULL )
     {
 	PRMSG(1,
 	      "TLIGetPeerAddr: Can't allocate space for the addr\n",
@@ -730,7 +730,7 @@ TRANS(TLICreateListener)(XtransConnInfo ciptr, struct t_bind *req)
      * Everything looks good: fill in the XtransConnInfo structure.
      */
     
-    if( (ciptr->addr=(char *)xalloc(ret->addr.len)) == NULL )
+    if( (ciptr->addr=(char *)malloc(ret->addr.len)) == NULL )
     {
 	PRMSG(1,
 	      "TLICreateListener: Unable to allocate space for the address\n",
diff --git a/nx-X11/lib/xtrans/Xtransutil.c b/nx-X11/lib/xtrans/Xtransutil.c
index 7dc91b16c..cfe925edf 100644
--- a/nx-X11/lib/xtrans/Xtransutil.c
+++ b/nx-X11/lib/xtrans/Xtransutil.c
@@ -215,7 +215,7 @@ TRANS(ConvertAddress)(int *familyp, int *addrlenp, Xtransaddr **addrp)
 		*addrp = NULL;
 	    }
 	    if (!*addrp)
-		*addrp = (Xtransaddr *) xalloc (len + 1);
+		*addrp = (Xtransaddr *) malloc (len + 1);
 	    if (*addrp) {
 		strcpy ((char *) *addrp, hostnamebuf);
 		*addrlenp = len;
@@ -262,7 +262,7 @@ TRANS(GetMyNetworkId) (XtransConnInfo ciptr)
     case AF_UNIX:
     {
 	struct sockaddr_un *saddr = (struct sockaddr_un *) addr;
-	networkId = (char *) xalloc (3 + strlen (transName) +
+	networkId = (char *) malloc (3 + strlen (transName) +
 	    strlen (hostnamebuf) + strlen (saddr->sun_path));
 	sprintf (networkId, "%s/%s:%s", transName,
 	    hostnamebuf, saddr->sun_path);
@@ -292,7 +292,7 @@ TRANS(GetMyNetworkId) (XtransConnInfo ciptr)
 	    portnum = ntohs (saddr->sin_port);
 
 	sprintf (portnumbuf, "%d", portnum);
-	networkId = (char *) xalloc (3 + strlen (transName) +
+	networkId = (char *) malloc (3 + strlen (transName) +
 	    strlen (hostnamebuf) + strlen (portnumbuf));
 	sprintf (networkId, "%s/%s:%s", transName, hostnamebuf, portnumbuf);
 	break;
@@ -304,7 +304,7 @@ TRANS(GetMyNetworkId) (XtransConnInfo ciptr)
     {
 	struct sockaddr_dn *saddr = (struct sockaddr_dn *) addr;
 
-	networkId = (char *) xalloc (
+	networkId = (char *) malloc (
 	    13 + strlen (hostnamebuf) + saddr->sdn_objnamel);
 	sprintf (networkId, "dnet/%s::%s",
 	    hostnamebuf, saddr->sdn_objname);
@@ -453,7 +453,7 @@ TRANS(GetPeerNetworkId) (XtransConnInfo ciptr)
     }
 
 
-    hostname = (char *) xalloc (
+    hostname = (char *) malloc (
 	strlen (ciptr->transptr->TransName) + strlen (addr) + 2);
     strcpy (hostname, ciptr->transptr->TransName);
     strcat (hostname, "/");
diff --git a/nx-X11/lib/xtrans/transport.c b/nx-X11/lib/xtrans/transport.c
index 49441d76e..8d3516dba 100644
--- a/nx-X11/lib/xtrans/transport.c
+++ b/nx-X11/lib/xtrans/transport.c
@@ -59,7 +59,6 @@ from The Open Group.
 #include "os.h"
 #else
 #include <stdlib.h>
-#define xalloc(_size)		malloc(_size)
 #define xcalloc(_num,_size)	calloc(_num,_size)
 #define xrealloc(_ptr,_size)	realloc(_ptr,_size)
 #endif
diff --git a/nx-X11/programs/Xserver/GL/glx/glxcmds.c b/nx-X11/programs/Xserver/GL/glx/glxcmds.c
index c62585507..7d8fbe81f 100644
--- a/nx-X11/programs/Xserver/GL/glx/glxcmds.c
+++ b/nx-X11/programs/Xserver/GL/glx/glxcmds.c
@@ -2138,7 +2138,7 @@ int __glXQueryServerString(__GLXclientState *cl, GLbyte *pc)
     reply.length = length;
     reply.n = n;
 
-    if ((buf = (char *) Xalloc(length << 2)) == NULL) {
+    if ((buf = (char *) malloc(length << 2)) == NULL) {
         return BadAlloc;
     }
     __glXStrncpy(buf, ptr, n);
diff --git a/nx-X11/programs/Xserver/GL/glx/glximports.c b/nx-X11/programs/Xserver/GL/glx/glximports.c
index 5b6c545fc..b1245f900 100644
--- a/nx-X11/programs/Xserver/GL/glx/glximports.c
+++ b/nx-X11/programs/Xserver/GL/glx/glximports.c
@@ -50,7 +50,7 @@ void *__glXImpMalloc(__GLcontext *gc, size_t size)
     if (size == 0) {
 	return NULL;
     }
-    addr = xalloc(size);
+    addr = malloc(size);
     if (addr == NULL) {
 	/* XXX: handle out of memory error */
 	return NULL;
@@ -67,7 +67,7 @@ void *__glXImpCalloc(__GLcontext *gc, size_t numElements, size_t elementSize)
 	return NULL;
     }
     size = numElements * elementSize;
-    addr = xalloc(size);
+    addr = malloc(size);
     if (addr == NULL) {
 	/* XXX: handle out of memory error */
 	return NULL;
@@ -99,7 +99,7 @@ void *__glXImpRealloc(__GLcontext *gc, void *addr, size_t newSize)
 	if (newSize == 0) {
 	    return NULL;
 	}
-	newAddr = xalloc(newSize);
+	newAddr = malloc(newSize);
     }
     if (newAddr == NULL) {
 	return NULL;	/* XXX: out of memory error */
diff --git a/nx-X11/programs/Xserver/GL/glx/glxutil.c b/nx-X11/programs/Xserver/GL/glx/glxutil.c
index cf0aae011..715bb5c99 100644
--- a/nx-X11/programs/Xserver/GL/glx/glxutil.c
+++ b/nx-X11/programs/Xserver/GL/glx/glxutil.c
@@ -68,7 +68,7 @@ __glXMalloc(size_t size)
     if (size == 0) {
 	return NULL;
     }
-    addr = (void *) xalloc(size);
+    addr = (void *) malloc(size);
     if (addr == NULL) {
 	/* XXX: handle out of memory error */
 	return NULL;
@@ -86,7 +86,7 @@ __glXCalloc(size_t numElements, size_t elementSize)
 	return NULL;
     }
     size = numElements * elementSize;
-    addr = (void *) xalloc(size);
+    addr = (void *) malloc(size);
     if (addr == NULL) {
 	/* XXX: handle out of memory error */
 	return NULL;
@@ -111,7 +111,7 @@ __glXRealloc(void *addr, size_t newSize)
 	if (newSize == 0) {
 	    return NULL;
 	} else {
-	    newAddr = xalloc(newSize);
+	    newAddr = malloc(newSize);
 	}
     }
     if (newAddr == NULL) {
diff --git a/nx-X11/programs/Xserver/GL/mesa/X/xf86glx_util.c b/nx-X11/programs/Xserver/GL/mesa/X/xf86glx_util.c
index 0a86bf208..057acb6d3 100644
--- a/nx-X11/programs/Xserver/GL/mesa/X/xf86glx_util.c
+++ b/nx-X11/programs/Xserver/GL/mesa/X/xf86glx_util.c
@@ -52,7 +52,7 @@ XMesaImage *XMesaCreateImage(int bitsPerPixel, int width, int height, char *data
 {
     XMesaImage *image;
 
-    image = (XMesaImage *)xalloc(sizeof(XMesaImage));
+    image = (XMesaImage *)malloc(sizeof(XMesaImage));
 
     if (image) {
 	image->width = width;
diff --git a/nx-X11/programs/Xserver/Xext/extmod/modinit.c b/nx-X11/programs/Xserver/Xext/extmod/modinit.c
index 5bfd15719..5224a8ad9 100644
--- a/nx-X11/programs/Xserver/Xext/extmod/modinit.c
+++ b/nx-X11/programs/Xserver/Xext/extmod/modinit.c
@@ -161,7 +161,7 @@ extmodSetup(void * module, void * opts, int *errmaj, int *errmin)
     for (i = 0; extensionModules[i].name != NULL; i++) {
 	if (opts) {
 	    char *s;
-	    s = (char *)xalloc(strlen(extensionModules[i].name) + 5);
+	    s = (char *)malloc(strlen(extensionModules[i].name) + 5);
 	    if (s) {
 		void * o;
 		strcpy(s, "omit");
diff --git a/nx-X11/programs/Xserver/Xext/panoramiX.c b/nx-X11/programs/Xserver/Xext/panoramiX.c
index c3b47cf2c..ecf3453bb 100644
--- a/nx-X11/programs/Xserver/Xext/panoramiX.c
+++ b/nx-X11/programs/Xserver/Xext/panoramiX.c
@@ -420,7 +420,7 @@ XineramaRegisterConnectionBlockCallback(void (*func)(void))
 {
     XineramaConnectionCallbackList *newlist;
 
-    if(!(newlist = xalloc(sizeof(XineramaConnectionCallbackList))))
+    if(!(newlist = malloc(sizeof(XineramaConnectionCallbackList))))
 	return FALSE;
 
     newlist->next = ConnectionCallbackList;
@@ -539,7 +539,7 @@ void PanoramiXExtensionInit(int argc, char *argv[])
 		return;
 	   }
 
-	   pScreenPriv = xalloc(sizeof(PanoramiXScreenRec));
+	   pScreenPriv = malloc(sizeof(PanoramiXScreenRec));
 	   pScreen->devPrivates[PanoramiXScreenIndex].ptr = 
 						(void *)pScreenPriv;
 	   if(!pScreenPriv) {
@@ -805,7 +805,7 @@ void PanoramiXConsolidate(void)
             PanoramiXDepths[PanoramiXNumDepths].numVids = 0;
             if(pDepth->numVids)
                 PanoramiXDepths[PanoramiXNumDepths].vids = 
-                      xalloc(sizeof(VisualID) * pDepth->numVids);      
+                      malloc(sizeof(VisualID) * pDepth->numVids);      
             else
                 PanoramiXDepths[PanoramiXNumDepths].vids = NULL;
             PanoramiXNumDepths++;
@@ -887,11 +887,11 @@ void PanoramiXConsolidate(void)
     } 
 
 
-    root = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes));
+    root = (PanoramiXRes *) malloc(sizeof(PanoramiXRes));
     root->type = XRT_WINDOW;
-    defmap = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes));
+    defmap = (PanoramiXRes *) malloc(sizeof(PanoramiXRes));
     defmap->type = XRT_COLORMAP;
-    saver = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes));
+    saver = (PanoramiXRes *) malloc(sizeof(PanoramiXRes));
     saver->type = XRT_WINDOW;
 
 
diff --git a/nx-X11/programs/Xserver/Xext/panoramiXprocs.c b/nx-X11/programs/Xserver/Xext/panoramiXprocs.c
index 28c0eb8b0..9682f2427 100644
--- a/nx-X11/programs/Xserver/Xext/panoramiXprocs.c
+++ b/nx-X11/programs/Xserver/Xext/panoramiXprocs.c
@@ -130,7 +130,7 @@ int PanoramiXCreateWindow(ClientPtr client)
 	}
     }
 
-    if(!(newWin = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes))))
+    if(!(newWin = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
         return BadAlloc;
 
     newWin->type = XRT_WINDOW;
@@ -660,7 +660,7 @@ int PanoramiXCreatePixmap(ClientPtr client)
 		client, stuff->drawable, XRC_DRAWABLE, SecurityReadAccess)))
 	return BadDrawable;
 
-    if(!(newPix = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes))))
+    if(!(newPix = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
 	return BadAlloc;
 
     newPix->type = XRT_PIXMAP;
@@ -760,7 +760,7 @@ int PanoramiXCreateGC(ClientPtr client)
 	}
     }
 
-    if(!(newGC = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes))))
+    if(!(newGC = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
         return BadAlloc;
 
     newGC->type = XRT_GC;
@@ -1844,7 +1844,7 @@ int PanoramiXGetImage(ClientPtr client)
 	    linesPerBuf = h;
     }
     length = linesPerBuf * widthBytesLine;
-    if(!(pBuf = xalloc(length)))
+    if(!(pBuf = malloc(length)))
 	return (BadAlloc);
 
     WriteReplyToClient(client, sizeof (xGetImageReply), &xgi);
@@ -2072,7 +2072,7 @@ int PanoramiXCreateColormap(ClientPtr client)
     if(!stuff->visual || (stuff->visual > 255)) 
 	return BadValue;
 
-    if(!(newCmap = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes))))
+    if(!(newCmap = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
         return BadAlloc;
 
     newCmap->type = XRT_COLORMAP;
@@ -2141,7 +2141,7 @@ PanoramiXCopyColormapAndFree(ClientPtr client)
 		SecurityReadAccess | SecurityWriteAccess)))
         return BadColor;
 
-    if(!(newCmap = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes))))
+    if(!(newCmap = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
         return BadAlloc;
 
     newCmap->type = XRT_COLORMAP;
diff --git a/nx-X11/programs/Xserver/Xext/saver.c b/nx-X11/programs/Xserver/Xext/saver.c
index 68dbe2fe8..f9a86899f 100644
--- a/nx-X11/programs/Xserver/Xext/saver.c
+++ b/nx-X11/programs/Xserver/Xext/saver.c
@@ -218,7 +218,7 @@ static int ScreenPrivateIndex;
 #define SetScreenPrivate(s,v) ((s)->devPrivates[ScreenPrivateIndex].ptr = (void *) v);
 #define SetupScreen(s)	ScreenSaverScreenPrivatePtr pPriv = (s ? GetScreenPrivate(s) : NULL)
 
-#define New(t)	((t *) xalloc (sizeof (t)))
+#define New(t)	((t *) malloc (sizeof (t)))
 
 /****************
  * ScreenSaverExtensionInit
@@ -939,7 +939,7 @@ ScreenSaverSetAttributes (ClientPtr client)
 	goto bail;
     }
     /* over allocate for override redirect */
-    values = (unsigned long *) xalloc ((len + 1) * sizeof (unsigned long));
+    values = (unsigned long *) malloc ((len + 1) * sizeof (unsigned long));
     if (!values)
     {
 	ret = BadAlloc;
diff --git a/nx-X11/programs/Xserver/Xext/security.c b/nx-X11/programs/Xserver/Xext/security.c
index ceadd8f6a..ec5f371db 100644
--- a/nx-X11/programs/Xserver/Xext/security.c
+++ b/nx-X11/programs/Xserver/Xext/security.c
@@ -524,7 +524,7 @@ SecurityEventSelectForAuthorization(
 	}
     }
     
-    pEventClient = (OtherClients *) xalloc(sizeof(OtherClients));
+    pEventClient = (OtherClients *) malloc(sizeof(OtherClients));
     if (!pEventClient)
 	return BadAlloc;
     pEventClient->mask = mask;
@@ -662,7 +662,7 @@ ProcSecurityGenerateAuthorization(
 
     /* associate additional information with this auth ID */
 
-    pAuth = (SecurityAuthorizationPtr)xalloc(sizeof(SecurityAuthorizationRec));
+    pAuth = (SecurityAuthorizationPtr)malloc(sizeof(SecurityAuthorizationRec));
     if (!pAuth)
     {
 	err = BadAlloc;
@@ -1643,7 +1643,7 @@ SecurityParsePropertyAccessRule(
      */
     if (mustHaveValue)
 	size += strlen(mustHaveValue) + 1;
-    pacl = (PropertyAccessPtr)Xalloc(size);
+    pacl = (PropertyAccessPtr)malloc(size);
     if (!pacl)
 	return FALSE;
 
@@ -1716,7 +1716,7 @@ SecurityParseSitePolicy(
     if (!policyStr)
 	return FALSE;
 
-    copyPolicyStr = (char *)Xalloc(strlen(policyStr) + 1);
+    copyPolicyStr = (char *)malloc(strlen(policyStr) + 1);
     if (!copyPolicyStr)
 	return TRUE;
     strcpy(copyPolicyStr, policyStr);
diff --git a/nx-X11/programs/Xserver/Xext/shape.c b/nx-X11/programs/Xserver/Xext/shape.c
index a55dd4553..b929dded0 100644
--- a/nx-X11/programs/Xserver/Xext/shape.c
+++ b/nx-X11/programs/Xserver/Xext/shape.c
@@ -849,7 +849,7 @@ ProcShapeSelectInput (client)
 
 	/* build the entry */
     	pNewShapeEvent = (ShapeEventPtr)
-			    xalloc (sizeof (ShapeEventRec));
+			    malloc (sizeof (ShapeEventRec));
     	if (!pNewShapeEvent)
 	    return BadAlloc;
     	pNewShapeEvent->next = 0;
@@ -871,7 +871,7 @@ ProcShapeSelectInput (client)
      	 */
     	if (!pHead)
     	{
-	    pHead = (ShapeEventPtr *) xalloc (sizeof (ShapeEventPtr));
+	    pHead = (ShapeEventPtr *) malloc (sizeof (ShapeEventPtr));
 	    if (!pHead ||
 		!AddResource (pWin->drawable.id, EventType, (void *)pHead))
 	    {
diff --git a/nx-X11/programs/Xserver/Xext/shm.c b/nx-X11/programs/Xserver/Xext/shm.c
index 4e36a6bb4..af529e46f 100644
--- a/nx-X11/programs/Xserver/Xext/shm.c
+++ b/nx-X11/programs/Xserver/Xext/shm.c
@@ -439,7 +439,7 @@ ProcShmAttach(client)
     }
     else
     {
-	shmdesc = (ShmDescPtr) xalloc(sizeof(ShmDescRec));
+	shmdesc = (ShmDescPtr) malloc(sizeof(ShmDescRec));
 	if (!shmdesc)
 	    return BadAlloc;
 	shmdesc->addr = shmat(stuff->shmid, 0,
@@ -779,7 +779,7 @@ CreatePmap:
 
     VERIFY_SHMSIZE(shmdesc, stuff->offset, size, client);
 
-    if(!(newPix = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes))))
+    if(!(newPix = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
 	return BadAlloc;
 
     newPix->type = XRT_PIXMAP;
diff --git a/nx-X11/programs/Xserver/Xext/sleepuntil.c b/nx-X11/programs/Xserver/Xext/sleepuntil.c
index 368dc6b48..93d75a862 100644
--- a/nx-X11/programs/Xserver/Xext/sleepuntil.c
+++ b/nx-X11/programs/Xserver/Xext/sleepuntil.c
@@ -98,7 +98,7 @@ ClientSleepUntil (client, revive, notifyFunc, closure)
 	SertafiedGeneration = serverGeneration;
 	BlockHandlerRegistered = FALSE;
     }
-    pRequest = (SertafiedPtr) xalloc (sizeof (SertafiedRec));
+    pRequest = (SertafiedPtr) malloc (sizeof (SertafiedRec));
     if (!pRequest)
 	return FALSE;
     pRequest->pClient = client;
diff --git a/nx-X11/programs/Xserver/Xext/sync.c b/nx-X11/programs/Xserver/Xext/sync.c
index 8fe510497..88170169e 100644
--- a/nx-X11/programs/Xserver/Xext/sync.c
+++ b/nx-X11/programs/Xserver/Xext/sync.c
@@ -345,7 +345,7 @@ SyncAddTriggerToCounter(pTrigger)
 	    return Success;
     }
 
-    if (!(pCur = (SyncTriggerList *)xalloc(sizeof(SyncTriggerList))))
+    if (!(pCur = (SyncTriggerList *)malloc(sizeof(SyncTriggerList))))
 	return BadAlloc;
 
     pCur->pTrigger = pTrigger;
@@ -879,7 +879,7 @@ SyncEventSelectForAlarm(pAlarm, client, wantevents)
 
     /* add new client to pAlarm->pEventClients */
 
-    pClients = (SyncAlarmClientList *) xalloc(sizeof(SyncAlarmClientList));
+    pClients = (SyncAlarmClientList *) malloc(sizeof(SyncAlarmClientList));
     if (!pClients)
 	return BadAlloc;
 
@@ -1014,7 +1014,7 @@ SyncCreateCounter(client, id, initialvalue)
 {
     SyncCounter *pCounter;
 
-    if (!(pCounter = (SyncCounter *) xalloc(sizeof(SyncCounter))))
+    if (!(pCounter = (SyncCounter *) malloc(sizeof(SyncCounter))))
 	return (SyncCounter *)NULL;
 
     if (!AddResource(id, RTCounter, (void *) pCounter))
@@ -1081,7 +1081,7 @@ SyncCreateSystemCounter(name, initial, resolution, counterType,
     {
 	SysCounterInfo *psci;
 
-	psci = (SysCounterInfo *)xalloc(sizeof(SysCounterInfo));
+	psci = (SysCounterInfo *)malloc(sizeof(SysCounterInfo));
 	if (!psci)
 	{
 	    FreeResource(pCounter->id, RT_NONE);
@@ -1670,7 +1670,7 @@ ProcSyncAwait(client)
     /*  all the memory for the entire await list is allocated 
      *  here in one chunk
      */
-    pAwaitUnion = (SyncAwaitUnion *)xalloc((items+1) * sizeof(SyncAwaitUnion));
+    pAwaitUnion = (SyncAwaitUnion *)malloc((items+1) * sizeof(SyncAwaitUnion));
     if (!pAwaitUnion)
 	return BadAlloc;
 
@@ -1821,7 +1821,7 @@ ProcSyncCreateAlarm(client)
     if (len != (Ones(vmask) + Ones(vmask & (XSyncCAValue|XSyncCADelta))))
 	return BadLength;
 
-    if (!(pAlarm = (SyncAlarm *) xalloc(sizeof(SyncAlarm))))
+    if (!(pAlarm = (SyncAlarm *) malloc(sizeof(SyncAlarm))))
     {
 	return BadAlloc;
     }
diff --git a/nx-X11/programs/Xserver/Xext/xcmisc.c b/nx-X11/programs/Xserver/Xext/xcmisc.c
index 8f381cee5..7021ed47e 100644
--- a/nx-X11/programs/Xserver/Xext/xcmisc.c
+++ b/nx-X11/programs/Xserver/Xext/xcmisc.c
@@ -154,7 +154,7 @@ ProcXCMiscGetXIDList(client)
     if (stuff->count > UINT32_MAX / sizeof(XID))
 	    return BadAlloc;
 
-    pids = (XID *)Xalloc(stuff->count * sizeof(XID));
+    pids = (XID *)malloc(stuff->count * sizeof(XID));
     if (!pids)
     {
 	return BadAlloc;
diff --git a/nx-X11/programs/Xserver/Xext/xf86bigfont.c b/nx-X11/programs/Xserver/Xext/xf86bigfont.c
index 7bdda72b4..a89005cde 100644
--- a/nx-X11/programs/Xserver/Xext/xf86bigfont.c
+++ b/nx-X11/programs/Xserver/Xext/xf86bigfont.c
@@ -248,7 +248,7 @@ shmalloc(
     if (size < 3500)
 	return (ShmDescPtr) NULL;
 
-    pDesc = (ShmDescRec *) xalloc(sizeof(ShmDescRec));
+    pDesc = (ShmDescRec *) malloc(sizeof(ShmDescRec));
     if (!pDesc)
 	return (ShmDescPtr) NULL;
 
diff --git a/nx-X11/programs/Xserver/Xext/xvdisp.c b/nx-X11/programs/Xserver/Xext/xvdisp.c
index b300a32d5..e9250427d 100644
--- a/nx-X11/programs/Xserver/Xext/xvdisp.c
+++ b/nx-X11/programs/Xserver/Xext/xvdisp.c
@@ -1258,7 +1258,7 @@ ProcXvQueryImageAttributes(ClientPtr client)
 
   num_planes = pImage->num_planes;
 
-  if(!(offsets = xalloc(num_planes << 3)))
+  if(!(offsets = malloc(num_planes << 3)))
 	return BadAlloc;
   pitches = offsets + num_planes;
 
@@ -2223,7 +2223,7 @@ void XineramifyXv(void)
 
       /* now create a resource for each port */
       for(j = 0; j < refAdapt->nPorts; j++) {
-         if(!(port = xalloc(sizeof(PanoramiXRes))))
+         if(!(port = malloc(sizeof(PanoramiXRes))))
 	    break;
 	 port->info[0].id = MatchingAdaptors[0]->base_id + j;
 	 AddResource(port->info[0].id, XvXRTPort, port);
diff --git a/nx-X11/programs/Xserver/Xext/xvmain.c b/nx-X11/programs/Xserver/Xext/xvmain.c
index d2c21b13f..8a279ac1e 100644
--- a/nx-X11/programs/Xserver/Xext/xvmain.c
+++ b/nx-X11/programs/Xserver/Xext/xvmain.c
@@ -288,7 +288,7 @@ XvScreenInit(ScreenPtr pScreen)
 
   /* ALLOCATE SCREEN PRIVATE RECORD */
   
-  pxvs = (XvScreenPtr) xalloc (sizeof (XvScreenRec));
+  pxvs = (XvScreenPtr) malloc (sizeof (XvScreenRec));
   if (!pxvs)
     {
       ErrorF("XvScreenInit: Unable to allocate screen private structure\n");
@@ -941,7 +941,7 @@ XvdiSelectVideoNotify(
 
   if (!pn) 
     {
-      if (!(tpn = (XvVideoNotifyPtr)xalloc(sizeof(XvVideoNotifyRec))))
+      if (!(tpn = (XvVideoNotifyPtr)malloc(sizeof(XvVideoNotifyRec))))
 	return BadAlloc;
       tpn->next = (XvVideoNotifyPtr)NULL;
       if (!AddResource(pDraw->id, XvRTVideoNotifyList, tpn))
@@ -979,7 +979,7 @@ XvdiSelectVideoNotify(
 	}
       else
 	{
-	  if (!(tpn = (XvVideoNotifyPtr)xalloc(sizeof(XvVideoNotifyRec))))
+	  if (!(tpn = (XvVideoNotifyPtr)malloc(sizeof(XvVideoNotifyRec))))
 	    return BadAlloc;
 	  tpn->next = pn->next;
 	  pn->next = tpn;
@@ -1037,7 +1037,7 @@ XvdiSelectPortNotify(
 
   if (!tpn)
     {
-      if (!(tpn = (XvPortNotifyPtr)xalloc(sizeof(XvPortNotifyRec))))
+      if (!(tpn = (XvPortNotifyPtr)malloc(sizeof(XvPortNotifyRec))))
 	return BadAlloc;
       tpn->next = pPort->pNotify;
       pPort->pNotify = tpn;
diff --git a/nx-X11/programs/Xserver/Xext/xvmc.c b/nx-X11/programs/Xserver/Xext/xvmc.c
index 0ec04f3e3..bce7fbf7a 100644
--- a/nx-X11/programs/Xserver/Xext/xvmc.c
+++ b/nx-X11/programs/Xserver/Xext/xvmc.c
@@ -242,7 +242,7 @@ ProcXvMCCreateContext(ClientPtr client)
        (stuff->height > surface->max_height))
         return BadValue;
 
-    if(!(pContext = xalloc(sizeof(XvMCContextRec)))) {
+    if(!(pContext = malloc(sizeof(XvMCContextRec)))) {
 	return BadAlloc;
     }
 
@@ -313,7 +313,7 @@ ProcXvMCCreateSurface(ClientPtr client)
 
     pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen);
 
-    if(!(pSurface = xalloc(sizeof(XvMCSurfaceRec)))) 
+    if(!(pSurface = malloc(sizeof(XvMCSurfaceRec)))) 
         return BadAlloc;
 
     pSurface->surface_id = stuff->surface_id;
@@ -408,7 +408,7 @@ ProcXvMCCreateSubpicture(ClientPtr client)
        (stuff->height > surface->subpicture_max_height))
 	return BadValue;
 
-    if(!(pSubpicture = xalloc(sizeof(XvMCSubpictureRec))))
+    if(!(pSubpicture = malloc(sizeof(XvMCSubpictureRec))))
         return BadAlloc;
 
     pSubpicture->subpicture_id = stuff->subpicture_id;
@@ -726,7 +726,7 @@ XvMCScreenInit(ScreenPtr pScreen, int num, XvMCAdaptorPtr pAdapt)
 	XvMCGeneration = serverGeneration;
    }
 
-   if(!(pScreenPriv = (XvMCScreenPtr)xalloc(sizeof(XvMCScreenRec))))
+   if(!(pScreenPriv = (XvMCScreenPtr)malloc(sizeof(XvMCScreenRec))))
 	return BadAlloc;
 
    pScreen->devPrivates[XvMCScreenIndex].ptr = (void *)pScreenPriv;
diff --git a/nx-X11/programs/Xserver/Xi/exevents.c b/nx-X11/programs/Xserver/Xi/exevents.c
index 1612047bb..85abd4fee 100644
--- a/nx-X11/programs/Xserver/Xi/exevents.c
+++ b/nx-X11/programs/Xserver/Xi/exevents.c
@@ -302,7 +302,7 @@ InitProximityClassDeviceStruct( DeviceIntPtr dev)
 {
     register ProximityClassPtr proxc;
 
-    proxc = (ProximityClassPtr)xalloc(sizeof(ProximityClassRec));
+    proxc = (ProximityClassPtr)malloc(sizeof(ProximityClassRec));
     if (!proxc)
 	return FALSE;
     dev->proximity = proxc;
@@ -460,7 +460,7 @@ DeviceFocusEvent(dev, type, mode, detail, pWin)
 	    }
 	}
 
-	sev = ev = (deviceStateNotify *) xalloc(evcount * sizeof(xEvent));
+	sev = ev = (deviceStateNotify *) malloc(evcount * sizeof(xEvent));
 	FixDeviceStateNotify (dev, ev, NULL, NULL, NULL, first);
 
 	if (b != NULL) {
@@ -741,7 +741,7 @@ AddExtensionClient (pWin, client, mask, mskidx)
 
     if (!pWin->optional && !MakeWindowOptional (pWin))
 	return BadAlloc;
-    others = (InputClients *) xalloc(sizeof(InputClients));
+    others = (InputClients *) malloc(sizeof(InputClients));
     if (!others)
 	return BadAlloc;
     if (!pWin->optional->inputMasks && !MakeInputMasks (pWin))
@@ -763,7 +763,7 @@ MakeInputMasks (pWin)
     struct _OtherInputMasks *imasks;
 
     imasks = (struct _OtherInputMasks *) 
-	xalloc (sizeof (struct _OtherInputMasks));
+	malloc (sizeof (struct _OtherInputMasks));
     if (!imasks)
 	return FALSE;
     bzero((char *) imasks, sizeof (struct _OtherInputMasks));
@@ -1027,7 +1027,7 @@ SetModifierMapping(client, dev, len, rlen, numKeyPerModifier, inputMap, k)
      *	list of keycodes.
      */
     if (inputMapLen) {
-	map = (KeyCode *)xalloc(inputMapLen);
+	map = (KeyCode *)malloc(inputMapLen);
         if (!map)
             return BadAlloc;
     }
diff --git a/nx-X11/programs/Xserver/Xi/extinit.c b/nx-X11/programs/Xserver/Xi/extinit.c
index 81f5ca551..d74ac5dc7 100644
--- a/nx-X11/programs/Xserver/Xi/extinit.c
+++ b/nx-X11/programs/Xserver/Xi/extinit.c
@@ -872,7 +872,7 @@ AssignTypeAndName (dev, type, name)
     char *name;
 {
     dev->type = type;
-    dev->name = (char *) xalloc(strlen(name)+1);
+    dev->name = (char *) malloc(strlen(name)+1);
     strcpy (dev->name, name);
     }
 
diff --git a/nx-X11/programs/Xserver/Xi/getdctl.c b/nx-X11/programs/Xserver/Xi/getdctl.c
index 440c1eeb4..1161e5aef 100644
--- a/nx-X11/programs/Xserver/Xi/getdctl.c
+++ b/nx-X11/programs/Xserver/Xi/getdctl.c
@@ -139,7 +139,7 @@ ProcXGetDeviceControl(client)
 	    return Success;
 	}
 
-    buf = (char *) xalloc (total_length);
+    buf = (char *) malloc (total_length);
     if (!buf)
 	{
 	SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0, 
diff --git a/nx-X11/programs/Xserver/Xi/getfctl.c b/nx-X11/programs/Xserver/Xi/getfctl.c
index e2f243430..bc92784d3 100644
--- a/nx-X11/programs/Xserver/Xi/getfctl.c
+++ b/nx-X11/programs/Xserver/Xi/getfctl.c
@@ -165,7 +165,7 @@ ProcXGetFeedbackControl(client)
 	return Success;
 	}
 
-    buf = (char *) xalloc (total_length);
+    buf = (char *) malloc (total_length);
     if (!buf)
 	{
 	SendErrorToClient(client, IReqCode, X_GetFeedbackControl, 0, 
diff --git a/nx-X11/programs/Xserver/Xi/getprop.c b/nx-X11/programs/Xserver/Xi/getprop.c
index 33d49fb95..42403b0e5 100644
--- a/nx-X11/programs/Xserver/Xi/getprop.c
+++ b/nx-X11/programs/Xserver/Xi/getprop.c
@@ -137,7 +137,7 @@ ProcXGetDeviceDontPropagateList (client)
 	if (count)
 	    {
 	    rep.count = count;
-	    buf = (XEventClass *) xalloc (rep.count * sizeof(XEventClass));
+	    buf = (XEventClass *) malloc (rep.count * sizeof(XEventClass));
 	    rep.length = (rep.count * sizeof (XEventClass) + 3) >> 2;
 
 	    tbuf = buf;
diff --git a/nx-X11/programs/Xserver/Xi/getselev.c b/nx-X11/programs/Xserver/Xi/getselev.c
index 05d9d987c..8abea78d4 100644
--- a/nx-X11/programs/Xserver/Xi/getselev.c
+++ b/nx-X11/programs/Xserver/Xi/getselev.c
@@ -149,7 +149,7 @@ ProcXGetSelectedExtensionEvents(client)
 	total_length = (rep.all_clients_count + rep.this_client_count) * 
 	    sizeof (XEventClass);
 	rep.length = (total_length + 3) >> 2;
-	buf = (XEventClass *) xalloc (total_length);
+	buf = (XEventClass *) malloc (total_length);
 
 	tclient = buf;
 	aclient = buf + rep.this_client_count;
diff --git a/nx-X11/programs/Xserver/Xi/queryst.c b/nx-X11/programs/Xserver/Xi/queryst.c
index 975643e0e..a590aa0e1 100644
--- a/nx-X11/programs/Xserver/Xi/queryst.c
+++ b/nx-X11/programs/Xserver/Xi/queryst.c
@@ -135,7 +135,7 @@ ProcXQueryDeviceState(client)
 			(v->numAxes * sizeof(int)));
 	num_classes++;
 	}
-    buf = (char *) xalloc (total_length);
+    buf = (char *) malloc (total_length);
     if (!buf)
 	{
 	SendErrorToClient(client, IReqCode, X_QueryDeviceState, 0, 
diff --git a/nx-X11/programs/Xserver/composite/compalloc.c b/nx-X11/programs/Xserver/composite/compalloc.c
index a5d0998eb..e24c490d2 100644
--- a/nx-X11/programs/Xserver/composite/compalloc.c
+++ b/nx-X11/programs/Xserver/composite/compalloc.c
@@ -146,7 +146,7 @@ compRedirectWindow(ClientPtr pClient, WindowPtr pWin, int update)
      * The client *could* allocate multiple, but while supported,
      * it is not expected to be common
      */
-    ccw = xalloc (sizeof (CompClientWindowRec));
+    ccw = malloc (sizeof (CompClientWindowRec));
     if (!ccw)
 	return BadAlloc;
     ccw->id = FakeClientID (pClient->index);
@@ -156,7 +156,7 @@ compRedirectWindow(ClientPtr pClient, WindowPtr pWin, int update)
      */
     if (!cw)
     {
-	cw = xalloc (sizeof (CompWindowRec));
+	cw = malloc (sizeof (CompWindowRec));
 	if (!cw)
 	{
 	    free (ccw);
@@ -355,7 +355,7 @@ compRedirectSubwindows (ClientPtr pClient, WindowPtr pWin, int update)
      * The client *could* allocate multiple, but while supported,
      * it is not expected to be common
      */
-    ccw = xalloc (sizeof (CompClientWindowRec));
+    ccw = malloc (sizeof (CompClientWindowRec));
     if (!ccw)
 	return BadAlloc;
     ccw->id = FakeClientID (pClient->index);
@@ -365,7 +365,7 @@ compRedirectSubwindows (ClientPtr pClient, WindowPtr pWin, int update)
      */
     if (!csw)
     {
-	csw = xalloc (sizeof (CompSubwindowsRec));
+	csw = malloc (sizeof (CompSubwindowsRec));
 	if (!csw)
 	{
 	    free (ccw);
diff --git a/nx-X11/programs/Xserver/composite/compinit.c b/nx-X11/programs/Xserver/composite/compinit.c
index 930787195..e33bd3a3f 100644
--- a/nx-X11/programs/Xserver/composite/compinit.c
+++ b/nx-X11/programs/Xserver/composite/compinit.c
@@ -405,7 +405,7 @@ compScreenInit (ScreenPtr pScreen)
 
     if (GetCompScreen (pScreen))
 	return TRUE;
-    cs = (CompScreenPtr) xalloc (sizeof (CompScreenRec));
+    cs = (CompScreenPtr) malloc (sizeof (CompScreenRec));
     if (!cs)
 	return FALSE;
 
diff --git a/nx-X11/programs/Xserver/damageext/damageext.c b/nx-X11/programs/Xserver/damageext/damageext.c
index aedbecb7b..88858f621 100755
--- a/nx-X11/programs/Xserver/damageext/damageext.c
+++ b/nx-X11/programs/Xserver/damageext/damageext.c
@@ -199,7 +199,7 @@ ProcDamageCreate (ClientPtr client)
 	return BadValue;
     }
     
-    pDamageExt = xalloc (sizeof (DamageExtRec));
+    pDamageExt = malloc (sizeof (DamageExtRec));
     if (!pDamageExt)
 	return BadAlloc;
     pDamageExt->id = stuff->damage;
diff --git a/nx-X11/programs/Xserver/dbe/dbe.c b/nx-X11/programs/Xserver/dbe/dbe.c
index e64b6bd22..658e61abe 100644
--- a/nx-X11/programs/Xserver/dbe/dbe.c
+++ b/nx-X11/programs/Xserver/dbe/dbe.c
@@ -176,7 +176,7 @@ DbeAllocWinPriv(pScreen)
     register int		i;
 
     pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
-    pDbeWindowPriv = (DbeWindowPrivPtr)xalloc(pDbeScreenPriv->totalWinPrivSize);
+    pDbeWindowPriv = (DbeWindowPrivPtr)malloc(pDbeScreenPriv->totalWinPrivSize);
 
     if (pDbeWindowPriv)
     {
@@ -746,7 +746,7 @@ ProcDbeSwapBuffers(client)
     dbeSwapInfo = (xDbeSwapInfo *)&stuff[1];
 
     /* Allocate array to record swap information. */ 
-    swapInfo = (DbeSwapInfoPtr)Xalloc(nStuff * sizeof(DbeSwapInfoRec));
+    swapInfo = (DbeSwapInfoPtr)malloc(nStuff * sizeof(DbeSwapInfoRec));
     if (swapInfo == NULL)
     {
         return(BadAlloc);
@@ -912,7 +912,7 @@ ProcDbeGetVisualInfo(client)
     /* Make sure any specified drawables are valid. */
     if (stuff->n != 0)
     {
-        if (!(pDrawables = (DrawablePtr *)Xalloc(stuff->n *
+        if (!(pDrawables = (DrawablePtr *)malloc(stuff->n *
                                                  sizeof(DrawablePtr))))
         {
             return(BadAlloc);
@@ -932,7 +932,7 @@ ProcDbeGetVisualInfo(client)
     }
 
     count = (stuff->n == 0) ? screenInfo.numScreens : stuff->n;
-    if (!(pScrVisInfo = (XdbeScreenVisualInfo *)xalloc(count *
+    if (!(pScrVisInfo = (XdbeScreenVisualInfo *)malloc(count *
                         sizeof(XdbeScreenVisualInfo))))
     {
         if (pDrawables)
diff --git a/nx-X11/programs/Xserver/dbe/midbe.c b/nx-X11/programs/Xserver/dbe/midbe.c
index b8383e11a..c83b42771 100644
--- a/nx-X11/programs/Xserver/dbe/midbe.c
+++ b/nx-X11/programs/Xserver/dbe/midbe.c
@@ -115,7 +115,7 @@ miDbeGetVisualInfo(pScreen, pScrVisInfo)
     }
 
     /* Allocate an array of XdbeVisualInfo items. */
-    if (!(visInfo = (XdbeVisualInfo *)xalloc(count * sizeof(XdbeVisualInfo))))
+    if (!(visInfo = (XdbeVisualInfo *)malloc(count * sizeof(XdbeVisualInfo))))
     {
         return(FALSE); /* memory alloc failure */
     }
diff --git a/nx-X11/programs/Xserver/dix/atom.c b/nx-X11/programs/Xserver/dix/atom.c
index fdb1c18a2..227069bab 100644
--- a/nx-X11/programs/Xserver/dix/atom.c
+++ b/nx-X11/programs/Xserver/dix/atom.c
@@ -109,7 +109,7 @@ MakeAtom(const char *string, unsigned len, Bool makeit)
     {
 	register NodePtr nd;
 
-	nd = (NodePtr) xalloc(sizeof(NodeRec));
+	nd = (NodePtr) malloc(sizeof(NodeRec));
 	if (!nd)
 	    return BAD_RESOURCE;
 	if (lastAtom < XA_LAST_PREDEFINED)
@@ -118,7 +118,7 @@ MakeAtom(const char *string, unsigned len, Bool makeit)
 	}
 	else
 	{
-	    nd->string = (char *) xalloc(len + 1);
+	    nd->string = (char *) malloc(len + 1);
 	    if (!nd->string) {
 		free(nd);
 		return BAD_RESOURCE;
@@ -201,7 +201,7 @@ InitAtoms()
 {
     FreeAllAtoms();
     tableLength = InitialTableSize;
-    nodeTable = (NodePtr *)xalloc(InitialTableSize*sizeof(NodePtr));
+    nodeTable = (NodePtr *)malloc(InitialTableSize*sizeof(NodePtr));
     if (!nodeTable)
 	AtomError();
     nodeTable[None] = (NodePtr)NULL;
diff --git a/nx-X11/programs/Xserver/dix/colormap.c b/nx-X11/programs/Xserver/dix/colormap.c
index 39da0abd4..121877461 100644
--- a/nx-X11/programs/Xserver/dix/colormap.c
+++ b/nx-X11/programs/Xserver/dix/colormap.c
@@ -274,7 +274,7 @@ CreateColormap (Colormap mid, ScreenPtr pScreen, VisualPtr pVisual,
     if ((class | DynamicClass) == DirectColor)
 	sizebytes *= 3;
     sizebytes += sizeof(ColormapRec);
-    pmap = (ColormapPtr) xalloc(sizebytes);
+    pmap = (ColormapPtr) malloc(sizebytes);
     if (!pmap)
 	return (BadAlloc);
     pmap->red = (EntryPtr)((char *)pmap + sizeof(ColormapRec));    
@@ -303,7 +303,7 @@ CreateColormap (Colormap mid, ScreenPtr pScreen, VisualPtr pVisual,
 	for (pent = &pmap->red[size - 1]; pent >= pmap->red; pent--)
 	    pent->refcnt = AllocPrivate;
 	pmap->freeRed = 0;
-	ppix = (Pixel *)xalloc(size * sizeof(Pixel));
+	ppix = (Pixel *)malloc(size * sizeof(Pixel));
 	if (!ppix)
 	{
 	    free(pmap);
@@ -349,7 +349,7 @@ CreateColormap (Colormap mid, ScreenPtr pScreen, VisualPtr pVisual,
 	    for(pent = &pmap->green[size-1]; pent >= pmap->green; pent--)
 		pent->refcnt = AllocPrivate;
 	    pmap->freeGreen = 0;
-	    ppix = (Pixel *) xalloc(size * sizeof(Pixel));
+	    ppix = (Pixel *) malloc(size * sizeof(Pixel));
 	    if (!ppix)
 	    {
 		free(pmap->clientPixelsRed[client]);
@@ -365,7 +365,7 @@ CreateColormap (Colormap mid, ScreenPtr pScreen, VisualPtr pVisual,
 	    for(pent = &pmap->blue[size-1]; pent >= pmap->blue; pent--)
 		pent->refcnt = AllocPrivate;
 	    pmap->freeBlue = 0;
-	    ppix = (Pixel *) xalloc(size * sizeof(Pixel));
+	    ppix = (Pixel *) malloc(size * sizeof(Pixel));
 	    if (!ppix)
 	    {
 		free(pmap->clientPixelsGreen[client]);
@@ -963,7 +963,7 @@ AllocColor (ColormapPtr pmap,
     {
 	colorResource	*pcr;
 
-	pcr = (colorResource *) xalloc(sizeof(colorResource));
+	pcr = (colorResource *) malloc(sizeof(colorResource));
 	if (!pcr)
 	{
 	    (void)FreeColors(pmap, client, 1, pPix, (Pixel)0);
@@ -1578,7 +1578,7 @@ AllocColorCells (int client, ColormapPtr pmap, int colors, int planes,
 	oldcount += pmap->numPixelsGreen[client] + pmap->numPixelsBlue[client];
     if (!oldcount && (CLIENT_ID(pmap->mid) != client))
     {
-	pcr = (colorResource *) xalloc(sizeof(colorResource));
+	pcr = (colorResource *) malloc(sizeof(colorResource));
 	if (!pcr)
 	    return (BadAlloc);
     }
@@ -1653,7 +1653,7 @@ AllocColorPlanes (int client, ColormapPtr pmap, int colors,
 	oldcount += pmap->numPixelsGreen[client] + pmap->numPixelsBlue[client];
     if (!oldcount && (CLIENT_ID(pmap->mid) != client))
     {
-	pcr = (colorResource *) xalloc(sizeof(colorResource));
+	pcr = (colorResource *) malloc(sizeof(colorResource));
 	if (!pcr)
 	    return (BadAlloc);
     }
@@ -2089,7 +2089,7 @@ AllocShared (ColormapPtr pmap, Pixel *ppix, int c, int r, int g, int b,
     ppshared = psharedList;
     for (z = npixShared; --z >= 0; )
     {
-	if (!(ppshared[z] = (SHAREDCOLOR *)xalloc(sizeof(SHAREDCOLOR))))
+	if (!(ppshared[z] = (SHAREDCOLOR *)malloc(sizeof(SHAREDCOLOR))))
 	{
 	    for (z++ ; z < npixShared; z++)
 		free(ppshared[z]);
diff --git a/nx-X11/programs/Xserver/dix/cursor.c b/nx-X11/programs/Xserver/dix/cursor.c
index 575ff1eb4..875e19480 100644
--- a/nx-X11/programs/Xserver/dix/cursor.c
+++ b/nx-X11/programs/Xserver/dix/cursor.c
@@ -174,7 +174,7 @@ AllocCursorARGB(unsigned char *psrcbits, unsigned char *pmaskbits, CARD32 *argb,
     int		nscr;
     ScreenPtr 	pscr;
 
-    pCurs = (CursorPtr)xalloc(sizeof(CursorRec) + sizeof(CursorBits));
+    pCurs = (CursorPtr)malloc(sizeof(CursorRec) + sizeof(CursorBits));
     if (!pCurs)
     {
 	free(psrcbits);
@@ -292,7 +292,7 @@ AllocGlyphCursor(Font source, unsigned sourceChar, Font mask, unsigned maskChar,
     }
     if (pShare)
     {
-	pCurs = (CursorPtr)xalloc(sizeof(CursorRec));
+	pCurs = (CursorPtr)malloc(sizeof(CursorRec));
 	if (!pCurs)
 	    return BadAlloc;
 	bits = pShare->bits;
@@ -311,7 +311,7 @@ AllocGlyphCursor(Font source, unsigned sourceChar, Font mask, unsigned maskChar,
 	    register unsigned char *mskptr;
 
 	    n = BitmapBytePad(cm.width)*(long)cm.height;
-	    mskptr = mskbits = (unsigned char *)xalloc(n);
+	    mskptr = mskbits = (unsigned char *)malloc(n);
 	    if (!mskptr)
 		return BadAlloc;
 	    while (--n >= 0)
@@ -334,7 +334,7 @@ AllocGlyphCursor(Font source, unsigned sourceChar, Font mask, unsigned maskChar,
 	}
 	if (sourcefont != maskfont)
 	{
-	    pCurs = (CursorPtr)xalloc(sizeof(CursorRec) + sizeof(CursorBits));
+	    pCurs = (CursorPtr)malloc(sizeof(CursorRec) + sizeof(CursorBits));
 	    if (pCurs)
 		bits = (CursorBitsPtr)((char *)pCurs + sizeof(CursorRec));
 	    else
@@ -342,9 +342,9 @@ AllocGlyphCursor(Font source, unsigned sourceChar, Font mask, unsigned maskChar,
 	}
 	else
 	{
-	    pCurs = (CursorPtr)xalloc(sizeof(CursorRec));
+	    pCurs = (CursorPtr)malloc(sizeof(CursorRec));
 	    if (pCurs)
-		bits = (CursorBitsPtr)xalloc(sizeof(CursorBits));
+		bits = (CursorBitsPtr)malloc(sizeof(CursorBits));
 	    else
 		bits = (CursorBitsPtr)NULL;
 	}
@@ -369,7 +369,7 @@ AllocGlyphCursor(Font source, unsigned sourceChar, Font mask, unsigned maskChar,
 	else
 	{
 	    bits->refcnt = 1;
-	    pShare = (GlyphSharePtr)xalloc(sizeof(GlyphShare));
+	    pShare = (GlyphSharePtr)malloc(sizeof(GlyphShare));
 	    if (!pShare)
 	    {
 		FreeCursorBits(bits);
diff --git a/nx-X11/programs/Xserver/dix/devices.c b/nx-X11/programs/Xserver/dix/devices.c
index 314714152..69a72fbad 100644
--- a/nx-X11/programs/Xserver/dix/devices.c
+++ b/nx-X11/programs/Xserver/dix/devices.c
@@ -86,7 +86,7 @@ _AddInputDevice(DeviceProc deviceProc, Bool autoStart)
 
     if (inputInfo.numDevices >= MAX_DEVICES)
 	return (DeviceIntPtr)NULL;
-    dev = (DeviceIntPtr) xalloc(sizeof(DeviceIntRec));
+    dev = (DeviceIntPtr) malloc(sizeof(DeviceIntRec));
     if (!dev)
 	return (DeviceIntPtr)NULL;
     dev->name = (char *)NULL;
@@ -369,7 +369,7 @@ _RegisterPointerDevice(DeviceIntPtr device)
     if (!device->name)
     {
 	char *p = "pointer";
-	device->name = (char *)xalloc(strlen(p) + 1);
+	device->name = (char *)malloc(strlen(p) + 1);
 	strcpy(device->name, p);
     }
 }
@@ -392,7 +392,7 @@ _RegisterKeyboardDevice(DeviceIntPtr device)
     if (!device->name)
     {
 	char *k = "keyboard";
-	device->name = (char *)xalloc(strlen(k) + 1);
+	device->name = (char *)malloc(strlen(k) + 1);
 	strcpy(device->name, k);
     }
 }
@@ -461,7 +461,7 @@ SetKeySymsMap(register KeySymsPtr dst, register KeySymsPtr src)
         KeySym *map;
 	int bytes = sizeof(KeySym) * src->mapWidth *
 		    (dst->maxKeyCode - dst->minKeyCode + 1);
-        map = (KeySym *)xalloc(bytes);
+        map = (KeySym *)malloc(bytes);
 	if (!map)
 	    return FALSE;
 	bzero((char *)map, bytes);
@@ -504,7 +504,7 @@ InitModMap(register KeyClassPtr keyc)
 	    }
 	}
     }
-    keyc->modifierKeyMap = (KeyCode *)xalloc(8*keyc->maxKeysPerModifier);
+    keyc->modifierKeyMap = (KeyCode *)malloc(8*keyc->maxKeysPerModifier);
     if (!keyc->modifierKeyMap && keyc->maxKeysPerModifier)
 	return (FALSE);
     bzero((char *)keyc->modifierKeyMap, 8*(int)keyc->maxKeysPerModifier);
@@ -531,7 +531,7 @@ InitKeyClassDeviceStruct(DeviceIntPtr dev, KeySymsPtr pKeySyms, CARD8 pModifiers
     int i;
     register KeyClassPtr keyc;
 
-    keyc = (KeyClassPtr)xalloc(sizeof(KeyClassRec));
+    keyc = (KeyClassPtr)malloc(sizeof(KeyClassRec));
     if (!keyc)
 	return FALSE;
     keyc->curKeySyms.map = (KeySym *)NULL;
@@ -570,7 +570,7 @@ InitButtonClassDeviceStruct(register DeviceIntPtr dev, int numButtons,
     register ButtonClassPtr butc;
     int i;
 
-    butc = (ButtonClassPtr)xalloc(sizeof(ButtonClassRec));
+    butc = (ButtonClassPtr)malloc(sizeof(ButtonClassRec));
     if (!butc)
 	return FALSE;
     butc->numButtons = numButtons;
@@ -595,7 +595,7 @@ InitValuatorClassDeviceStruct(DeviceIntPtr dev, int numAxes,
     int i;
     register ValuatorClassPtr valc;
 
-    valc = (ValuatorClassPtr)xalloc(sizeof(ValuatorClassRec) +
+    valc = (ValuatorClassPtr)malloc(sizeof(ValuatorClassRec) +
 				    numAxes * sizeof(AxisInfo) +
 				    numAxes * sizeof(unsigned int));
     if (!valc)
@@ -618,7 +618,7 @@ InitFocusClassDeviceStruct(DeviceIntPtr dev)
 {
     register FocusClassPtr focc;
 
-    focc = (FocusClassPtr)xalloc(sizeof(FocusClassRec));
+    focc = (FocusClassPtr)malloc(sizeof(FocusClassRec));
     if (!focc)
 	return FALSE;
     focc->win = PointerRootWin;
@@ -637,7 +637,7 @@ InitKbdFeedbackClassDeviceStruct(DeviceIntPtr dev, BellProcPtr bellProc,
 {
     register KbdFeedbackPtr feedc;
 
-    feedc = (KbdFeedbackPtr)xalloc(sizeof(KbdFeedbackClassRec));
+    feedc = (KbdFeedbackPtr)malloc(sizeof(KbdFeedbackClassRec));
     if (!feedc)
 	return FALSE;
     feedc->BellProc = bellProc;
@@ -664,7 +664,7 @@ InitPtrFeedbackClassDeviceStruct(DeviceIntPtr dev, PtrCtrlProcPtr controlProc)
 {
     register PtrFeedbackPtr feedc;
 
-    feedc = (PtrFeedbackPtr)xalloc(sizeof(PtrFeedbackClassRec));
+    feedc = (PtrFeedbackPtr)malloc(sizeof(PtrFeedbackClassRec));
     if (!feedc)
 	return FALSE;
     feedc->CtrlProc = controlProc;
@@ -708,7 +708,7 @@ InitStringFeedbackClassDeviceStruct (
     int i;
     register StringFeedbackPtr feedc;
 
-    feedc = (StringFeedbackPtr)xalloc(sizeof(StringFeedbackClassRec));
+    feedc = (StringFeedbackPtr)malloc(sizeof(StringFeedbackClassRec));
     if (!feedc)
 	return FALSE;
     feedc->CtrlProc = controlProc;
@@ -716,9 +716,9 @@ InitStringFeedbackClassDeviceStruct (
     feedc->ctrl.num_symbols_displayed = 0;
     feedc->ctrl.max_symbols = max_symbols;
     feedc->ctrl.symbols_supported = (KeySym *) 
-	xalloc (sizeof (KeySym) * num_symbols_supported);
+	malloc (sizeof (KeySym) * num_symbols_supported);
     feedc->ctrl.symbols_displayed = (KeySym *) 
-	xalloc (sizeof (KeySym) * max_symbols);
+	malloc (sizeof (KeySym) * max_symbols);
     if (!feedc->ctrl.symbols_supported || !feedc->ctrl.symbols_displayed)
     {
 	if (feedc->ctrl.symbols_supported)
@@ -746,7 +746,7 @@ InitBellFeedbackClassDeviceStruct (DeviceIntPtr dev, BellProcPtr bellProc,
 {
     register BellFeedbackPtr feedc;
 
-    feedc = (BellFeedbackPtr)xalloc(sizeof(BellFeedbackClassRec));
+    feedc = (BellFeedbackPtr)malloc(sizeof(BellFeedbackClassRec));
     if (!feedc)
 	return FALSE;
     feedc->CtrlProc = controlProc;
@@ -765,7 +765,7 @@ InitLedFeedbackClassDeviceStruct (DeviceIntPtr dev, LedCtrlProcPtr controlProc)
 {
     register LedFeedbackPtr feedc;
 
-    feedc = (LedFeedbackPtr)xalloc(sizeof(LedFeedbackClassRec));
+    feedc = (LedFeedbackPtr)malloc(sizeof(LedFeedbackClassRec));
     if (!feedc)
 	return FALSE;
     feedc->CtrlProc = controlProc;
@@ -786,7 +786,7 @@ InitIntegerFeedbackClassDeviceStruct (DeviceIntPtr dev, IntegerCtrlProcPtr contr
 {
     register IntegerFeedbackPtr feedc;
 
-    feedc = (IntegerFeedbackPtr)xalloc(sizeof(IntegerFeedbackClassRec));
+    feedc = (IntegerFeedbackPtr)malloc(sizeof(IntegerFeedbackClassRec));
     if (!feedc)
 	return FALSE;
     feedc->CtrlProc = controlProc;
@@ -997,7 +997,7 @@ ProcSetModifierMapping(ClientPtr client)
 	 *	Now build the keyboard's modifier bitmap from the
 	 *	list of keycodes.
 	 */
-	map = (KeyCode *)xalloc(inputMapLen);
+	map = (KeyCode *)malloc(inputMapLen);
 	if (!map && inputMapLen)
 	    return BadAlloc;
 	if (keyc->modifierKeyMap)
diff --git a/nx-X11/programs/Xserver/dix/dispatch.c b/nx-X11/programs/Xserver/dix/dispatch.c
index 9b9021d62..807fecd90 100644
--- a/nx-X11/programs/Xserver/dix/dispatch.c
+++ b/nx-X11/programs/Xserver/dix/dispatch.c
@@ -1021,7 +1021,7 @@ ProcSetSelectionOwner(register ClientPtr client)
 	    Selection *newsels;
 
 	    if (i == 0)
-		newsels = (Selection *)xalloc(sizeof(Selection));
+		newsels = (Selection *)malloc(sizeof(Selection));
 	    else
 		newsels = (Selection *)xrealloc(CurrentSelections,
 			    (NumCurrentSelections + 1) * sizeof(Selection));
@@ -3084,10 +3084,10 @@ ProcCreateCursor (register ClientPtr client)
 	return (BadMatch);
 
     n = BitmapBytePad(width)*height;
-    srcbits = (unsigned char *)xalloc(n);
+    srcbits = (unsigned char *)malloc(n);
     if (!srcbits)
 	return (BadAlloc);
-    mskbits = (unsigned char *)xalloc(n);
+    mskbits = (unsigned char *)malloc(n);
     if (!mskbits)
     {
 	free(srcbits);
@@ -3716,7 +3716,7 @@ InitClientPrivates(ClientPtr client)
 	ppriv = (DevUnion *)(client + 1);
     else
     {
-	ppriv = (DevUnion *)xalloc(totalClientSize - sizeof(ClientRec));
+	ppriv = (DevUnion *)malloc(totalClientSize - sizeof(ClientRec));
 	if (!ppriv)
 	    return 0;
     }
@@ -3753,7 +3753,7 @@ ClientPtr NextAvailableClient(void * ospriv)
     i = nextFreeClientID;
     if (i == MAXCLIENTS)
 	return (ClientPtr)NULL;
-    clients[i] = client = (ClientPtr)xalloc(totalClientSize);
+    clients[i] = client = (ClientPtr)malloc(totalClientSize);
     if (!client)
 	return (ClientPtr)NULL;
     InitClient(client, i, ospriv);
diff --git a/nx-X11/programs/Xserver/dix/dixfonts.c b/nx-X11/programs/Xserver/dix/dixfonts.c
index 1a0352387..ef40c66f7 100644
--- a/nx-X11/programs/Xserver/dix/dixfonts.c
+++ b/nx-X11/programs/Xserver/dix/dixfonts.c
@@ -393,7 +393,7 @@ OpenFont(ClientPtr client, XID fid, Mask flags, unsigned lenfname, char *pfontna
 
 #ifdef FONTDEBUG
     char *f;
-    f = (char *)xalloc(lenfname + 1);
+    f = (char *)malloc(lenfname + 1);
     memmove(f, pfontname, lenfname);
     f[lenfname] = '\0';
     ErrorF("OpenFont: fontname is \"%s\"\n", f);
@@ -430,10 +430,10 @@ OpenFont(ClientPtr client, XID fid, Mask flags, unsigned lenfname, char *pfontna
 	    return Success;
 	}
     }
-    c = (OFclosurePtr) xalloc(sizeof(OFclosureRec));
+    c = (OFclosurePtr) malloc(sizeof(OFclosureRec));
     if (!c)
 	return BadAlloc;
-    c->fontname = (char *) xalloc(lenfname);
+    c->fontname = (char *) malloc(lenfname);
     c->origFontName = pfontname;
     c->origFontNameLen = lenfname;
     if (!c->fontname) {
@@ -445,7 +445,7 @@ OpenFont(ClientPtr client, XID fid, Mask flags, unsigned lenfname, char *pfontna
      * while we're blocking, the request still appears atomic
      */
     c->fpe_list = (FontPathElementPtr *)
-	xalloc(sizeof(FontPathElementPtr) * num_fpes);
+	malloc(sizeof(FontPathElementPtr) * num_fpes);
     if (!c->fpe_list) {
 	free(c->fontname);
 	free(c);
@@ -680,7 +680,7 @@ doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
 		}
 		if (err == FontNameAlias) {
 		    if (resolved) free(resolved);
-		    resolved = (char *) xalloc(resolvedlen + 1);
+		    resolved = (char *) malloc(resolvedlen + 1);
 		    if (resolved)
 			memmove(resolved, tmpname, resolvedlen + 1);
 		}
@@ -735,7 +735,7 @@ doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
 		    c->haveSaved = TRUE;
 		    if (c->savedName)
 			free(c->savedName);
-		    c->savedName = (char *)xalloc(namelen + 1);
+		    c->savedName = (char *)malloc(namelen + 1);
 		    if (c->savedName)
 			memmove(c->savedName, name, namelen + 1);
 		    c->savedNameLen = namelen;
@@ -853,10 +853,10 @@ ListFonts(ClientPtr client, unsigned char *pattern, unsigned length,
     if (length > XLFDMAXFONTNAMELEN)
 	return BadAlloc;
 
-    if (!(c = (LFclosurePtr) xalloc(sizeof *c)))
+    if (!(c = (LFclosurePtr) malloc(sizeof *c)))
 	return BadAlloc;
     c->fpe_list = (FontPathElementPtr *)
-	xalloc(sizeof(FontPathElementPtr) * num_fpes);
+	malloc(sizeof(FontPathElementPtr) * num_fpes);
     if (!c->fpe_list) {
 	free(c);
 	return BadAlloc;
@@ -995,7 +995,7 @@ doListFontsWithInfo(ClientPtr client, LFWIclosurePtr c)
 		c->savedNumFonts = numFonts;
 		if (c->savedName)
 		  free(c->savedName);
-		c->savedName = (char *)xalloc(namelen + 1);
+		c->savedName = (char *)malloc(namelen + 1);
 		if (c->savedName)
 		  memmove(c->savedName, name, namelen + 1);
 		aliascount = 20;
@@ -1127,10 +1127,10 @@ StartListFontsWithInfo(ClientPtr client, int length, unsigned char *pattern,
     if (length > XLFDMAXFONTNAMELEN)
 	return BadAlloc;
 
-    if (!(c = (LFWIclosurePtr) xalloc(sizeof *c)))
+    if (!(c = (LFWIclosurePtr) malloc(sizeof *c)))
 	goto badAlloc;
     c->fpe_list = (FontPathElementPtr *)
-	xalloc(sizeof(FontPathElementPtr) * num_fpes);
+	malloc(sizeof(FontPathElementPtr) * num_fpes);
     if (!c->fpe_list)
     {
 	free(c);
@@ -1317,7 +1317,7 @@ doPolyText(ClientPtr client, register PTclosurePtr c)
 		    /* Step 1 */
 		    /* Allocate a malloc'd closure structure to replace
 		       the local one we were passed */
-		    new_closure = (PTclosurePtr) xalloc(sizeof(PTclosureRec));
+		    new_closure = (PTclosurePtr) malloc(sizeof(PTclosureRec));
 		    if (!new_closure)
 		    {
 			err = BadAlloc;
@@ -1327,7 +1327,7 @@ doPolyText(ClientPtr client, register PTclosurePtr c)
 		    c = new_closure;
 
 		    len = c->endReq - c->pElt;
-		    c->data = (unsigned char *)xalloc(len);
+		    c->data = (unsigned char *)malloc(len);
 		    if (!c->data)
 		    {
 			free(c);
@@ -1517,7 +1517,7 @@ doImageText(ClientPtr client, register ITclosurePtr c)
 	       in doPolyText, but much simpler because the
 	       request structure is much simpler. */
 
-	    new_closure = (ITclosurePtr) xalloc(sizeof(ITclosureRec));
+	    new_closure = (ITclosurePtr) malloc(sizeof(ITclosureRec));
 	    if (!new_closure)
 	    {
 		err = BadAlloc;
@@ -1527,7 +1527,7 @@ doImageText(ClientPtr client, register ITclosurePtr c)
 	    *new_closure = *c;
 	    c = new_closure;
 
-	    data = (unsigned char *)xalloc(c->nChars * c->itemSize);
+	    data = (unsigned char *)malloc(c->nChars * c->itemSize);
 	    if (!data)
 	    {
 		free(c);
@@ -1704,7 +1704,7 @@ SetFontPathElements(int npaths, unsigned char *paths, int *bad, Bool persist)
     FontPathElementPtr fpe = NULL, *fplist;
 
     fplist = (FontPathElementPtr *)
-	xalloc(sizeof(FontPathElementPtr) * npaths);
+	malloc(sizeof(FontPathElementPtr) * npaths);
     if (!fplist) {
 	*bad = 0;
 	return BadAlloc;
@@ -1745,13 +1745,13 @@ SetFontPathElements(int npaths, unsigned char *paths, int *bad, Bool persist)
 	    /* if error or can't do it, act like it's a new one */
 	    if (!fpe)
 	    {
-		fpe = (FontPathElementPtr) xalloc(sizeof(FontPathElementRec));
+		fpe = (FontPathElementPtr) malloc(sizeof(FontPathElementRec));
 		if (!fpe) 
 		{
 		    err = BadAlloc;
 		    goto bail;
 		}
-		fpe->name = (char *) xalloc(len + 1);
+		fpe->name = (char *) malloc(len + 1);
 		if (!fpe->name) 
 		{
 		    free(fpe);
diff --git a/nx-X11/programs/Xserver/dix/dixutils.c b/nx-X11/programs/Xserver/dix/dixutils.c
index 1c6305684..84eb63f14 100644
--- a/nx-X11/programs/Xserver/dix/dixutils.c
+++ b/nx-X11/programs/Xserver/dix/dixutils.c
@@ -621,7 +621,7 @@ QueueWorkProc (
 {
     WorkQueuePtr    q;
 
-    q = (WorkQueuePtr) xalloc (sizeof *q);
+    q = (WorkQueuePtr) malloc (sizeof *q);
     if (!q)
 	return FALSE;
     q->function = function;
@@ -655,7 +655,7 @@ ClientSleep (ClientPtr client, ClientSleepProcPtr function, void * closure)
 {
     SleepQueuePtr   q;
 
-    q = (SleepQueuePtr) xalloc (sizeof *q);
+    q = (SleepQueuePtr) malloc (sizeof *q);
     if (!q)
 	return FALSE;
 
@@ -735,7 +735,7 @@ _AddCallback(
 {
     CallbackPtr     cbr;
 
-    cbr = (CallbackPtr) xalloc(sizeof(CallbackRec));
+    cbr = (CallbackPtr) malloc(sizeof(CallbackRec));
     if (!cbr)
 	return FALSE;
     cbr->proc = callback;
@@ -888,7 +888,7 @@ CreateCallbackList(CallbackListPtr *pcbl, CallbackFuncsPtr cbfuncs)
     int i;
 
     if (!pcbl) return FALSE;
-    cbl = (CallbackListPtr) xalloc(sizeof(CallbackListRec));
+    cbl = (CallbackListPtr) malloc(sizeof(CallbackListRec));
     if (!cbl) return FALSE;
     cbl->funcs = cbfuncs ? *cbfuncs : default_cbfuncs;
     cbl->inCallback = 0;
diff --git a/nx-X11/programs/Xserver/dix/events.c b/nx-X11/programs/Xserver/dix/events.c
index ba0c5d847..97cd13b5e 100644
--- a/nx-X11/programs/Xserver/dix/events.c
+++ b/nx-X11/programs/Xserver/dix/events.c
@@ -1027,7 +1027,7 @@ EnqueueEvent(xEvent *xE, DeviceIntPtr device, int count)
 	    return;
 	}
     }
-    qe = (QdEventPtr)xalloc(sizeof(QdEventRec) + (count * sizeof(xEvent)));
+    qe = (QdEventPtr)malloc(sizeof(QdEventRec) + (count * sizeof(xEvent)));
     if (!qe)
 	return;
     qe->next = (QdEventPtr)NULL;
@@ -3030,7 +3030,7 @@ EventSelectForWindow(register WindowPtr pWin, register ClientPtr client, Mask ma
 	check = 0;
 	if (!pWin->optional && !MakeWindowOptional (pWin))
 	    return BadAlloc;
-	others = (OtherClients *) xalloc(sizeof(OtherClients));
+	others = (OtherClients *) malloc(sizeof(OtherClients));
 	if (!others)
 	    return BadAlloc;
 	others->mask = mask;
@@ -3929,7 +3929,7 @@ InitEvents()
     if (spriteTraceSize == 0)
     {
 	spriteTraceSize = 32;
-	spriteTrace = (WindowPtr *)xalloc(32*sizeof(WindowPtr));
+	spriteTrace = (WindowPtr *)malloc(32*sizeof(WindowPtr));
 	if (!spriteTrace)
 	    FatalError("failed to allocate spriteTrace");
     }
diff --git a/nx-X11/programs/Xserver/dix/extension.c b/nx-X11/programs/Xserver/dix/extension.c
index 4f06c0af4..9c25c3db8 100644
--- a/nx-X11/programs/Xserver/dix/extension.c
+++ b/nx-X11/programs/Xserver/dix/extension.c
@@ -95,10 +95,10 @@ AddExtension(char *name, int NumEvents, int NumErrors,
 	        (unsigned)(lastError + NumErrors > LAST_ERROR))
         return((ExtensionEntry *) NULL);
 
-    ext = (ExtensionEntry *) xalloc(sizeof(ExtensionEntry));
+    ext = (ExtensionEntry *) malloc(sizeof(ExtensionEntry));
     if (!ext)
 	return((ExtensionEntry *) NULL);
-    ext->name = (char *)xalloc(strlen(name) + 1);
+    ext->name = (char *)malloc(strlen(name) + 1);
     ext->num_aliases = 0;
     ext->aliases = (char **)NULL;
     if (!ext->name)
@@ -164,7 +164,7 @@ Bool AddExtensionAlias(char *alias, ExtensionEntry *ext)
     if (!aliases)
 	return FALSE;
     ext->aliases = aliases;
-    name = (char *)xalloc(strlen(alias) + 1);
+    name = (char *)malloc(strlen(alias) + 1);
     if (!name)
 	return FALSE;
     strcpy(name,  alias);
@@ -438,7 +438,7 @@ RegisterScreenProc(char *name, ScreenPtr pScreen, ExtensionLookupProc proc)
         procEntry->proc = proc;
     else
     {
-	newname = (char *)xalloc(strlen(name)+1);
+	newname = (char *)malloc(strlen(name)+1);
 	if (!newname)
 	    return FALSE;
 	procEntry = (ProcEntryPtr)
diff --git a/nx-X11/programs/Xserver/dix/gc.c b/nx-X11/programs/Xserver/dix/gc.c
index 595d8ab74..9566bb8f7 100644
--- a/nx-X11/programs/Xserver/dix/gc.c
+++ b/nx-X11/programs/Xserver/dix/gc.c
@@ -466,7 +466,7 @@ dixChangeGC(ClientPtr client, register GC *pGC, register BITS32 mask, CARD32 *pC
  		{
 		    unsigned char *dash;
 
-		    dash = (unsigned char *)xalloc(2 * sizeof(unsigned char));
+		    dash = (unsigned char *)malloc(2 * sizeof(unsigned char));
 		    if (dash)
 		    {
 			if (pGC->dash != DefaultDash)
@@ -580,7 +580,7 @@ AllocateGC(ScreenPtr pScreen)
     register unsigned size;
     register int i;
 
-    pGC = (GCPtr)xalloc(pScreen->totalGCSize);
+    pGC = (GCPtr)malloc(pScreen->totalGCSize);
     if (pGC)
     {
 	ppriv = (DevUnion *)(pGC + 1);
@@ -848,7 +848,7 @@ CopyGC(register GC *pgcSrc, register GC *pgcDst, register BITS32 mask)
 		    unsigned char *dash;
 		    unsigned int i;
 
-		    dash = (unsigned char *)xalloc(pgcSrc->numInDashList *
+		    dash = (unsigned char *)malloc(pgcSrc->numInDashList *
 						   sizeof(unsigned char));
 		    if (dash)
 		    {
@@ -1098,9 +1098,9 @@ SetDashes(register GCPtr pGC, unsigned offset, unsigned ndash, unsigned char *pd
     }
 
     if (ndash & 1)
-	p = (unsigned char *)xalloc(2 * ndash * sizeof(unsigned char));
+	p = (unsigned char *)malloc(2 * ndash * sizeof(unsigned char));
     else
-	p = (unsigned char *)xalloc(ndash * sizeof(unsigned char));
+	p = (unsigned char *)malloc(ndash * sizeof(unsigned char));
     if (!p)
 	return BadAlloc;
 
@@ -1195,7 +1195,7 @@ SetClipRects(GCPtr pGC, int xOrigin, int yOrigin, int nrects,
     if (newct < 0)
 	return(BadMatch);
     size = nrects * sizeof(xRectangle);
-    prectsNew = (xRectangle *) xalloc(size);
+    prectsNew = (xRectangle *) malloc(size);
     if (!prectsNew && size)
 	return BadAlloc;
 
diff --git a/nx-X11/programs/Xserver/dix/glyphcurs.c b/nx-X11/programs/Xserver/dix/glyphcurs.c
index c8b71db4e..a1da68443 100644
--- a/nx-X11/programs/Xserver/dix/glyphcurs.c
+++ b/nx-X11/programs/Xserver/dix/glyphcurs.c
@@ -93,7 +93,7 @@ ServerBitsFromGlyph(FontPtr pfont, unsigned ch, register CursorMetricPtr cm, uns
 
     pScreen = screenInfo.screens[0];
     nby = BitmapBytePad(cm->width) * (long)cm->height;
-    pbits = (char *)xalloc(nby);
+    pbits = (char *)malloc(nby);
     if (!pbits)
 	return BadAlloc;
     /* zeroing the (pad) bits seems to help some ddx cursor handling */
diff --git a/nx-X11/programs/Xserver/dix/grabs.c b/nx-X11/programs/Xserver/dix/grabs.c
index 7fd9ad096..d72ef3f6a 100644
--- a/nx-X11/programs/Xserver/dix/grabs.c
+++ b/nx-X11/programs/Xserver/dix/grabs.c
@@ -84,7 +84,7 @@ CreateGrab(
 {
     GrabPtr grab;
 
-    grab = (GrabPtr)xalloc(sizeof(GrabRec));
+    grab = (GrabPtr)malloc(sizeof(GrabRec));
     if (!grab)
 	return (GrabPtr)NULL;
     grab->resource = FakeClientID(client);
@@ -158,7 +158,7 @@ DeleteDetailFromMask(Mask *pDetailMask, unsigned short detail)
     register Mask *mask;
     register int i;
 
-    mask = (Mask *)xalloc(sizeof(Mask) * MasksPerDetailMask);
+    mask = (Mask *)malloc(sizeof(Mask) * MasksPerDetailMask);
     if (mask)
     {
 	if (pDetailMask)
diff --git a/nx-X11/programs/Xserver/dix/main.c b/nx-X11/programs/Xserver/dix/main.c
index 9d0197e3d..05f6dd19b 100644
--- a/nx-X11/programs/Xserver/dix/main.c
+++ b/nx-X11/programs/Xserver/dix/main.c
@@ -310,12 +310,12 @@ main(int argc, char *argv[], char *envp[])
 	{
 	    CreateWellKnownSockets();
 	    InitProcVectors();
-	    clients = (ClientPtr *)xalloc(MAXCLIENTS * sizeof(ClientPtr));
+	    clients = (ClientPtr *)malloc(MAXCLIENTS * sizeof(ClientPtr));
 	    if (!clients)
 		FatalError("couldn't create client array");
 	    for (i=1; i<MAXCLIENTS; i++) 
 		clients[i] = NullClient;
-	    serverClient = (ClientPtr)xalloc(sizeof(ClientRec));
+	    serverClient = (ClientPtr)malloc(sizeof(ClientRec));
 	    if (!serverClient)
 		FatalError("couldn't create server client");
 	    InitClient(serverClient, 0, (void *)NULL);
@@ -556,7 +556,7 @@ CreateConnectionBlock()
             ((setup.nbytesVendor + 3) & ~3) +
 	    (setup.numFormats * sizeof(xPixmapFormat)) +
             (setup.numRoots * sizeof(xWindowRoot));
-    ConnectionInfo = (char *) xalloc(lenofblock);
+    ConnectionInfo = (char *) malloc(lenofblock);
     if (!ConnectionInfo)
 	return FALSE;
 
diff --git a/nx-X11/programs/Xserver/dix/pixmap.c b/nx-X11/programs/Xserver/dix/pixmap.c
index 463e31598..246d26067 100644
--- a/nx-X11/programs/Xserver/dix/pixmap.c
+++ b/nx-X11/programs/Xserver/dix/pixmap.c
@@ -128,7 +128,7 @@ AllocatePixmap(ScreenPtr pScreen, int pixDataSize)
      * the pixmap buffer. This may be a RENDER bug.
      */
 
-    pPixmap = (PixmapPtr)xalloc(pScreen->totalPixmapSize + pixDataSize + 4);
+    pPixmap = (PixmapPtr)malloc(pScreen->totalPixmapSize + pixDataSize + 4);
     if (!pPixmap)
 	return NullPixmap;
     ppriv = (DevUnion *)(pPixmap + 1);
@@ -146,7 +146,7 @@ AllocatePixmap(ScreenPtr pScreen, int pixDataSize)
 	    ppriv->ptr = (void *)NULL;
     }
 #else
-    pPixmap = (PixmapPtr)xalloc(sizeof(PixmapRec) + pixDataSize);
+    pPixmap = (PixmapPtr)malloc(sizeof(PixmapRec) + pixDataSize);
 #endif
     return pPixmap;
 }
diff --git a/nx-X11/programs/Xserver/dix/property.c b/nx-X11/programs/Xserver/dix/property.c
index 4476141e5..28ce1355c 100644
--- a/nx-X11/programs/Xserver/dix/property.c
+++ b/nx-X11/programs/Xserver/dix/property.c
@@ -284,10 +284,10 @@ ChangeWindowProperty(WindowPtr pWin, Atom property, Atom type, int format,
     {
 	if (!pWin->optional && !MakeWindowOptional (pWin))
 	    return(BadAlloc);
-        pProp = (PropertyPtr)xalloc(sizeof(PropertyRec));
+        pProp = (PropertyPtr)malloc(sizeof(PropertyRec));
 	if (!pProp)
 	    return(BadAlloc);
-        data = (void *)xalloc(totalSize);
+        data = (void *)malloc(totalSize);
 	if (!data && len)
 	{
 	    free(pProp);
@@ -347,7 +347,7 @@ ChangeWindowProperty(WindowPtr pWin, Atom property, Atom type, int format,
 	}
         else if (mode == PropModePrepend)
         {
-            data = (void *)xalloc(sizeInBytes * (len + pProp->size));
+            data = (void *)malloc(sizeInBytes * (len + pProp->size));
 	    if (!data)
 		return(BadAlloc);
 	    memmove(&((char *)data)[totalSize], (char *)pProp->data, 
diff --git a/nx-X11/programs/Xserver/dix/region.c b/nx-X11/programs/Xserver/dix/region.c
index 4c2bc4695..df7c1fc16 100644
--- a/nx-X11/programs/Xserver/dix/region.c
+++ b/nx-X11/programs/Xserver/dix/region.c
@@ -311,7 +311,7 @@ RegionCreate(rect, size)
 {
     register RegionPtr pReg;
     size_t newSize;
-    pReg = (RegionPtr)xalloc(sizeof(RegionRec));
+    pReg = (RegionPtr)malloc(sizeof(RegionRec));
     if (!pReg)
 	return &RegionBrokenRegion;
     if (rect)
@@ -324,7 +324,7 @@ RegionCreate(rect, size)
 	pReg->extents = RegionEmptyBox;
 	newSize = RegionSizeof(size);
 	if ((size > 1) && (newSize > 0) &&
-	    (pReg->data = xalloc(newSize)))
+	    (pReg->data = malloc(newSize)))
 	{
 	    pReg->data->size = size;
 	    pReg->data->numRects = 0;
@@ -367,7 +367,7 @@ RegionRectAlloc(
     {
 	n++;
 	rgnSize = RegionSizeof(n);
-	pRgn->data = (rgnSize > 0) ? xalloc(rgnSize) : NULL;
+	pRgn->data = (rgnSize > 0) ? malloc(rgnSize) : NULL;
 	if (!pRgn->data)
 	    return RegionBreak (pRgn);
 	pRgn->data->numRects = 1;
@@ -376,7 +376,7 @@ RegionRectAlloc(
     else if (!pRgn->data->size)
     {
 	rgnSize = RegionSizeof(n);
-	pRgn->data = (rgnSize > 0) ? xalloc(rgnSize) : NULL;
+	pRgn->data = (rgnSize > 0) ? malloc(rgnSize) : NULL;
 	if (!pRgn->data)
 	    return RegionBreak (pRgn);
 	pRgn->data->numRects = 0;
@@ -1235,7 +1235,7 @@ RegionValidate(badreg, pOverlap)
 
     /* Set up the first region to be the first rectangle in badreg */
     /* Note that step 2 code will never overflow the ri[0].reg rects array */
-    ri = (RegionInfo *) xalloc(4 * sizeof(RegionInfo));
+    ri = (RegionInfo *) malloc(4 * sizeof(RegionInfo));
     if (!ri)
 	return RegionBreak (badreg);
     sizeRI = 4;
@@ -1402,7 +1402,7 @@ RegionFromRects(nrects, prect, ctype)
 	return pRgn;
     }
     newSize = RegionSizeof(nrects);
-    pData = newSize > 0 ? xalloc(newSize) : NULL;
+    pData = newSize > 0 ? malloc(newSize) : NULL;
     if (!pData)
     {
 	RegionBreak (pRgn);
@@ -1469,7 +1469,7 @@ miRegionDataCopy(
     {
 	size_t newSize = RegionSizeof(src->data->numRects);
 	xfreeData(dst);
-	dst->data = newSize > 0 ? xalloc(newSize) : NULL;
+	dst->data = newSize > 0 ? malloc(newSize) : NULL;
 	if (!dst->data)
 	    return RegionBreak (dst);
     }
diff --git a/nx-X11/programs/Xserver/dix/resource.c b/nx-X11/programs/Xserver/dix/resource.c
index 0c5b6dd29..905dafc24 100644
--- a/nx-X11/programs/Xserver/dix/resource.c
+++ b/nx-X11/programs/Xserver/dix/resource.c
@@ -232,7 +232,7 @@ InitClientResources(ClientPtr client)
 	TypeMask = RC_LASTPREDEF - 1;
 	if (DeleteFuncs)
 	    free(DeleteFuncs);
-	DeleteFuncs = (DeleteType *)xalloc((lastResourceType + 1) *
+	DeleteFuncs = (DeleteType *)malloc((lastResourceType + 1) *
 					   sizeof(DeleteType));
 	if (!DeleteFuncs)
 	    return FALSE;
@@ -250,13 +250,13 @@ InitClientResources(ClientPtr client)
 #ifdef XResExtension
         if(ResourceNames)
             free(ResourceNames);
-        ResourceNames = xalloc((lastResourceType + 1) * sizeof(Atom));
+        ResourceNames = malloc((lastResourceType + 1) * sizeof(Atom));
         if(!ResourceNames)
            return FALSE;
 #endif
     }
     clientTable[i = client->index].resources =
-	(ResourcePtr *)xalloc(INITBUCKETS*sizeof(ResourcePtr));
+	(ResourcePtr *)malloc(INITBUCKETS*sizeof(ResourcePtr));
     if (!clientTable[i].resources)
 	return FALSE;
     clientTable[i].buckets = INITBUCKETS;
@@ -442,7 +442,7 @@ AddResource(XID id, RESTYPE type, void * value)
 	(rrec->hashsize < MAXHASHSIZE))
 	RebuildTable(client);
     head = &rrec->resources[Hash(client, id)];
-    res = (ResourcePtr)xalloc(sizeof(ResourceRec));
+    res = (ResourcePtr)malloc(sizeof(ResourceRec));
     if (!res)
     {
 	(*DeleteFuncs[type & TypeMask])(value, id);
@@ -477,7 +477,7 @@ RebuildTable(int client)
     tails = (ResourcePtr **)ALLOCATE_LOCAL(j * sizeof(ResourcePtr *));
     if (!tails)
 	return;
-    resources = (ResourcePtr *)xalloc(j * sizeof(ResourcePtr));
+    resources = (ResourcePtr *)malloc(j * sizeof(ResourcePtr));
     if (!resources)
     {
 	DEALLOCATE_LOCAL(tails);
diff --git a/nx-X11/programs/Xserver/dix/window.c b/nx-X11/programs/Xserver/dix/window.c
index 945dde7cf..f4c10f11d 100644
--- a/nx-X11/programs/Xserver/dix/window.c
+++ b/nx-X11/programs/Xserver/dix/window.c
@@ -344,7 +344,7 @@ AllocateWindow(ScreenPtr pScreen)
     register unsigned size;
     register int i;
 
-    pWin = (WindowPtr)xalloc(pScreen->totalWindowSize);
+    pWin = (WindowPtr)malloc(pScreen->totalWindowSize);
     if (pWin)
     {
 	ppriv = (DevUnion *)(pWin + 1);
@@ -403,7 +403,7 @@ CreateRootWindow(ScreenPtr pScreen)
     pWin->parent = NullWindow;
     SetWindowToDefaults(pWin);
 
-    pWin->optional = (WindowOptRec *) xalloc (sizeof (WindowOptRec));
+    pWin->optional = (WindowOptRec *) malloc (sizeof (WindowOptRec));
     if (!pWin->optional)
         return FALSE;
 
@@ -3445,8 +3445,8 @@ TileScreenSaver(int i, int kind)
     cm.height=16;
     cm.xhot=8;
     cm.yhot=8;
-    srcbits = (unsigned char *)xalloc( BitmapBytePad(32)*16);
-    mskbits = (unsigned char *)xalloc( BitmapBytePad(32)*16);
+    srcbits = (unsigned char *)malloc( BitmapBytePad(32)*16);
+    mskbits = (unsigned char *)malloc( BitmapBytePad(32)*16);
     if (!srcbits || !mskbits)
     {
 	free(srcbits);
@@ -3595,7 +3595,7 @@ MakeWindowOptional (register WindowPtr pWin)
 
     if (pWin->optional)
 	return TRUE;
-    optional = (WindowOptPtr) xalloc (sizeof (WindowOptRec));
+    optional = (WindowOptPtr) malloc (sizeof (WindowOptRec));
     if (!optional)
 	return FALSE;
     optional->dontPropagateMask = DontPropagateMasks[pWin->dontPropagate];
diff --git a/nx-X11/programs/Xserver/fb/fballpriv.c b/nx-X11/programs/Xserver/fb/fballpriv.c
index c1cd834f1..638e71621 100644
--- a/nx-X11/programs/Xserver/fb/fballpriv.c
+++ b/nx-X11/programs/Xserver/fb/fballpriv.c
@@ -83,7 +83,7 @@ fbAllocatePrivates(ScreenPtr pScreen, int *pGCIndex)
     {
 	FbScreenPrivPtr	pScreenPriv;
 
-	pScreenPriv = (FbScreenPrivPtr) xalloc (sizeof (FbScreenPrivRec));
+	pScreenPriv = (FbScreenPrivPtr) malloc (sizeof (FbScreenPrivRec));
 	if (!pScreenPriv)
 	    return FALSE;
 	pScreen->devPrivates[fbScreenPrivateIndex].ptr = (void *) pScreenPriv;
diff --git a/nx-X11/programs/Xserver/fb/fbcmap.c b/nx-X11/programs/Xserver/fb/fbcmap.c
index 9fdffdeff..656cafbb8 100644
--- a/nx-X11/programs/Xserver/fb/fbcmap.c
+++ b/nx-X11/programs/Xserver/fb/fbcmap.c
@@ -390,7 +390,7 @@ fbSetVisualTypesAndMasks (int depth, int visuals, int bitsPerRGB,
 {
     fbVisualsPtr   new, *prev, v;
 
-    new = (fbVisualsPtr) xalloc (sizeof *new);
+    new = (fbVisualsPtr) malloc (sizeof *new);
     if (!new)
 	return FALSE;
     if (!redMask || !greenMask || !blueMask)
@@ -487,8 +487,8 @@ fbInitVisuals (VisualPtr    *visualp,
 	ndepth++;
 	nvisual += visuals->count;
     }
-    depth = (DepthPtr) xalloc (ndepth * sizeof (DepthRec));
-    visual = (VisualPtr) xalloc (nvisual * sizeof (VisualRec));
+    depth = (DepthPtr) malloc (ndepth * sizeof (DepthRec));
+    visual = (VisualPtr) malloc (nvisual * sizeof (VisualRec));
     if (!depth || !visual)
     {
 	free (depth);
@@ -508,7 +508,7 @@ fbInitVisuals (VisualPtr    *visualp,
 	vid = NULL;
 	if (nvtype)
 	{
-	    vid = (VisualID *) xalloc (nvtype * sizeof (VisualID));
+	    vid = (VisualID *) malloc (nvtype * sizeof (VisualID));
 	    if (!vid)
 		return FALSE;
 	}
diff --git a/nx-X11/programs/Xserver/fb/fbcopy.c b/nx-X11/programs/Xserver/fb/fbcopy.c
index d1fb63828..e936fcc9a 100644
--- a/nx-X11/programs/Xserver/fb/fbcopy.c
+++ b/nx-X11/programs/Xserver/fb/fbcopy.c
@@ -244,7 +244,7 @@ fbCopyNto1 (DrawablePtr	pSrcDrawable,
 	    height = pbox->y2 - pbox->y1;
 	    
 	    tmpStride = ((width + FB_STIP_MASK) >> FB_STIP_SHIFT);
-	    tmp = xalloc (tmpStride * height * sizeof (FbStip));
+	    tmp = malloc (tmpStride * height * sizeof (FbStip));
 	    if (!tmp)
 		return;
 	    
diff --git a/nx-X11/programs/Xserver/fb/fboverlay.c b/nx-X11/programs/Xserver/fb/fboverlay.c
index 49623ba4f..a98a131c9 100644
--- a/nx-X11/programs/Xserver/fb/fboverlay.c
+++ b/nx-X11/programs/Xserver/fb/fboverlay.c
@@ -363,7 +363,7 @@ fbOverlayFinishScreenInit(ScreenPtr	pScreen,
 	fbOverlayGeneration = serverGeneration;
     }
 
-    pScrPriv = xalloc (sizeof (FbOverlayScrPrivRec));
+    pScrPriv = malloc (sizeof (FbOverlayScrPrivRec));
     if (!pScrPriv)
 	return FALSE;
  
diff --git a/nx-X11/programs/Xserver/fb/fbpseudocolor.c b/nx-X11/programs/Xserver/fb/fbpseudocolor.c
index bc1c091ed..71f39b52f 100644
--- a/nx-X11/programs/Xserver/fb/fbpseudocolor.c
+++ b/nx-X11/programs/Xserver/fb/fbpseudocolor.c
@@ -271,7 +271,7 @@ xxCreateScreenResources(ScreenPtr pScreen)
     if (pScrPriv->addr)
 	pBits = pScrPriv->addr;
     else
-	pBits = xalloc(pScreen->width * pScreen->height
+	pBits = malloc(pScreen->width * pScreen->height
 		       * (BitsPerPixel(depth) >> 3));
     if (!pBits) return FALSE;
     
@@ -370,11 +370,11 @@ xxInitColormapPrivate(ColormapPtr pmap)
     
     if (xxMyVisual(pmap->pScreen,pmap->pVisual->vid)) {
 	DBG("CreateColormap\n");
-	pCmapPriv = (xxCmapPrivPtr) xalloc (sizeof (xxCmapPrivRec));
+	pCmapPriv = (xxCmapPrivPtr) malloc (sizeof (xxCmapPrivRec));
 	if (!pCmapPriv)
 	    return FALSE;
 	pmap->devPrivates[xxColormapPrivateIndex].ptr = (void *) pCmapPriv;
-	cmap = xalloc(sizeof (CARD32) * (1 << pScrPriv->myDepth));
+	cmap = malloc(sizeof (CARD32) * (1 << pScrPriv->myDepth));
 	if (!cmap)
 	return FALSE;
 
@@ -1109,7 +1109,7 @@ xxSetup(ScreenPtr pScreen, int myDepth, int baseDepth, char* addr, xxSyncFunc sy
     if (!AllocateGCPrivate (pScreen, xxGCPrivateIndex, sizeof (xxGCPrivRec)))
 	return FALSE;
 
-    pScrPriv = (xxScrPrivPtr) xalloc (sizeof (xxScrPrivRec));
+    pScrPriv = (xxScrPrivPtr) malloc (sizeof (xxScrPrivRec));
     if (!pScrPriv)
 	return FALSE;
     
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Args.c b/nx-X11/programs/Xserver/hw/nxagent/Args.c
index 4f0173db0..895de1ef8 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Args.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Args.c
@@ -362,7 +362,7 @@ int ddxProcessArgument(int argc, char *argv[], int i)
 
       if ((size = strlen(argv[i])) < 1024)
       {
-        if ((nxagentOptionFile = xalloc(size + 1)) == NULL)
+        if ((nxagentOptionFile = malloc(size + 1)) == NULL)
         {
           FatalError("malloc failed");
         }
@@ -726,7 +726,7 @@ int ddxProcessArgument(int argc, char *argv[], int i)
 
       if ((size = strlen(argv[i])) < 256)
       {
-        if ((nxagentKeyboard = xalloc(size + 1)) == NULL)
+        if ((nxagentKeyboard = malloc(size + 1)) == NULL)
         {
           FatalError("malloc failed");
         }
@@ -1537,7 +1537,7 @@ void nxagentProcessOptionsFile()
     goto nxagentProcessOptionsFileClose;
   }
 
-  if ((data = xalloc(sizeOfFile + 1)) == NULL)
+  if ((data = malloc(sizeOfFile + 1)) == NULL)
   {
     fprintf(stderr, "Warning: Memory allocation failed processing file '%s'.\n",
                 validateString(nxagentOptionFile));
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Clipboard.c b/nx-X11/programs/Xserver/hw/nxagent/Clipboard.c
index 5249d8550..2fb53d440 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Clipboard.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Clipboard.c
@@ -1491,7 +1491,7 @@ int nxagentInitClipboard(WindowPtr pWin)
     lastSelectionOwner = NULL;
   }
 
-  lastSelectionOwner = (SelectionOwner *) xalloc(2 * sizeof(SelectionOwner));
+  lastSelectionOwner = (SelectionOwner *) malloc(2 * sizeof(SelectionOwner));
 
   if (lastSelectionOwner == NULL)
   {
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Colormap.c b/nx-X11/programs/Xserver/hw/nxagent/Colormap.c
index 18c4c67a6..3905e289b 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Colormap.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Colormap.c
@@ -77,7 +77,7 @@ Bool nxagentCreateColormap(ColormapPtr pCmap)
   pVisual = pCmap->pVisual;
   ncolors = pVisual->ColormapEntries;
 
-  pCmap->devPriv = (void *)xalloc(sizeof(nxagentPrivColormap));
+  pCmap->devPriv = (void *)malloc(sizeof(nxagentPrivColormap));
 
   if (((visual = nxagentVisual(pVisual))) == NULL)
   {
@@ -103,7 +103,7 @@ Bool nxagentCreateColormap(ColormapPtr pCmap)
 
   switch (class) {
   case StaticGray: /* read only */
-    colors = (XColor *)xalloc(ncolors * sizeof(XColor));
+    colors = (XColor *)malloc(ncolors * sizeof(XColor));
     for (i = 0; i < ncolors; i++)
       colors[i].pixel = i;
     XQueryColors(nxagentDisplay, nxagentColormap(pCmap), colors, ncolors);
@@ -116,7 +116,7 @@ Bool nxagentCreateColormap(ColormapPtr pCmap)
     break;
 
   case StaticColor: /* read only */
-    colors = (XColor *)xalloc(ncolors * sizeof(XColor));
+    colors = (XColor *)malloc(ncolors * sizeof(XColor));
     for (i = 0; i < ncolors; i++)
       colors[i].pixel = i;
     XQueryColors(nxagentDisplay, nxagentColormap(pCmap), colors, ncolors);
@@ -129,7 +129,7 @@ Bool nxagentCreateColormap(ColormapPtr pCmap)
     break;
 
   case TrueColor: /* read only */
-    colors = (XColor *)xalloc(ncolors * sizeof(XColor));
+    colors = (XColor *)malloc(ncolors * sizeof(XColor));
     red = green = blue = 0L;
     redInc = lowbit(pVisual->redMask);
     greenInc = lowbit(pVisual->greenMask);
@@ -229,13 +229,13 @@ void nxagentSetInstalledColormapWindows(ScreenPtr pScreen)
   nxagentInstalledColormapWindows icws;
   int numWindows;
 
-  icws.cmapIDs = (Colormap *)xalloc(pScreen->maxInstalledCmaps *
+  icws.cmapIDs = (Colormap *)malloc(pScreen->maxInstalledCmaps *
 				    sizeof(Colormap));
   icws.numCmapIDs = nxagentListInstalledColormaps(pScreen, icws.cmapIDs);
   icws.numWindows = 0;
   WalkTree(pScreen, nxagentCountInstalledColormapWindows, (void *)&icws);
   if (icws.numWindows) {
-    icws.windows = (Window *)xalloc((icws.numWindows + 1) * sizeof(Window));
+    icws.windows = (Window *)malloc((icws.numWindows + 1) * sizeof(Window));
     icws.index = 0;
     WalkTree(pScreen, nxagentGetInstalledColormapWindows, (void *)&icws);
     icws.windows[icws.numWindows] = nxagentDefaultWindows[pScreen->myNum];
@@ -255,7 +255,7 @@ void nxagentSetInstalledColormapWindows(ScreenPtr pScreen)
 #ifdef _XSERVER64
     {
       int i;
-      Window64 *windows = (Window64 *)xalloc(numWindows * sizeof(Window64));
+      Window64 *windows = (Window64 *)malloc(numWindows * sizeof(Window64));
 
       for(i = 0; i < numWindows; ++i)
 	  windows[i] = icws.windows[i];
@@ -437,7 +437,7 @@ void nxagentStoreColors(ColormapPtr pCmap, int nColors, xColorItem *pColors)
 #ifdef _XSERVER64
   {
     int i;
-    XColor *pColors64 = (XColor *)xalloc(nColors * sizeof(XColor) );
+    XColor *pColors64 = (XColor *)malloc(nColors * sizeof(XColor) );
 
     for(i = 0; i < nColors; ++i)
     {
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Cursor.c b/nx-X11/programs/Xserver/hw/nxagent/Cursor.c
index b1449bf13..932f7495f 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Cursor.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Cursor.c
@@ -231,7 +231,7 @@ Bool nxagentRealizeCursor(ScreenPtr pScreen, CursorPtr pCursor)
   bg_color.green = pCursor->backGreen;
   bg_color.blue = pCursor->backBlue;
 
-  pCursor->devPriv[pScreen->myNum] = (void *) xalloc(sizeof(nxagentPrivCursor));
+  pCursor->devPriv[pScreen->myNum] = (void *) malloc(sizeof(nxagentPrivCursor));
 
   nxagentCursorPriv(pCursor, pScreen)->cursor =
          XCreatePixmapCursor(nxagentDisplay, source, mask, &fg_color,
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Display.c b/nx-X11/programs/Xserver/hw/nxagent/Display.c
index 27cd0859a..86a338b3d 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Display.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Display.c
@@ -1272,7 +1272,7 @@ Reply   Total	Cached	Bits In			Bits Out		Bits/Reply	  Ratio
   nxagentInitVisuals();
 
   nxagentNumDefaultColormaps = nxagentNumVisuals;
-  nxagentDefaultColormaps = (Colormap *)xalloc(nxagentNumDefaultColormaps *
+  nxagentDefaultColormaps = (Colormap *)malloc(nxagentNumDefaultColormaps *
                                              sizeof(Colormap));
 
   for (i = 0; i < nxagentNumDefaultColormaps; i++)
@@ -1651,7 +1651,7 @@ void nxagentInitPixmapFormats()
 XXX: Some X server doesn't list 1 among available depths...
 */
 
-  nxagentPixmapFormats = xalloc((nxagentNumDepths + 1) * sizeof(XPixmapFormatValues));
+  nxagentPixmapFormats = malloc((nxagentNumDepths + 1) * sizeof(XPixmapFormatValues));
 
   for (i = 1; i <= MAXDEPTH; i++)
   {
@@ -2063,7 +2063,7 @@ void nxagentBackupDisplayInfo(void)
     free(nxagentVisualHasBeenIgnored);
     nxagentVisualHasBeenIgnored = NULL;
   }
-  nxagentVisualHasBeenIgnored = xalloc(nxagentNumVisuals * sizeof(Bool));
+  nxagentVisualHasBeenIgnored = malloc(nxagentNumVisuals * sizeof(Bool));
   nxagentDefaultDepthRecBackup = DefaultDepth(nxagentDisplay, DefaultScreen(nxagentDisplay));
   nxagentDisplayWidthRecBackup = DisplayWidth(nxagentDisplay, DefaultScreen(nxagentDisplay));
   nxagentDisplayHeightRecBackup = DisplayHeight(nxagentDisplay, DefaultScreen(nxagentDisplay));
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Drawable.c b/nx-X11/programs/Xserver/hw/nxagent/Drawable.c
index a73040eeb..bf88db38c 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Drawable.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Drawable.c
@@ -223,7 +223,7 @@ int nxagentSynchronizeDrawableData(DrawablePtr pDrawable, unsigned int breakMask
 
     length = nxagentImageLength(width, height, format, leftPad, depth);
 
-    if ((data = xalloc(length)) == NULL)
+    if ((data = malloc(length)) == NULL)
     {
       #ifdef WARNING
       fprintf(stderr, "nxagentSynchronizeDrawableData: WARNING! Failed to allocate memory for the operation.\n");
@@ -2129,7 +2129,7 @@ unsigned long nxagentGetColor(DrawablePtr pDrawable, int xPixel, int yPixel)
   format = (depth == 1) ? XYPixmap : ZPixmap;
   length = nxagentImageLength(1, 1, format, leftPad, depth);
 
-  if ((data = xalloc(length)) == NULL)
+  if ((data = malloc(length)) == NULL)
   {
     #ifdef WARNING
     fprintf(stderr, "nxagentGetColor: WARNING! Failed to allocate memory for the operation.\n");
@@ -2374,7 +2374,7 @@ void nxagentFillRemoteRegion(DrawablePtr pDrawable, RegionPtr pRegion)
   {
     pBox = RegionRects(pRegion);
 
-    pRects = xalloc(nrects * sizeof(XRectangle));
+    pRects = malloc(nrects * sizeof(XRectangle));
 
     for (i = 0; i < nrects; i++)
     {
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Font.c b/nx-X11/programs/Xserver/hw/nxagent/Font.c
index 22b3e6c88..90f545027 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Font.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Font.c
@@ -330,9 +330,9 @@ void nxagentListRemoteAddName(const char *name, int status)
                     (nxagentRemoteFontList.length - pos) * sizeof(nxagentFontRecPtr));
   }
 
-  if ((nxagentRemoteFontList.list[pos] = xalloc(sizeof(nxagentFontRec))))
+  if ((nxagentRemoteFontList.list[pos] = malloc(sizeof(nxagentFontRec))))
   {
-    nxagentRemoteFontList.list[pos]->name = xalloc(strlen(name) +1);
+    nxagentRemoteFontList.list[pos]->name = malloc(strlen(name) +1);
     if (nxagentRemoteFontList.list[pos]->name == NULL)
     {
        fprintf(stderr, "Font: remote list name memory allocation failed!.\n");
@@ -538,7 +538,7 @@ Bool nxagentRealizeFont(ScreenPtr pScreen, FontPtr pFont)
      name = origName;
   }
 
-  priv = (void *)xalloc(sizeof(nxagentPrivFont));
+  priv = (void *)malloc(sizeof(nxagentPrivFont));
   FontSetPrivate(pFont, nxagentFontPrivateIndex, priv);
 
   nxagentFontPriv(pFont) -> mirrorID = 0;
@@ -579,14 +579,14 @@ Bool nxagentRealizeFont(ScreenPtr pScreen, FontPtr pFont)
         CACHE_SIZE += 100;
      }
 
-     CACHE_ENTRY(CACHE_INDEX) = xalloc(sizeof(nxCacheFontEntryRec));
+     CACHE_ENTRY(CACHE_INDEX) = malloc(sizeof(nxCacheFontEntryRec));
 
      if (CACHE_ENTRY(CACHE_INDEX) == NULL)
      {
         return False;
      }
 
-     CACHE_NAME(CACHE_INDEX) = xalloc(strlen(name) + 1);
+     CACHE_NAME(CACHE_INDEX) = malloc(strlen(name) + 1);
 
      if (CACHE_NAME(CACHE_INDEX) == NULL)
      {
@@ -753,7 +753,7 @@ static XFontStruct *nxagentLoadBestQueryFont(Display* dpy, char *fontName, FontP
   fprintf(stderr, "nxagentLoadBestQueryFont: Searching font '%s' .\n", fontName);
   #endif
 
-  substFontBuf = (char *) xalloc(sizeof(char) * 512);
+  substFontBuf = (char *) malloc(sizeof(char) * 512);
 
 
   numFontFields = nxagentSplitString(fontName, fontNameFields, FIELDS + 1, "-");
@@ -1666,7 +1666,7 @@ XFontStruct* nxagentLoadQueryFont(register Display *dpy, char *name, FontPtr pFo
     register long nbytes;
 
     nbytes = pFont -> info.nprops * sizeof(XFontProp);
-    fs -> properties = (XFontProp *) Xalloc((unsigned) nbytes);
+    fs -> properties = (XFontProp *) malloc((unsigned) nbytes);
 
     if (fs -> properties == NULL)
     {
diff --git a/nx-X11/programs/Xserver/hw/nxagent/GC.c b/nx-X11/programs/Xserver/hw/nxagent/GC.c
index 21e828769..ef83b871a 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/GC.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/GC.c
@@ -673,7 +673,7 @@ void nxagentChangeClip(GCPtr pGC, int type, void * pValue, int nRects)
       {
         nRects = RegionNumRects((RegionPtr)pValue);
         size = nRects * sizeof(*pRects);
-        pRects = (XRectangle *) xalloc(size);
+        pRects = (XRectangle *) malloc(size);
         pBox = RegionRects((RegionPtr)pValue);
 
         for (i = nRects; i-- > 0;)
@@ -1280,7 +1280,7 @@ static void nxagentReconnectClip(GCPtr pGC, int type, void * pValue, int nRects)
       {
         nRects = RegionNumRects((RegionPtr)pValue);
         size = nRects * sizeof(*pRects);
-        pRects = (XRectangle *) xalloc(size);
+        pRects = (XRectangle *) malloc(size);
         pBox = RegionRects((RegionPtr)pValue);
         for (i = nRects; i-- > 0;) {
           pRects[i].x = pBox[i].x1;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/GCOps.c b/nx-X11/programs/Xserver/hw/nxagent/GCOps.c
index 01a3f6a93..a50a830f9 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/GCOps.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/GCOps.c
@@ -754,7 +754,7 @@ RegionPtr nxagentCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
 
     length = nxagentImageLength(width, height, format, leftPad, depth);
 
-    if ((data = xalloc(length)) == NULL)
+    if ((data = malloc(length)) == NULL)
     {
       #ifdef WARNING
       fprintf(stderr, "nxagentCopyArea: WARNING! Failed to allocate memory for the operation.\n");
@@ -974,7 +974,7 @@ RegionPtr nxagentCopyPlane(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
 
     length = nxagentImageLength(width, height, format, leftPad, depth);
 
-    if ((data = xalloc(length)) == NULL)
+    if ((data = malloc(length)) == NULL)
     {
       #ifdef DEBUG
       fprintf(stderr, "nxagentCopyPlane: WARNING! Failed to allocate memory for the operation.\n");
@@ -1467,7 +1467,7 @@ void nxagentFillPolygon(DrawablePtr pDrawable, GCPtr pGC, int shape,
 
     mode = CoordModePrevious;
 
-    newPoints = xalloc(nPoints * sizeof(xPoint));
+    newPoints = malloc(nPoints * sizeof(xPoint));
 
     /*
      * The first point is always relative
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Image.c b/nx-X11/programs/Xserver/hw/nxagent/Image.c
index b7c3135d0..8cc8962cc 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Image.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Image.c
@@ -1808,7 +1808,7 @@ char *nxagentAllocateImageData(int width, int height, int depth, int *length, in
 
   data = NULL;
 
-  if ((data = xalloc(*length)) == NULL)
+  if ((data = malloc(*length)) == NULL)
   {
     #ifdef WARNING
     fprintf(stderr, "nxagentAllocateImageData: WARNING! Failed to allocate [%d] bytes of memory.\n", *length);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c b/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c
index 6bd201d70..e85cdfdb6 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Keyboard.c
@@ -757,7 +757,7 @@ N/A
         }
 
         len = (max_keycode - min_keycode + 1) * mapWidth;
-        keymap = (KeySym *)xalloc(len * sizeof(KeySym));
+        keymap = (KeySym *)malloc(len * sizeof(KeySym));
         for(i = 0; i < len; ++i)
           keymap[i] = keymap64[i];
         XFree(keymap64);
@@ -1296,7 +1296,7 @@ int nxagentResetKeyboard(void)
               savedBellPercent, savedBellPitch, savedBellDuration);
   #endif
 
-  devBackup = xalloc(sizeof(DeviceIntRec));
+  devBackup = malloc(sizeof(DeviceIntRec));
 
   if (devBackup == NULL)
   {
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c b/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c
index d1923106d..b27a92102 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c
@@ -204,7 +204,7 @@ InitSelections()
 #ifdef NXAGENT_CLIPBOARD
     {
       Selection *newsels;
-      newsels = (Selection *)xalloc(2 * sizeof(Selection));
+      newsels = (Selection *)malloc(2 * sizeof(Selection));
       if (!newsels)
         return;
       NumCurrentSelections += 2;
@@ -750,7 +750,7 @@ ProcSetSelectionOwner(register ClientPtr client)
 	    Selection *newsels;
 
 	    if (i == 0)
-		newsels = (Selection *)xalloc(sizeof(Selection));
+		newsels = (Selection *)malloc(sizeof(Selection));
 	    else
 		newsels = (Selection *)xrealloc(CurrentSelections,
 			    (NumCurrentSelections + 1) * sizeof(Selection));
@@ -1338,7 +1338,7 @@ InitClientPrivates(ClientPtr client)
 	ppriv = (DevUnion *)(client + 1);
     else
     {
-	ppriv = (DevUnion *)xalloc(totalClientSize - sizeof(ClientRec));
+	ppriv = (DevUnion *)malloc(totalClientSize - sizeof(ClientRec));
 	if (!ppriv)
 	    return 0;
     }
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c b/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c
index d15df9513..4b0af0867 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXdixfonts.c
@@ -442,7 +442,7 @@ doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
 		}
 		if (err == FontNameAlias) {
 		    if (resolved) free(resolved);
-		    resolved = (char *) xalloc(resolvedlen + 1);
+		    resolved = (char *) malloc(resolvedlen + 1);
 		    if (resolved)
 			memmove(resolved, tmpname, resolvedlen + 1);
 		}
@@ -497,7 +497,7 @@ doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
 		    c->haveSaved = TRUE;
 		    if (c->savedName)
 			free(c->savedName);
-		    c->savedName = (char *)xalloc(namelen + 1);
+		    c->savedName = (char *)malloc(namelen + 1);
 		    if (c->savedName)
 			memmove(c->savedName, name, namelen + 1);
 		    c->savedNameLen = namelen;
@@ -638,10 +638,10 @@ ListFonts(ClientPtr client, unsigned char *pattern, unsigned length,
     if (length > XLFDMAXFONTNAMELEN)
 	return BadAlloc;
 
-    if (!(c = (LFclosurePtr) xalloc(sizeof *c)))
+    if (!(c = (LFclosurePtr) malloc(sizeof *c)))
 	return BadAlloc;
     c->fpe_list = (FontPathElementPtr *)
-	xalloc(sizeof(FontPathElementPtr) * num_fpes);
+	malloc(sizeof(FontPathElementPtr) * num_fpes);
     if (!c->fpe_list) {
 	free(c);
 	return BadAlloc;
@@ -786,7 +786,7 @@ doListFontsWithInfo(ClientPtr client, LFWIclosurePtr c)
 		c->savedNumFonts = numFonts;
 		if (c->savedName)
 		  free(c->savedName);
-		c->savedName = (char *)xalloc(namelen + 1);
+		c->savedName = (char *)malloc(namelen + 1);
 		if (c->savedName)
 		  memmove(c->savedName, name, namelen + 1);
 		aliascount = 20;
@@ -1086,7 +1086,7 @@ nxdoListFontsAndAliases(client, fss)
 		}
 		if (err == FontNameAlias) {
 		    if (resolved) free(resolved);
-		    resolved = (char *) xalloc(resolvedlen + 1);
+		    resolved = (char *) malloc(resolvedlen + 1);
 		    if (resolved)
                     {
                         memmove(resolved, tmpname, resolvedlen);
@@ -1155,7 +1155,7 @@ nxdoListFontsAndAliases(client, fss)
 		    c->haveSaved = TRUE;
 		    if (c->savedName)
 			free(c->savedName);
-		    c->savedName = (char *)xalloc(namelen + 1);
+		    c->savedName = (char *)malloc(namelen + 1);
 		    if (c->savedName)
                     {
                         memmove(c->savedName, name, namelen);
@@ -1275,7 +1275,7 @@ nxOpenFont(client, fid, flags, lenfname, pfontname)
 
 #ifdef FONTDEBUG
     char *f;
-    f = (char *)xalloc(lenfname + 1);
+    f = (char *)malloc(lenfname + 1);
     memmove(f, pfontname, lenfname);
     f[lenfname] = '\0';
     ErrorF("OpenFont: fontname is \"%s\"\n", f);
@@ -1312,16 +1312,16 @@ nxOpenFont(client, fid, flags, lenfname, pfontname)
 	    return Success;
 	}
     }
-    if (!(fss = (nxFsPtr) xalloc(sizeof(nxFs))))
+    if (!(fss = (nxFsPtr) malloc(sizeof(nxFs))))
         return BadAlloc;
 
-    if (!(c = (LFclosurePtr) xalloc(sizeof *c)))
+    if (!(c = (LFclosurePtr) malloc(sizeof *c)))
     {
 	free(fss);
 	return BadAlloc;
     }
         c->fpe_list = (FontPathElementPtr *)
-	xalloc(sizeof(FontPathElementPtr) * num_fpes);
+	malloc(sizeof(FontPathElementPtr) * num_fpes);
     if (!c->fpe_list) {
 	free(c);
 	free(fss);
@@ -1351,7 +1351,7 @@ nxOpenFont(client, fid, flags, lenfname, pfontname)
     c->slept = FALSE;
     c->savedName = 0;
 
-    oc = (OFclosurePtr) xalloc(sizeof(OFclosureRec));
+    oc = (OFclosurePtr) malloc(sizeof(OFclosureRec));
     if (!oc)
     {
       for (i = 0; i < c->num_fpes; i++)
@@ -1361,7 +1361,7 @@ nxOpenFont(client, fid, flags, lenfname, pfontname)
       free(fss);
       return BadAlloc;
     }
-    oc->fontname = (char *) xalloc(256);/* I don't want to deal with future reallocs errors */
+    oc->fontname = (char *) malloc(256);/* I don't want to deal with future reallocs errors */
     oc->origFontName = pfontname;
     oc->origFontNameLen = lenfname;
     if (!oc->fontname) {
@@ -1378,7 +1378,7 @@ nxOpenFont(client, fid, flags, lenfname, pfontname)
      * while we're blocking, the request still appears atomic
      */
     oc->fpe_list = (FontPathElementPtr *)
-	xalloc(sizeof(FontPathElementPtr) * num_fpes);
+	malloc(sizeof(FontPathElementPtr) * num_fpes);
     if (!oc->fpe_list) {
 	free(oc->fontname);
 	free(oc);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXglyphcurs.c b/nx-X11/programs/Xserver/hw/nxagent/NXglyphcurs.c
index 53a5a8d68..430fb6baf 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXglyphcurs.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXglyphcurs.c
@@ -101,7 +101,7 @@ ServerBitsFromGlyph(FontPtr pfont, unsigned ch, register CursorMetricPtr cm, uns
 
     pScreen = screenInfo.screens[0];
     nby = BitmapBytePad(cm->width) * (long)cm->height;
-    pbits = (char *)xalloc(nby);
+    pbits = (char *)malloc(nby);
     if (!pbits)
 	return BadAlloc;
     /* zeroing the (pad) bits seems to help some ddx cursor handling */
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXmiglyph.c b/nx-X11/programs/Xserver/hw/nxagent/NXmiglyph.c
index bdc0bc316..15798bc77 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXmiglyph.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXmiglyph.c
@@ -87,7 +87,7 @@ miGlyphs (CARD8		op,
         }
         else
         {
-          nxagentGlyphsExtents = (BoxPtr) xalloc(sizeof(BoxRec));
+          nxagentGlyphsExtents = (BoxPtr) malloc(sizeof(BoxRec));
 
           miGlyphExtents (nlist, list, glyphs, &extents);
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXmitrap.c b/nx-X11/programs/Xserver/hw/nxagent/NXmitrap.c
index 1ef445af5..8db856d0a 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXmitrap.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXmitrap.c
@@ -80,7 +80,7 @@ miTrapezoids (CARD8	    op,
         }
         else
         {
-          nxagentTrapezoidExtents = (BoxPtr) xalloc(sizeof(BoxRec));
+          nxagentTrapezoidExtents = (BoxPtr) malloc(sizeof(BoxRec));
 
           miTrapezoidBounds (ntrap, traps, &bounds);
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXpicture.c b/nx-X11/programs/Xserver/hw/nxagent/NXpicture.c
index 44248bc1b..83133cb36 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXpicture.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXpicture.c
@@ -87,7 +87,7 @@ PictureCreateDefaultFormats (ScreenPtr pScreen, int *nformatp)
 
     nxagentPictureCreateDefaultFormats(pScreen, formats, &nformats);
 
-    pFormats = (PictFormatPtr) xalloc (nformats * sizeof (PictFormatRec));
+    pFormats = (PictFormatPtr) malloc (nformats * sizeof (PictFormatRec));
     if (!pFormats)
 	return 0;
     memset (pFormats, '\0', nformats * sizeof (PictFormatRec));
@@ -190,7 +190,7 @@ AllocatePicture (ScreenPtr  pScreen)
     unsigned int    	size;
     int			i;
 
-    pPicture = (PicturePtr) xalloc (ps->totalPictureSize);
+    pPicture = (PicturePtr) malloc (ps->totalPictureSize);
     if (!pPicture)
 	return 0;
     ppriv = (DevUnion *)(pPicture + 1);
@@ -281,7 +281,7 @@ CreateSolidPicture (Picture pid, xRenderColor *color, int *error)
     }
 
     pPicture->id = pid;
-    pPicture->pSourcePict = (SourcePictPtr) xalloc(sizeof(PictSolidFill));
+    pPicture->pSourcePict = (SourcePictPtr) malloc(sizeof(PictSolidFill));
     if (!pPicture->pSourcePict) {
         *error = BadAlloc;
         free(pPicture);
@@ -318,7 +318,7 @@ static PicturePtr createSourcePicture(void)
                            picturePrivateCount * sizeof(DevUnion) +
                                sizeof(nxagentPrivPictureRec);
 
-    pPicture = (PicturePtr) xalloc(totalPictureSize);
+    pPicture = (PicturePtr) malloc(totalPictureSize);
 
     if (pPicture != NULL)
     {
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXproperty.c b/nx-X11/programs/Xserver/hw/nxagent/NXproperty.c
index 0ace2fbd2..4b4e059bd 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXproperty.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXproperty.c
@@ -227,10 +227,10 @@ ChangeWindowProperty(WindowPtr pWin, Atom property, Atom type, int format,
     {
 	if (!pWin->optional && !MakeWindowOptional (pWin))
 	    return(BadAlloc);
-        pProp = (PropertyPtr)xalloc(sizeof(PropertyRec));
+        pProp = (PropertyPtr)malloc(sizeof(PropertyRec));
 	if (!pProp)
 	    return(BadAlloc);
-        data = (void *)xalloc(totalSize);
+        data = (void *)malloc(totalSize);
 	if (!data && len)
 	{
 	    free(pProp);
@@ -290,7 +290,7 @@ ChangeWindowProperty(WindowPtr pWin, Atom property, Atom type, int format,
 	}
         else if (mode == PropModePrepend)
         {
-            data = (void *)xalloc(sizeInBytes * (len + pProp->size));
+            data = (void *)malloc(sizeInBytes * (len + pProp->size));
 	    if (!data)
 		return(BadAlloc);
 	    memmove(&((char *)data)[totalSize], (char *)pProp->data, 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXrender.c b/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
index b89b835db..d14b47866 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
@@ -224,7 +224,7 @@ ProcRenderQueryPictFormats (ClientPtr client)
 	       ndepth * sizeof (xPictDepth) +
 	       nvisual * sizeof (xPictVisual) +
 	       numSubpixel * sizeof (CARD32));
-    reply = (xRenderQueryPictFormatsReply *) xalloc (rlength);
+    reply = (xRenderQueryPictFormatsReply *) malloc (rlength);
     if (!reply)
 	return BadAlloc;
     memset(reply, 0, rlength);
@@ -712,7 +712,7 @@ ProcRenderTrapezoids (ClientPtr client)
     {
       if (pFormat != NULL)
       {
-        nxagentTrapezoidExtents = (BoxPtr) xalloc(sizeof(BoxRec));
+        nxagentTrapezoidExtents = (BoxPtr) malloc(sizeof(BoxRec));
 
         miTrapezoidBounds (ntraps, (xTrapezoid *) &stuff[1], nxagentTrapezoidExtents);
       }
@@ -996,7 +996,7 @@ ProcRenderCompositeGlyphs (ClientPtr client)
 	    return BadAlloc;
     }
 
-    elementsBase = xalloc(nlist * sizeof(XGlyphElt8));
+    elementsBase = malloc(nlist * sizeof(XGlyphElt8));
     if (!elementsBase)
       return BadAlloc;
 
@@ -1098,7 +1098,7 @@ ProcRenderCompositeGlyphs (ClientPtr client)
      * after the X requests.
      */
 
-    nxagentGlyphsExtents = (BoxPtr) xalloc(sizeof(BoxRec));
+    nxagentGlyphsExtents = (BoxPtr) malloc(sizeof(BoxRec));
 
     miGlyphExtents(nlist, listsBase, glyphsBase, nxagentGlyphsExtents);
 
@@ -1219,19 +1219,19 @@ ProcRenderCreateCursor (ClientPtr client)
     if ( stuff->x > width 
       || stuff->y > height )
 	return (BadMatch);
-    argbbits = xalloc (width * height * sizeof (CARD32));
+    argbbits = malloc (width * height * sizeof (CARD32));
     if (!argbbits)
 	return (BadAlloc);
     
     stride = BitmapBytePad(width);
     nbytes_mono = stride*height;
-    srcbits = (unsigned char *)xalloc(nbytes_mono);
+    srcbits = (unsigned char *)malloc(nbytes_mono);
     if (!srcbits)
     {
 	free (argbbits);
 	return (BadAlloc);
     }
-    mskbits = (unsigned char *)xalloc(nbytes_mono);
+    mskbits = (unsigned char *)malloc(nbytes_mono);
     if (!mskbits)
     {
 	free(argbbits);
@@ -1477,7 +1477,7 @@ ProcRenderCreateAnimCursor (ClientPtr client)
     if (client->req_len & 1)
 	return BadLength;
     ncursor = (client->req_len - (SIZEOF(xRenderCreateAnimCursorReq) >> 2)) >> 1;
-    cursors = xalloc (ncursor * (sizeof (CursorPtr) + sizeof (CARD32)));
+    cursors = malloc (ncursor * (sizeof (CursorPtr) + sizeof (CARD32)));
     if (!cursors)
 	return BadAlloc;
     deltas = (CARD32 *) (cursors + ncursor);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXresource.c b/nx-X11/programs/Xserver/hw/nxagent/NXresource.c
index 4226a4435..eb48c5094 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXresource.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXresource.c
@@ -257,7 +257,7 @@ AddResource(XID id, RESTYPE type, void * value)
 	(rrec->hashsize < MAXHASHSIZE))
 	RebuildTable(client);
     head = &rrec->resources[Hash(client, id)];
-    res = (ResourcePtr)xalloc(sizeof(ResourceRec));
+    res = (ResourcePtr)malloc(sizeof(ResourceRec));
     if (!res)
     {
 	(*DeleteFuncs[type & TypeMask])(value, id);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXshm.c b/nx-X11/programs/Xserver/hw/nxagent/NXshm.c
index 08237440f..86b9e0d24 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXshm.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXshm.c
@@ -234,7 +234,7 @@ fbShmPutImage(dst, pGC, depth, format, w, h, sx, sy, sw, sh, dx, dy, data)
 
         length = nxagentImageLength(sw, sh, format, 0, depth);
 
-        if ((newdata = xalloc(length)) != NULL)
+        if ((newdata = malloc(length)) != NULL)
         {
           fbGetImage((DrawablePtr) pPixmap, sx, sy, sw, sh, format, AllPlanes, newdata);
           (*pGC->ops->PutImage)(dst, pGC, depth, dx, dy, sw, sh, 0, format, newdata);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Pixmap.c b/nx-X11/programs/Xserver/hw/nxagent/Pixmap.c
index 0eabf1262..931c564dc 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Pixmap.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Pixmap.c
@@ -1251,7 +1251,7 @@ void nxagentSynchronizeShmPixmap(DrawablePtr pDrawable, int xPict, int yPict,
 
     nxagentFBTrap = 1;
 
-    if ((data = xalloc(length)) != NULL)
+    if ((data = malloc(length)) != NULL)
     {
       fbGetImage(nxagentVirtualDrawable(pDrawable), xPict, yPict,
                      width, height, format, 0xffffffff, data);
@@ -1373,7 +1373,7 @@ FIXME: If the pixmap has a different depth from the window, the
 
   length = nxagentImageLength(width, height, format, 0, depth);
 
-  if ((data = xalloc(length)) == NULL)
+  if ((data = malloc(length)) == NULL)
   {
     #ifdef WARNING
     fprintf(stderr, "nxagentPixmapOnShadowDisplay: WARNING! Failed to allocate memory for the operation.\n");
@@ -1535,7 +1535,7 @@ Bool nxagentFbOnShadowDisplay()
 
   length = nxagentImageLength(width, height, format, 0, depth);
 
-  if ((data = xalloc(length)) == NULL)
+  if ((data = malloc(length)) == NULL)
   {
     #ifdef WARNING
     fprintf(stderr, "nxagentFbOnShadowDisplay: WARNING! Failed to allocate memory for the operation.\n");
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Reconnect.c b/nx-X11/programs/Xserver/hw/nxagent/Reconnect.c
index 587e9a564..74c7587c7 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Reconnect.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Reconnect.c
@@ -329,17 +329,17 @@ void nxagentInitReconnector(void)
 {
   nxagentReconnectTrap = 0;
 
-  reconnectLossyLevel[DISPLAY_STEP]    = xalloc(sizeof(int));
-  reconnectLossyLevel[SCREEN_STEP]     = xalloc(sizeof(int));
-  reconnectLossyLevel[FONT_STEP]       = xalloc(sizeof(int));
-  reconnectLossyLevel[PIXMAP_STEP]     = xalloc(sizeof(int));
-  reconnectLossyLevel[GC_STEP]         = xalloc(sizeof(int));
-  reconnectLossyLevel[CURSOR_STEP]     = xalloc(sizeof(int));
-  reconnectLossyLevel[COLORMAP_STEP]   = xalloc(sizeof(int));
-  reconnectLossyLevel[WINDOW_STEP]     = xalloc(sizeof(int));
-  reconnectLossyLevel[GLYPHSET_STEP]   = xalloc(sizeof(int));
-  reconnectLossyLevel[PICTFORMAT_STEP] = xalloc(sizeof(int));
-  reconnectLossyLevel[PICTURE_STEP]    = xalloc(sizeof(int));
+  reconnectLossyLevel[DISPLAY_STEP]    = malloc(sizeof(int));
+  reconnectLossyLevel[SCREEN_STEP]     = malloc(sizeof(int));
+  reconnectLossyLevel[FONT_STEP]       = malloc(sizeof(int));
+  reconnectLossyLevel[PIXMAP_STEP]     = malloc(sizeof(int));
+  reconnectLossyLevel[GC_STEP]         = malloc(sizeof(int));
+  reconnectLossyLevel[CURSOR_STEP]     = malloc(sizeof(int));
+  reconnectLossyLevel[COLORMAP_STEP]   = malloc(sizeof(int));
+  reconnectLossyLevel[WINDOW_STEP]     = malloc(sizeof(int));
+  reconnectLossyLevel[GLYPHSET_STEP]   = malloc(sizeof(int));
+  reconnectLossyLevel[PICTFORMAT_STEP] = malloc(sizeof(int));
+  reconnectLossyLevel[PICTURE_STEP]    = malloc(sizeof(int));
 }
 
 void nxagentDisconnectSession(void)
@@ -434,7 +434,7 @@ Bool nxagentReconnectSession(void)
 
     size = strlen(nxagentKeyboard);
 
-    if ((nxagentOldKeyboard = xalloc(size + 1)) != NULL)
+    if ((nxagentOldKeyboard = malloc(size + 1)) != NULL)
     {
       strncpy(nxagentOldKeyboard, nxagentKeyboard, size);
 
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Render.c b/nx-X11/programs/Xserver/hw/nxagent/Render.c
index 36ce6a74f..4c9edb849 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Render.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Render.c
@@ -270,11 +270,11 @@ void nxagentRenderExtensionInit()
 
 int nxagentCursorSaveRenderInfo(ScreenPtr pScreen, CursorPtr pCursor)
 {
-  pCursor -> devPriv[pScreen -> myNum] = xalloc(sizeof(nxagentPrivCursor));
+  pCursor -> devPriv[pScreen -> myNum] = malloc(sizeof(nxagentPrivCursor));
 
   if (nxagentCursorPriv(pCursor, pScreen) == NULL)
   {
-    FatalError("xalloc failed");
+    FatalError("malloc failed");
   }
 
   nxagentCursorUsesRender(pCursor, pScreen) = 1;
@@ -2249,7 +2249,7 @@ void nxagentAddGlyphs(GlyphSetPtr glyphSet, Glyph *gids, xGlyphInfo *gi,
 
   if (sizeImages > 0)
   {
-    normalizedImages = xalloc(sizeImages);
+    normalizedImages = malloc(sizeImages);
 
     if (normalizedImages != NULL)
     {
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Rootless.c b/nx-X11/programs/Xserver/hw/nxagent/Rootless.c
index 6947371ff..d5c6e71c9 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Rootless.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Rootless.c
@@ -305,7 +305,7 @@ void nxagentRootlessRestack(unsigned long children[], unsigned int nchildren)
   XID values[2];
   Mask mask;
 
-  toplevel = xalloc(sizeof(WindowPtr) * nchildren);
+  toplevel = malloc(sizeof(WindowPtr) * nchildren);
   ntoplevel = 0;
 
   for(i = 0; i < nchildren; i++)
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Screen.c b/nx-X11/programs/Xserver/hw/nxagent/Screen.c
index a4c6fc2db..152040fbd 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Screen.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Screen.c
@@ -1149,13 +1149,13 @@ Bool nxagentOpenScreen(int index, ScreenPtr pScreen,
      * Initialize the depths.
      */
 
-    depths = (DepthPtr) xalloc(nxagentNumDepths * sizeof(DepthRec));
+    depths = (DepthPtr) malloc(nxagentNumDepths * sizeof(DepthRec));
 
     for (i = 0; i < nxagentNumDepths; i++)
     {
       depths[i].depth = nxagentDepths[i];
       depths[i].numVids = 0;
-      depths[i].vids = (VisualID *) xalloc(MAXVISUALSPERDEPTH * sizeof(VisualID));
+      depths[i].vids = (VisualID *) malloc(MAXVISUALSPERDEPTH * sizeof(VisualID));
     }
 
     /*
@@ -1170,7 +1170,7 @@ Bool nxagentOpenScreen(int index, ScreenPtr pScreen,
     numVisuals = 0;
     numDepths = nxagentNumDepths;
 
-    visuals = (VisualPtr) xalloc(nxagentNumVisuals * sizeof(VisualRec));
+    visuals = (VisualPtr) malloc(nxagentNumVisuals * sizeof(VisualRec));
 
     for (i = 0; i < nxagentNumVisuals; i++)
     {
@@ -1250,7 +1250,7 @@ Bool nxagentOpenScreen(int index, ScreenPtr pScreen,
 
         depths[depthIndex].depth = nxagentVisuals[i].depth;
         depths[depthIndex].numVids = 0;
-        depths[depthIndex].vids = (VisualID *) xalloc(MAXVISUALSPERDEPTH * sizeof(VisualID));
+        depths[depthIndex].vids = (VisualID *) malloc(MAXVISUALSPERDEPTH * sizeof(VisualID));
 
         numDepths++;
       }
@@ -1302,7 +1302,7 @@ Bool nxagentOpenScreen(int index, ScreenPtr pScreen,
                 "[%d] bitsPerPixel [%d] sizeInBytes [%d]\n", rootDepth, bitsPerPixel, sizeInBytes);
     #endif
 
-    pFrameBufferBits = (char *) Xalloc(sizeInBytes);
+    pFrameBufferBits = (char *) malloc(sizeInBytes);
 
     if (!pFrameBufferBits)
     {
@@ -3068,12 +3068,12 @@ int nxagentShadowPoll(PixmapPtr nxagentShadowPixmapPtr, GCPtr nxagentShadowGCPtr
         free(tBuffer);
       }
 
-      tBuffer = xalloc(length);
+      tBuffer = malloc(length);
 
       if (tBuffer == NULL)
       {
         #ifdef PANIC
-        fprintf(stderr, "nxagentShadowPoll: xalloc failed.\n");
+        fprintf(stderr, "nxagentShadowPoll: malloc failed.\n");
         #endif
 
         return -1;
@@ -3166,7 +3166,7 @@ void nxagentShadowAdaptDepth(unsigned int width, unsigned int height,
 
   length = nxagentImageLength(width, height, ZPixmap, 0, nxagentShadowDepth);
 
-  cBuffer = xalloc(length);
+  cBuffer = malloc(length);
   icBuffer = cBuffer;
 
   pVisual = nxagentImageVisual((DrawablePtr) nxagentShadowPixmapPtr, nxagentShadowDepth);
@@ -3423,7 +3423,7 @@ FIXME: The port information is not used at the moment and produces a
 
     #endif
 
-    local_buf = (char *) xalloc(strlen((char*)pszReturnData) + 100);
+    local_buf = (char *) malloc(strlen((char*)pszReturnData) + 100);
 
     if (local_buf)
     {
@@ -3771,7 +3771,7 @@ int nxagentAdjustRandRXinerama(ScreenPtr pScreen)
       if (screeninfo) {
 	free(screeninfo);
       }
-      if (!(screeninfo = xalloc(sizeof(XineramaScreenInfo)))) {
+      if (!(screeninfo = malloc(sizeof(XineramaScreenInfo)))) {
 	return FALSE;
       }
 
@@ -4157,7 +4157,7 @@ void nxagentSaveAreas(PixmapPtr pPixmap, RegionPtr prgnSave, int xorg, int yorg,
 
   nRects = RegionNumRects(&cleanRegion);
   size = nRects * sizeof(*pRects);
-  pRects = (XRectangle *) xalloc(size);
+  pRects = (XRectangle *) malloc(size);
   pBox = RegionRects(&cleanRegion);
 
   for (i = nRects; i-- > 0;)
@@ -4303,7 +4303,7 @@ void nxagentRestoreAreas(PixmapPtr pPixmap, RegionPtr prgnRestore, int xorg,
 
   nRects = RegionNumRects(clipRegion);
   size = nRects * sizeof(*pRects);
-  pRects = (XRectangle *) xalloc(size);
+  pRects = (XRectangle *) malloc(size);
   pBox = RegionRects(clipRegion);
 
   for (i = nRects; i-- > 0;)
@@ -4511,10 +4511,10 @@ void nxagentShowPixmap(PixmapPtr pPixmap, int x, int y, int width, int height)
 
   length = nxagentImageLength(width, height, format, 0, depth);
 
-  if ((data = xalloc(length)) == NULL)
+  if ((data = malloc(length)) == NULL)
   {
     #ifdef WARNING
-    fprintf(stderr, "nxagentShowPixmap: xalloc failed.\n");
+    fprintf(stderr, "nxagentShowPixmap: malloc failed.\n");
     #endif
 
     return;
@@ -4607,10 +4607,10 @@ void nxagentFbRestoreArea(PixmapPtr pPixmap, WindowPtr pWin, int xSrc, int ySrc,
 
   length = nxagentImageLength(width, height, format, 0, depth);
 
-  if ((data = xalloc(length)) == NULL)
+  if ((data = malloc(length)) == NULL)
   {
     #ifdef WARNING
-    fprintf(stderr, "nxagentFbRestoreArea: xalloc failed.\n");
+    fprintf(stderr, "nxagentFbRestoreArea: malloc failed.\n");
     #endif
 
     return;
diff --git a/nx-X11/programs/Xserver/include/os.h b/nx-X11/programs/Xserver/include/os.h
index 3b6a40b46..342913b4a 100644
--- a/nx-X11/programs/Xserver/include/os.h
+++ b/nx-X11/programs/Xserver/include/os.h
@@ -52,7 +52,7 @@ SOFTWARE.
 #define OS_H
 
 #include "misc.h"
-#define ALLOCATE_LOCAL_FALLBACK(_size) Xalloc((unsigned long)(_size))
+#define ALLOCATE_LOCAL_FALLBACK(_size) malloc((unsigned long)(_size))
 #define DEALLOCATE_LOCAL_FALLBACK(_ptr) free((void *)(_ptr))
 #include <nx-X11/Xalloca.h>
 #ifndef IN_MODULE
diff --git a/nx-X11/programs/Xserver/mi/miarc.c b/nx-X11/programs/Xserver/mi/miarc.c
index b268c1140..c1e07f175 100644
--- a/nx-X11/programs/Xserver/mi/miarc.c
+++ b/nx-X11/programs/Xserver/mi/miarc.c
@@ -912,7 +912,7 @@ miComputeWideEllipse(
     {
 	if (spdata)
 	    free(spdata);
-	spdata = (miArcSpanData *)xalloc(sizeof(miArcSpanData) +
+	spdata = (miArcSpanData *)malloc(sizeof(miArcSpanData) +
 					 sizeof(miArcSpan) * (k + 2));
 	lruent->spdata = spdata;
 	if (!spdata)
@@ -1396,7 +1396,7 @@ miArcJoin(DrawablePtr pDraw, GCPtr pGC, miArcFacePtr pLeft,
 		arc.height = width;
 		arc.angle1 = -miDatan2 (corner.y - center.y, corner.x - center.x);
 		arc.angle2 = a;
-		pArcPts = (SppPointPtr) xalloc (3 * sizeof (SppPointRec));
+		pArcPts = (SppPointPtr) malloc (3 * sizeof (SppPointRec));
 		if (!pArcPts)
 		    return;
 		pArcPts[0].x = otherCorner.x;
@@ -1641,10 +1641,10 @@ miDatan2 (double dy, double dx)
  * This procedure allocates the space necessary to fit the arc points.
  * Sometimes it's convenient for those points to be at the end of an existing
  * array. (For example, if we want to leave a spare point to make sectors
- * instead of segments.)  So we pass in the xalloc()ed chunk that contains the
+ * instead of segments.)  So we pass in the malloc()ed chunk that contains the
  * array and an index saying where we should start stashing the points.
  * If there isn't an array already, we just pass in a null pointer and 
- * count on xrealloc() to handle the null pointer correctly.
+ * count on realloc() to handle the null pointer correctly.
  */
 static int
 miGetArcPts(
@@ -1691,7 +1691,7 @@ miGetArcPts(
     count++;
 
     cdt = 2 * miDcos(dt);
-    if (!(poly = (SppPointPtr) xrealloc((void *)*ppPts,
+    if (!(poly = (SppPointPtr) realloc((void *)*ppPts,
 					(cpt + count) * sizeof(SppPointRec))))
 	return(0);
     *ppPts = poly;
@@ -1933,7 +1933,7 @@ miComputeArcs (
 	data = (struct arcData *) ALLOCATE_LOCAL (narcs * sizeof (struct arcData));
 	if (!data)
 	    return (miPolyArcPtr)NULL;
-	arcs = (miPolyArcPtr) xalloc (sizeof (*arcs) * (isDoubleDash ? 2 : 1));
+	arcs = (miPolyArcPtr) malloc (sizeof (*arcs) * (isDoubleDash ? 2 : 1));
 	if (!arcs)
 	{
 	    DEALLOCATE_LOCAL(data);
@@ -3146,7 +3146,7 @@ realAllocSpan ()
 	register struct finalSpan	*span;
 	register int			i;
 
-	newChunk = (struct finalSpanChunk *) xalloc (sizeof (struct finalSpanChunk));
+	newChunk = (struct finalSpanChunk *) malloc (sizeof (struct finalSpanChunk));
 	if (!newChunk)
 		return (struct finalSpan *) NULL;
 	newChunk->next = chunks;
@@ -3251,7 +3251,7 @@ realFindSpan (int y)
 		else
 			change = SPAN_REALLOC;
 		newSize = finalSize + change;
-		newSpans = (struct finalSpan **) xalloc
+		newSpans = (struct finalSpan **) malloc
  					(newSize * sizeof (struct finalSpan *));
 		if (!newSpans)
 		    return (struct finalSpan **)NULL;
diff --git a/nx-X11/programs/Xserver/mi/mibitblt.c b/nx-X11/programs/Xserver/mi/mibitblt.c
index ae30d5238..bded0850a 100644
--- a/nx-X11/programs/Xserver/mi/mibitblt.c
+++ b/nx-X11/programs/Xserver/mi/mibitblt.c
@@ -239,7 +239,7 @@ miCopyArea(pSrcDrawable, pDstDrawable,
 	    ppt++->y = y++;
 	    *pwidth++ = width;
 	}
-	pbits = (unsigned int *)xalloc(height * PixmapBytePad(width,
+	pbits = (unsigned int *)malloc(height * PixmapBytePad(width,
 					     pSrcDrawable->depth));
 	if (pbits)
 	{
@@ -318,7 +318,7 @@ miGetPlane(
     sy += pDraw->y;
     widthInBytes = BitmapBytePad(w);
     if(!result)
-        result = (MiBits *)xalloc(h * widthInBytes);
+        result = (MiBits *)malloc(h * widthInBytes);
     if (!result)
 	return (MiBits *)NULL;
     bitsPerPixel = pDraw->bitsPerPixel;
diff --git a/nx-X11/programs/Xserver/mi/mibstore.c b/nx-X11/programs/Xserver/mi/mibstore.c
index d3dc11603..5001eae6f 100644
--- a/nx-X11/programs/Xserver/mi/mibstore.c
+++ b/nx-X11/programs/Xserver/mi/mibstore.c
@@ -373,7 +373,7 @@ miInitializeBackingStore (pScreen)
     }
     if (!AllocateGCPrivate(pScreen, miBSGCIndex, 0))
 	return;
-    pScreenPriv = (miBSScreenPtr) xalloc (sizeof (miBSScreenRec));
+    pScreenPriv = (miBSScreenPtr) malloc (sizeof (miBSScreenRec));
     if (!pScreenPriv)
 	return;
 
@@ -903,7 +903,7 @@ miBSCreateGCPrivate (pGC)
 {
     miBSGCRec	*pPriv;
 
-    pPriv = (miBSGCRec *) xalloc (sizeof (miBSGCRec));
+    pPriv = (miBSGCRec *) malloc (sizeof (miBSGCRec));
     if (!pPriv)
 	return FALSE;
     pPriv->pBackingGC = NULL;
@@ -2581,7 +2581,7 @@ miBSAllocate(pWin)
     if (!(pBackingStore = (miBSWindowPtr)pWin->backStorage))
     {
 
-	pBackingStore = (miBSWindowPtr)xalloc(sizeof(miBSWindowRec));
+	pBackingStore = (miBSWindowPtr)malloc(sizeof(miBSWindowRec));
 	if (!pBackingStore)
 	    return;
 
diff --git a/nx-X11/programs/Xserver/mi/micmap.c b/nx-X11/programs/Xserver/mi/micmap.c
index 607ecec3b..1d79ade9b 100644
--- a/nx-X11/programs/Xserver/mi/micmap.c
+++ b/nx-X11/programs/Xserver/mi/micmap.c
@@ -406,7 +406,7 @@ miSetVisualTypesAndMasks(int depth, int visuals, int bitsPerRGB,
     miVisualsPtr   new, *prev, v;
     int		    count;
 
-    new = (miVisualsPtr) xalloc (sizeof *new);
+    new = (miVisualsPtr) malloc (sizeof *new);
     if (!new)
 	return FALSE;
     if (!redMask || !greenMask || !blueMask)
@@ -560,9 +560,9 @@ miDoInitVisuals(VisualPtr *visualp, DepthPtr *depthp, int *nvisualp,
 	ndepth++;
 	nvisual += visuals->count;
     }
-    depth = (DepthPtr) xalloc (ndepth * sizeof (DepthRec));
-    visual = (VisualPtr) xalloc (nvisual * sizeof (VisualRec));
-    preferredCVCs = (int *)xalloc(ndepth * sizeof(int));
+    depth = (DepthPtr) malloc (ndepth * sizeof (DepthRec));
+    visual = (VisualPtr) malloc (nvisual * sizeof (VisualRec));
+    preferredCVCs = (int *)malloc(ndepth * sizeof(int));
     if (!depth || !visual || !preferredCVCs)
     {
 	free (depth);
@@ -586,7 +586,7 @@ miDoInitVisuals(VisualPtr *visualp, DepthPtr *depthp, int *nvisualp,
 	vid = NULL;
 	if (nvtype)
 	{
-	    vid = (VisualID *) xalloc (nvtype * sizeof (VisualID));
+	    vid = (VisualID *) malloc (nvtype * sizeof (VisualID));
 	    if (!vid)
 		return FALSE;
 	}
diff --git a/nx-X11/programs/Xserver/mi/midispcur.c b/nx-X11/programs/Xserver/mi/midispcur.c
index 5d4b3023a..4d5e055eb 100644
--- a/nx-X11/programs/Xserver/mi/midispcur.c
+++ b/nx-X11/programs/Xserver/mi/midispcur.c
@@ -126,7 +126,7 @@ miDCInitialize (pScreen, screenFuncs)
 	    return FALSE;
 	miDCGeneration = serverGeneration;
     }
-    pScreenPriv = (miDCScreenPtr) xalloc (sizeof (miDCScreenRec));
+    pScreenPriv = (miDCScreenPtr) malloc (sizeof (miDCScreenRec));
     if (!pScreenPriv)
 	return FALSE;
 
@@ -250,7 +250,7 @@ miDCRealize (
     GCPtr	    pGC;
     XID		    gcvals[3];
 
-    pPriv = (miDCCursorPtr) xalloc (sizeof (miDCCursorRec));
+    pPriv = (miDCCursorPtr) malloc (sizeof (miDCCursorRec));
     if (!pPriv)
 	return (miDCCursorPtr)NULL;
 #ifdef ARGB_CURSOR
diff --git a/nx-X11/programs/Xserver/mi/migc.c b/nx-X11/programs/Xserver/mi/migc.c
index 0ca7872a3..58a00ddd1 100644
--- a/nx-X11/programs/Xserver/mi/migc.c
+++ b/nx-X11/programs/Xserver/mi/migc.c
@@ -71,7 +71,7 @@ miCreateGCOps(prototype)
     GCOpsPtr        ret;
 
      /* XXX */ Must_have_memory = TRUE;
-    ret = (GCOpsPtr) xalloc(sizeof(GCOps));
+    ret = (GCOpsPtr) malloc(sizeof(GCOps));
      /* XXX */ Must_have_memory = FALSE;
     if (!ret)
 	return 0;
diff --git a/nx-X11/programs/Xserver/mi/mioverlay.c b/nx-X11/programs/Xserver/mi/mioverlay.c
index 1c0402892..cff29ee2a 100644
--- a/nx-X11/programs/Xserver/mi/mioverlay.c
+++ b/nx-X11/programs/Xserver/mi/mioverlay.c
@@ -125,7 +125,7 @@ miInitOverlay(
 				sizeof(miOverlayWindowRec)))
 	return FALSE;
 
-    if(!(pScreenPriv = xalloc(sizeof(miOverlayScreenRec))))
+    if(!(pScreenPriv = malloc(sizeof(miOverlayScreenRec))))
 	return FALSE;
 
     pScreen->devPrivates[miOverlayScreenIndex].ptr = (void *)pScreenPriv;
diff --git a/nx-X11/programs/Xserver/mi/mipointer.c b/nx-X11/programs/Xserver/mi/mipointer.c
index 48da4b6c3..3e9fd0760 100644
--- a/nx-X11/programs/Xserver/mi/mipointer.c
+++ b/nx-X11/programs/Xserver/mi/mipointer.c
@@ -88,7 +88,7 @@ miPointerInitialize (pScreen, spriteFuncs, screenFuncs, waitForUpdate)
 	    return FALSE;
 	miPointerGeneration = serverGeneration;
     }
-    pScreenPriv = (miPointerScreenPtr) xalloc (sizeof (miPointerScreenRec));
+    pScreenPriv = (miPointerScreenPtr) malloc (sizeof (miPointerScreenRec));
     if (!pScreenPriv)
 	return FALSE;
     pScreenPriv->spriteFuncs = spriteFuncs;
diff --git a/nx-X11/programs/Xserver/mi/mipolyutil.c b/nx-X11/programs/Xserver/mi/mipolyutil.c
index 7a9794fe3..f88d03d54 100644
--- a/nx-X11/programs/Xserver/mi/mipolyutil.c
+++ b/nx-X11/programs/Xserver/mi/mipolyutil.c
@@ -106,7 +106,7 @@ miInsertEdgeInET(ET, ETE, scanline, SLLBlock, iSLLBlock)
         if (*iSLLBlock > SLLSPERBLOCK-1) 
         {
             tmpSLLBlock = 
-		  (ScanLineListBlock *)xalloc(sizeof(ScanLineListBlock));
+		  (ScanLineListBlock *)malloc(sizeof(ScanLineListBlock));
 	    if (!tmpSLLBlock)
 		return FALSE;
             (*SLLBlock)->next = tmpSLLBlock;
diff --git a/nx-X11/programs/Xserver/mi/mipushpxl.c b/nx-X11/programs/Xserver/mi/mipushpxl.c
index 83821b266..084597392 100644
--- a/nx-X11/programs/Xserver/mi/mipushpxl.c
+++ b/nx-X11/programs/Xserver/mi/mipushpxl.c
@@ -113,7 +113,7 @@ miPushPixels(pGC, pBitMap, pDrawable, dx, dy, xOrg, yOrg)
             LONG2CHARSDIFFORDER((MiBits)(-1) >> 1);
 #endif
 
-    pwLineStart = (MiBits *)xalloc(BitmapBytePad(dx));
+    pwLineStart = (MiBits *)malloc(BitmapBytePad(dx));
     if (!pwLineStart)
 	return;
     ipt = 0;
diff --git a/nx-X11/programs/Xserver/mi/miscrinit.c b/nx-X11/programs/Xserver/mi/miscrinit.c
index c0df4a072..f2b009fcd 100644
--- a/nx-X11/programs/Xserver/mi/miscrinit.c
+++ b/nx-X11/programs/Xserver/mi/miscrinit.c
@@ -197,7 +197,7 @@ miScreenDevPrivateInit(pScreen, width, pbits)
      * to the screen, until CreateScreenResources can put them in the
      * screen pixmap.
      */
-    pScrInitParms = (miScreenInitParmsPtr)xalloc(sizeof(miScreenInitParmsRec));
+    pScrInitParms = (miScreenInitParmsPtr)malloc(sizeof(miScreenInitParmsRec));
     if (!pScrInitParms)
 	return FALSE;
     pScrInitParms->pbits = pbits;
diff --git a/nx-X11/programs/Xserver/mi/mispans.c b/nx-X11/programs/Xserver/mi/mispans.c
index 107476df3..38398f86b 100644
--- a/nx-X11/programs/Xserver/mi/mispans.c
+++ b/nx-X11/programs/Xserver/mi/mispans.c
@@ -418,8 +418,8 @@ void miFillUniqueSpanGroup(pDraw, pGC, spanGroup)
 	ylength = spanGroup->ymax - ymin + 1;
 
 	/* Allocate Spans for y buckets */
-	yspans = (Spans *) xalloc(ylength * sizeof(Spans));
-	ysizes = (int *) xalloc(ylength * sizeof (int));
+	yspans = (Spans *) malloc(ylength * sizeof(Spans));
+	ysizes = (int *) malloc(ylength * sizeof (int));
 
 	if (!yspans || !ysizes)
 	{
@@ -492,8 +492,8 @@ void miFillUniqueSpanGroup(pDraw, pGC, spanGroup)
 	} /* for i thorough Spans */
 
 	/* Now sort by x and uniquify each bucket into the final array */
-	points = (DDXPointPtr) xalloc(count * sizeof(DDXPointRec));
-	widths = (int *)       xalloc(count * sizeof(int));
+	points = (DDXPointPtr) malloc(count * sizeof(DDXPointRec));
+	widths = (int *)       malloc(count * sizeof(int));
 	if (!points || !widths)
 	{
 	    int	i;
diff --git a/nx-X11/programs/Xserver/mi/misprite.c b/nx-X11/programs/Xserver/mi/misprite.c
index 2b68ad76a..b1555ec1b 100644
--- a/nx-X11/programs/Xserver/mi/misprite.c
+++ b/nx-X11/programs/Xserver/mi/misprite.c
@@ -169,7 +169,7 @@ miSpriteInitialize (pScreen, cursorFuncs, screenFuncs)
 	miSpriteGeneration = serverGeneration;
     }
     
-    pScreenPriv = (miSpriteScreenPtr) xalloc (sizeof (miSpriteScreenRec));
+    pScreenPriv = (miSpriteScreenPtr) malloc (sizeof (miSpriteScreenRec));
     if (!pScreenPriv)
 	return FALSE;
     
diff --git a/nx-X11/programs/Xserver/mi/miwideline.c b/nx-X11/programs/Xserver/mi/miwideline.c
index f3e8c691a..b96db7cfa 100644
--- a/nx-X11/programs/Xserver/mi/miwideline.c
+++ b/nx-X11/programs/Xserver/mi/miwideline.c
@@ -127,10 +127,10 @@ miFillPolyHelper (pDrawable, pGC, pixel, spanData, y, overall_height,
     }
     else
     {
-	spanRec.points = (DDXPointPtr) xalloc (overall_height * sizeof (*ppt));
+	spanRec.points = (DDXPointPtr) malloc (overall_height * sizeof (*ppt));
 	if (!spanRec.points)
 	    return;
-	spanRec.widths = (int *) xalloc (overall_height * sizeof (int));
+	spanRec.widths = (int *) malloc (overall_height * sizeof (int));
 	if (!spanRec.widths)
 	{
 	    free (spanRec.points);
@@ -231,10 +231,10 @@ miFillRectPolyHelper (
     }
     else
     {
-	spanRec.points = (DDXPointPtr) xalloc (h * sizeof (*ppt));
+	spanRec.points = (DDXPointPtr) malloc (h * sizeof (*ppt));
 	if (!spanRec.points)
 	    return;
-	spanRec.widths = (int *) xalloc (h * sizeof (int));
+	spanRec.widths = (int *) malloc (h * sizeof (int));
 	if (!spanRec.widths)
 	{
 	    free (spanRec.points);
@@ -1076,10 +1076,10 @@ miLineArc (
     }
     else
     {
-	points = (DDXPointPtr) xalloc (pGC->lineWidth * sizeof (DDXPointRec));
+	points = (DDXPointPtr) malloc (pGC->lineWidth * sizeof (DDXPointRec));
 	if (!points)
 	    return;
-	widths = (int *) xalloc (pGC->lineWidth * sizeof (int));
+	widths = (int *) malloc (pGC->lineWidth * sizeof (int));
 	if (!widths)
 	{
 	    free (points);
diff --git a/nx-X11/programs/Xserver/miext/cw/cw.c b/nx-X11/programs/Xserver/miext/cw/cw.c
index 5b2c65927..8aca3edf7 100644
--- a/nx-X11/programs/Xserver/miext/cw/cw.c
+++ b/nx-X11/programs/Xserver/miext/cw/cw.c
@@ -641,7 +641,7 @@ miInitializeCompositeWrapper(ScreenPtr pScreen)
     if (!AllocatePicturePrivate(pScreen, cwPictureIndex, 0))
 	return;
 #endif
-    pScreenPriv = (cwScreenPtr)xalloc(sizeof(cwScreenRec));
+    pScreenPriv = (cwScreenPtr)malloc(sizeof(cwScreenRec));
     if (!pScreenPriv)
 	return;
 
diff --git a/nx-X11/programs/Xserver/miext/cw/cw_render.c b/nx-X11/programs/Xserver/miext/cw/cw_render.c
index 2710bf60f..ac4230a03 100644
--- a/nx-X11/programs/Xserver/miext/cw/cw_render.c
+++ b/nx-X11/programs/Xserver/miext/cw/cw_render.c
@@ -74,7 +74,7 @@ cwCreatePicturePrivate (PicturePtr pPicture)
     int		    error;
     cwPicturePtr    pPicturePrivate;
 
-    pPicturePrivate = xalloc (sizeof (cwPictureRec));
+    pPicturePrivate = malloc (sizeof (cwPictureRec));
     if (!pPicturePrivate)
 	return NULL;
     
diff --git a/nx-X11/programs/Xserver/miext/damage/damage.c b/nx-X11/programs/Xserver/miext/damage/damage.c
index 2d6783204..669f08ff5 100755
--- a/nx-X11/programs/Xserver/miext/damage/damage.c
+++ b/nx-X11/programs/Xserver/miext/damage/damage.c
@@ -1770,7 +1770,7 @@ DamageSetup (ScreenPtr pScreen)
     if (!AllocateWindowPrivate (pScreen, damageWinPrivateIndex, 0))
 	return FALSE;
 
-    pScrPriv = (DamageScrPrivPtr) xalloc (sizeof (DamageScrPrivRec));
+    pScrPriv = (DamageScrPrivPtr) malloc (sizeof (DamageScrPrivRec));
     if (!pScrPriv)
 	return FALSE;
 
@@ -1818,7 +1818,7 @@ DamageCreate (DamageReportFunc  damageReport,
 {
     DamagePtr	pDamage;
 
-    pDamage = xalloc (sizeof (DamageRec));
+    pDamage = malloc (sizeof (DamageRec));
     if (!pDamage)
 	return 0;
     pDamage->pNext = 0;
diff --git a/nx-X11/programs/Xserver/os/Imakefile b/nx-X11/programs/Xserver/os/Imakefile
index 00d28deb1..802725306 100644
--- a/nx-X11/programs/Xserver/os/Imakefile
+++ b/nx-X11/programs/Xserver/os/Imakefile
@@ -91,11 +91,6 @@ COLOR_SRCS=oscolor.c
 COLOR_OBJS=oscolor.o
 #endif
 
-#if UseInternalMalloc
-MALLOC_SRCS=xalloc.c
-MALLOC_OBJS=xalloc.o
-#endif
-
 #if !HasSnprintf
 SNPRINTF_SRCS = snprintf.c
 SNPRINTF_OBJS = snprintf.o
@@ -119,19 +114,13 @@ BOOTSTRAPCFLAGS =
                   osinit.c utils.c log.c auth.c mitauth.c secauth.c \
                   $(XDMAUTHSRCS) $(RPCSRCS) xdmcp.c OtherSources \
                   transport.c $(SNPRINTF_SRCS) $(STRLCAT_SRCS) \
-		  $(MALLOC_SRCS) xprintf.c
+		  xprintf.c
            OBJS = WaitFor.o access.o connection.o io.o $(COLOR_OBJS) \
                   osinit.o utils.o log.o auth.o mitauth.o secauth.o \
                   $(XDMAUTHOBJS) $(RPCOBJS) xdmcp.o OtherObjects \
                   transport.o $(SNPRINTF_OBJS) $(STRLCAT_OBJS) \
-		  $(MALLOC_OBJS) xprintf.o
+		  xprintf.o
 
-#if SpecialMalloc
-     MEM_DEFINES = -DSPECIAL_MALLOC
-#endif /* SpecialMalloc */
-#if UseInternalMalloc
-     MEM_DEFINES = -DINTERNAL_MALLOC
-#endif
 #if UseMemLeak
      MEM_DEFINES = -DMEMBUG
 #endif
@@ -141,7 +130,6 @@ BOOTSTRAPCFLAGS =
     DBM_DEFINES = NdbmDefines
     ADM_DEFINES = -DADMPATH=\"$(ADMDIR)/X\%smsgs\"
   XDMCP_DEFINES = ServerXdmcpDefines
- XALLOC_DEFINES = XallocDefines
   ERROR_DEFINES = ServerErrorDefines
 #if HasPam && HasPamMisc
     PAM_DEFINES = -DUSE_PAM
@@ -189,7 +177,6 @@ SpecialCObjectRule(osinit,$(ICONFIGFILES),$(ADM_DEFINES))
 SpecialCObjectRule(WaitFor,$(ICONFIGFILES),$(EXT_DEFINES))
 SpecialCObjectRule(io,$(ICONFIGFILES),$(EXT_DEFINES))
 SpecialCObjectRule(utils,$(ICONFIGFILES),$(XDMCP_DEFINES) $(EXT_DEFINES) $(ERROR_DEFINES) $(PAM_DEFINES))
-SpecialCObjectRule(xalloc,$(ICONFIGFILES),$(XALLOC_DEFINES))
 #if defined(SparcArchitecture) && HasGcc && !HasGcc2
 oscolor.o: oscolor.c $(ICONFIGFILES)
 	$(RM) $@
diff --git a/nx-X11/programs/Xserver/os/WaitFor.c b/nx-X11/programs/Xserver/os/WaitFor.c
index f9037ed3b..0f23c9d4a 100644
--- a/nx-X11/programs/Xserver/os/WaitFor.c
+++ b/nx-X11/programs/Xserver/os/WaitFor.c
@@ -650,7 +650,7 @@ TimerSet(OsTimerPtr timer, int flags, CARD32 millis,
 
     if (!timer)
     {
-	timer = (OsTimerPtr)xalloc(sizeof(struct _OsTimerRec));
+	timer = (OsTimerPtr)malloc(sizeof(struct _OsTimerRec));
 	if (!timer)
 	    return NULL;
     }
diff --git a/nx-X11/programs/Xserver/os/access.c b/nx-X11/programs/Xserver/os/access.c
index dcd2b52af..4090a9589 100644
--- a/nx-X11/programs/Xserver/os/access.c
+++ b/nx-X11/programs/Xserver/os/access.c
@@ -256,7 +256,7 @@ typedef struct _host {
 	int		requested;
 } HOST;
 
-#define MakeHost(h,l)	(h)=(HOST *) xalloc(sizeof *(h)+(l));\
+#define MakeHost(h,l)	(h)=(HOST *) malloc(sizeof *(h)+(l));\
 			if (h) { \
 			   (h)->addr=(unsigned char *) ((h) + 1);\
 			   (h)->requested = FALSE; \
@@ -782,7 +782,7 @@ DefineSelf (int fd)
         Error ("Getting interface count");    
     if (len < (ifn.lifn_count * sizeof(struct lifreq))) {
 	len = ifn.lifn_count * sizeof(struct lifreq);
-	bufptr = xalloc(len);
+	bufptr = malloc(len);
     }
 #endif
     
@@ -1477,7 +1477,7 @@ LocalClientCredAndGroups(ClientPtr client, int *pUid, int *pGid,
 	const gid_t *gids;
 	*nSuppGids = ucred_getgroups(peercred, &gids);
 	if (*nSuppGids > 0) {
-	    *pSuppGids = xalloc(sizeof(int) * (*nSuppGids));
+	    *pSuppGids = malloc(sizeof(int) * (*nSuppGids));
 	    if (*pSuppGids == NULL) {
 		*nSuppGids = 0;
 	    } else {
@@ -1691,7 +1691,7 @@ GetHosts (
     }
     if (n)
     {
-        *data = ptr = (void *) xalloc (n);
+        *data = ptr = (void *) malloc (n);
 	if (!ptr)
 	{
 	    return(BadAlloc);
@@ -1951,7 +1951,7 @@ siTypeAdd(const char *typeName, siAddrMatchFunc addrMatch,
 	}
     }
 
-    s = (struct siType *) xalloc(sizeof(struct siType));
+    s = (struct siType *) malloc(sizeof(struct siType));
     if (s == NULL)
 	return BadAlloc;
 
@@ -2293,7 +2293,7 @@ static Bool
 siLocalCredGetId(const char *addr, int len, siLocalCredPrivPtr lcPriv, int *id)
 {
     Bool parsedOK = FALSE;
-    char *addrbuf = xalloc(len + 1);
+    char *addrbuf = malloc(len + 1);
 
     if (addrbuf == NULL) {
 	return FALSE;
diff --git a/nx-X11/programs/Xserver/os/connection.c b/nx-X11/programs/Xserver/os/connection.c
index 4d5826888..15321458e 100644
--- a/nx-X11/programs/Xserver/os/connection.c
+++ b/nx-X11/programs/Xserver/os/connection.c
@@ -261,7 +261,7 @@ void SetConnectionTranslation(int conn, int client)
             }
             node = &((*node)->next);
         }
-        *node = (struct _ct_node*)xalloc(sizeof(struct _ct_node));
+        *node = (struct _ct_node*)malloc(sizeof(struct _ct_node));
         (*node)->next = NULL;
         (*node)->key = conn;
         (*node)->value = client;
@@ -407,7 +407,7 @@ CreateWellKnownSockets(void)
 	}
 	else
 	{
-	    ListenTransFds = (int *) xalloc (ListenTransCount * sizeof (int));
+	    ListenTransFds = (int *) malloc (ListenTransCount * sizeof (int));
 
 	    for (i = 0; i < ListenTransCount; i++)
 	    {
@@ -764,7 +764,7 @@ AllocNewConnection (XtransConnInfo trans_conn, int fd, CARD32 conn_time)
 #endif
 	)
 	return NullClient;
-    oc = (OsCommPtr)xalloc(sizeof(OsCommRec));
+    oc = (OsCommPtr)malloc(sizeof(OsCommRec));
     if (!oc)
 	return NullClient;
     oc->trans_conn = trans_conn;
diff --git a/nx-X11/programs/Xserver/os/io.c b/nx-X11/programs/Xserver/os/io.c
index b8f05d939..3e9abb35c 100644
--- a/nx-X11/programs/Xserver/os/io.c
+++ b/nx-X11/programs/Xserver/os/io.c
@@ -1171,10 +1171,10 @@ AllocateInputBuffer(void)
 {
     ConnectionInputPtr oci;
 
-    oci = (ConnectionInputPtr)xalloc(sizeof(ConnectionInput));
+    oci = (ConnectionInputPtr)malloc(sizeof(ConnectionInput));
     if (!oci)
 	return (ConnectionInputPtr)NULL;
-    oci->buffer = (char *)xalloc(BUFSIZE);
+    oci->buffer = (char *)malloc(BUFSIZE);
     if (!oci->buffer)
     {
 	free(oci);
@@ -1192,10 +1192,10 @@ AllocateOutputBuffer(void)
 {
     ConnectionOutputPtr oco;
 
-    oco = (ConnectionOutputPtr)xalloc(sizeof(ConnectionOutput));
+    oco = (ConnectionOutputPtr)malloc(sizeof(ConnectionOutput));
     if (!oco)
 	return (ConnectionOutputPtr)NULL;
-    oco->buf = (unsigned char *) xalloc(BUFSIZE);
+    oco->buf = (unsigned char *) malloc(BUFSIZE);
     if (!oco->buf)
     {
 	free(oco);
diff --git a/nx-X11/programs/Xserver/os/log.c b/nx-X11/programs/Xserver/os/log.c
index 12827cbe0..d97317819 100644
--- a/nx-X11/programs/Xserver/os/log.c
+++ b/nx-X11/programs/Xserver/os/log.c
@@ -186,7 +186,7 @@ LogInit(const char *fname, const char *backup)
     char *logFileName = NULL;
 
     if (fname && *fname) {
-	/* xalloc() can't be used yet. */
+	/* malloc() can't be used yet. */
 	logFileName = malloc(strlen(fname) + strlen(display) + 1);
 	if (!logFileName)
 	    FatalError("Cannot allocate space for the log file name\n");
@@ -333,7 +333,7 @@ LogVWrite(int verb, const char *f, va_list args)
 	} else if (needBuffer) {
 	    /*
 	     * Note, this code is used before OsInit() has been called, so
-	     * xalloc() and friends can't be used.
+	     * malloc() and friends can't be used.
 	     */
 	    if (len > bufferUnused) {
 		bufferSize += 1024;
diff --git a/nx-X11/programs/Xserver/os/mitauth.c b/nx-X11/programs/Xserver/os/mitauth.c
index 4c1ae9cf6..2630a81ae 100644
--- a/nx-X11/programs/Xserver/os/mitauth.c
+++ b/nx-X11/programs/Xserver/os/mitauth.c
@@ -57,10 +57,10 @@ MitAddCookie (
 {
     struct auth	*new;
 
-    new = (struct auth *) xalloc (sizeof (struct auth));
+    new = (struct auth *) malloc (sizeof (struct auth));
     if (!new)
 	return 0;
-    new->data = (char *) xalloc ((unsigned) data_length);
+    new->data = (char *) malloc ((unsigned) data_length);
     if (!new->data) {
 	free(new);
 	return 0;
diff --git a/nx-X11/programs/Xserver/os/oscolor.c b/nx-X11/programs/Xserver/os/oscolor.c
index 8f737eaba..2ea81060d 100644
--- a/nx-X11/programs/Xserver/os/oscolor.c
+++ b/nx-X11/programs/Xserver/os/oscolor.c
@@ -134,11 +134,11 @@ OsLookupColor(int screen, char *name, unsigned int len,
     if(!rgb_dbm)
 	return(0);
 
-    /* we use xalloc here so that we can compile with cc without alloca
+    /* we use malloc here so that we can compile with cc without alloca
      * when otherwise using gcc */
     if (len < sizeof(buf))
 	lowername = buf;
-    else if (!(lowername = (char *)xalloc(len + 1)))
+    else if (!(lowername = (char *)malloc(len + 1)))
 	return(0);
     CopyISOLatin1Lowered ((unsigned char *) lowername, (unsigned char *) name,
 			  (int)len);
@@ -372,7 +372,7 @@ lookup(char *name, int len, Bool create)
   else
     prev = &(hashTab[h]);
 
-  if (!entry && create && (entry = (dbEntryPtr)xalloc(sizeof(dbEntry) +len)))
+  if (!entry && create && (entry = (dbEntryPtr)malloc(sizeof(dbEntry) +len)))
     {
       *prev = entry;
       entry->link = NULL;
diff --git a/nx-X11/programs/Xserver/os/rpcauth.c b/nx-X11/programs/Xserver/os/rpcauth.c
index 1b3db1e0e..40ea7ad97 100644
--- a/nx-X11/programs/Xserver/os/rpcauth.c
+++ b/nx-X11/programs/Xserver/os/rpcauth.c
@@ -77,7 +77,7 @@ authdes_ezdecode(char *inmsg, int len)
     XDR             xdr;
     SVCXPRT         xprt;
 
-    temp_inmsg = (char *) xalloc(len);
+    temp_inmsg = (char *) malloc(len);
     if (temp_inmsg == NULL) {
         why = AUTH_FAILED; /* generic error, since there is no AUTH_BADALLOC */
         return NULL;
@@ -94,7 +94,7 @@ authdes_ezdecode(char *inmsg, int len)
     why = AUTH_FAILED; 
     xdrmem_create(&xdr, temp_inmsg, len, XDR_DECODE);
 
-    if ((r.rq_clntcred = (caddr_t) xalloc(MAX_AUTH_BYTES)) == NULL)
+    if ((r.rq_clntcred = (caddr_t) malloc(MAX_AUTH_BYTES)) == NULL)
         goto bad1;
     r.rq_xprt = &xprt;
 
diff --git a/nx-X11/programs/Xserver/os/utils.c b/nx-X11/programs/Xserver/os/utils.c
index 03deb811a..98e3cab8b 100644
--- a/nx-X11/programs/Xserver/os/utils.c
+++ b/nx-X11/programs/Xserver/os/utils.c
@@ -261,12 +261,6 @@ int SyncOn  = 0;
 extern int SelectWaitTime;
 #endif
 
-#ifdef DEBUG
-#ifndef SPECIAL_MALLOC
-#define MEMBUG
-#endif
-#endif
-
 #if defined(SVR4) || defined(__linux__) || defined(CSRG_BASED)
 #define HAS_SAVED_IDS_AND_SETEUID
 #endif
@@ -1186,7 +1180,7 @@ InsertFileIntoCommandLine(
 
     fstat(fileno(f), &st);
 
-    buf = (char *) xalloc((unsigned) st.st_size + 1);
+    buf = (char *) malloc((unsigned) st.st_size + 1);
     if (!buf)
 	FatalError("Out of Memory\n");
 
@@ -1231,7 +1225,7 @@ InsertFileIntoCommandLine(
 	FatalError("Out of memory reallocing option buf\n");
 
     *resargc = prefix_argc + insert_argc + suffix_argc;
-    *resargv = (char **) xalloc((*resargc + 1) * sizeof(char *));
+    *resargv = (char **) malloc((*resargc + 1) * sizeof(char *));
     if (!*resargv)
 	FatalError("Out of Memory\n");
 
@@ -1316,7 +1310,7 @@ set_font_authorizations(char **authorizations, int *authlen, void * client)
 #endif
 
 	len = strlen(hnameptr) + 1;
-	result = xalloc(len + sizeof(AUTHORIZATION_NAME) + 4);
+	result = malloc(len + sizeof(AUTHORIZATION_NAME) + 4);
 
 	p = result;
         *p++ = sizeof(AUTHORIZATION_NAME) >> 8;
@@ -1517,7 +1511,7 @@ Xstrdup(const char *s)
     if (s == NULL)
 	return NULL;
 
-    sd = (char *)Xalloc(strlen(s) + 1);
+    sd = (char *)malloc(strlen(s) + 1);
     if (sd != NULL)
 	strcpy(sd, s);
     return sd;
@@ -1808,7 +1802,7 @@ Popen(char *command, char *type)
     if ((*type != 'r' && *type != 'w') || type[1])
 	return NULL;
 
-    if ((cur = (struct pid *)xalloc(sizeof(struct pid))) == NULL)
+    if ((cur = (struct pid *)malloc(sizeof(struct pid))) == NULL)
 	return NULL;
 
     if (pipe(pdes) < 0) {
@@ -1946,7 +1940,7 @@ Fopen(char *file, char *type)
     if ((*type != 'r' && *type != 'w') || type[1])
 	return NULL;
 
-    if ((cur = (struct pid *)xalloc(sizeof(struct pid))) == NULL)
+    if ((cur = (struct pid *)malloc(sizeof(struct pid))) == NULL)
 	return NULL;
 
     if (pipe(pdes) < 0) {
diff --git a/nx-X11/programs/Xserver/os/xalloc.c b/nx-X11/programs/Xserver/os/xalloc.c
deleted file mode 100644
index 4d2d3f1ee..000000000
--- a/nx-X11/programs/Xserver/os/xalloc.c
+++ /dev/null
@@ -1,817 +0,0 @@
-#define FATALERRORS 1
-/*
-Copyright (C) 1995 Pascal Haible.  All Rights Reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of this software and associated documentation files (the "Software"),
-to deal in the Software without restriction, including without limitation
-the rights to use, copy, modify, merge, publish, distribute, sublicense,
-and/or sell copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
-PASCAL HAIBLE BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
-OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-Except as contained in this notice, the name of Pascal Haible shall
-not be used in advertising or otherwise to promote the sale, use or other
-dealings in this Software without prior written authorization from
-Pascal Haible.
-*/
-
-/* $XFree86: xc/programs/Xserver/os/xalloc.c,v 3.35tsi Exp $ */
-
-/* Only used if INTERNAL_MALLOC is defined
- * - otherwise xalloc() in utils.c is used
- */
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#ifdef INTERNAL_MALLOC
-
-#include <stdlib.h>	/* for malloc() etc. */
-
-#include <nx-X11/Xos.h>
-#include "misc.h"
-#include <nx-X11/X.h>
-
-#ifdef XALLOC_LOG
-#include <stdio.h>
-#endif
-
-extern Bool Must_have_memory;
-
-/*
- ***** New malloc approach for the X server *****
- * Pascal Haible 1995
- *
- * Some statistics about memory allocation of the X server
- * The test session included several clients of different size, including
- * xv, emacs and xpaint with a new canvas of 3000x2000, zoom 5.
- * All clients were running together.
- * A protocolling version of Xalloc recorded 318917 allocating actions
- * (191573 Xalloc, 85942 XNFalloc, 41438 Xrealloc, 279727 Xfree).
- * Results grouped by size, excluding the next lower size
- * (i.e. size=32 means 16<size<=32):
- *
- *    size   nr of alloc   max nr of blocks allocated together
- *       8	1114		287
- *      16	17341		4104
- *      32	147352		2068
- *      64	59053		2518
- *     128	46882		1230
- *     256	20544		1217
- *     512	6808		117
- *    1024	8254		171
- *    2048	4841		287
- *    4096	2429		84
- *    8192	3364		85
- *   16384	573		22
- *   32768	49		7
- *   65536	45		5
- *  131072	48		2
- *  262144	209		2
- *  524288	7		4
- * 1048576	2		1
- * 8388608	2		2
- *
- * The most used sizes:
- * count size
- * 24	136267
- * 40	37055
- * 72	17278
- * 56	13504
- * 80	9372
- * 16	8966
- * 32	8411
- * 136	8399
- * 104	7690
- * 12	7630
- * 120	5512
- * 88	4634
- * 152	3062
- * 52	2881
- * 48	2736
- * 156	1569
- * 168	1487
- * 160	1483
- * 28	1446
- * 1608	1379
- * 184	1305
- * 552	1270
- * 64	934
- * 320	891
- * 8	754
- *
- * Conclusions: more than the half of all allocations are <= 32 bytes.
- * But of these about 150,000 blocks, only a maximum of about 6,000 are
- * allocated together (including memory leaks..).
- * On the other side, only 935 of the 191573 or 0.5% were larger than 8kB
- * (362 or 0.2% larger than 16k).
- *
- * What makes the server really grow is the fragmentation of the heap,
- * and the fact that it can't shrink.
- * To cure this, we do the following:
- * - large blocks (>=11k) are mmapped on xalloc, and unmapped on xfree,
- *   so we don't need any free lists etc.
- *   As this needs 2 system calls, we only do this for the quite
- *   infrequent large (>=11k) blocks.
- * - instead of reinventing the wheel, we use system malloc for medium
- *   sized blocks (>256, <11k).
- * - for small blocks (<=256) we use an other approach:
- *   As we need many small blocks, and most ones for a short time,
- *   we don't go through the system malloc:
- *   for each fixed sizes a seperate list of free blocks is kept.
- *   to KISS (Keep it Small and Simple), we don't free them
- *   (not freeing a block of 32 bytes won't be worse than having fragmented
- *   a larger area on allocation).
- *   This way, we (almost) allways have a fitting free block right at hand,
- *   and don't have to walk any lists.
- */
-
-/*
- * structure layout of a allocated block
- * unsigned long	size:
- *				rounded up netto size for small and medium blocks
- *				brutto size == mmap'ed area for large blocks
- * unsigned long	DEBUG ? MAGIC : unused
- * ....			data
- * ( unsigned long	MAGIC2 ) only if SIZE_TAIL defined
- *
- */
- 
-/* use otherwise unused long in the header to store a magic */
-/* shouldn't this be removed for production release ? */
-#define XALLOC_DEBUG
-
-#ifdef XALLOC_DEBUG
-/* Xfree fills the memory with a certain pattern (currently 0xF0) */
-/* this should really be removed for production release! */
-#define XFREE_ERASES
-#endif
-
-/* this must be a multiple of SIZE_STEPS below */
-#define MAX_SMALL 264		/* quite many blocks of 264 */
-
-#define MIN_LARGE (11*1024)
-/* worst case is 25% loss with a page size of 4k */
-
-/* SIZE_STEPS defines the granularity of size of small blocks -
- * this makes blocks align to that, too! */
-#define SIZE_STEPS		(sizeof(double))
-#define SIZE_HEADER		(2*sizeof(long)) /* = sizeof(double) for 32bit */
-#ifdef XALLOC_DEBUG
-#if defined(__sparc__)
-#define SIZE_TAIL		(2*sizeof(long)) /* = sizeof(double) for 32bit */
-#else
-#define SIZE_TAIL		(sizeof(long))
-#endif
-#endif
-
-#undef TAIL_SIZE
-#ifdef SIZE_TAIL
-#define TAIL_SIZE		SIZE_TAIL
-#else
-#define TAIL_SIZE		0
-#endif
-
-#if defined (_LP64) || \
-    defined(__alpha__) || defined(__alpha) || \
-    defined(__ia64__) || defined(ia64) || \
-    defined(__sparc64__) || \
-    defined(__s390x__) || \
-    defined(__amd64__) || defined(amd64) || \
-    defined(__powerpc64__) || \
-    (defined(sgi) && _MIPS_SZLONG == 64))
-#define MAGIC			0x1404196414071968
-#define MAGIC_FREE              0x1506196615061966
-#define MAGIC2			0x2515207525182079
-#else
-#define MAGIC			0x14071968
-#define MAGIC_FREE              0x15061966
-#define MAGIC2			0x25182079
-#endif
-
-/* To get some statistics about memory allocation */
-
-#ifdef XALLOC_LOG
-#define XALLOC_LOG_FILE "/tmp/Xalloc.log"	/* unsecure... */
-#define LOG_BODY(_body)					\
-		{ FILE *f;				\
-		  f = fopen(XALLOC_LOG_FILE, "a");	\
-		  if (NULL!=f) {			\
-			_body;				\
-			fclose(f);			\
-		  }					\
-		}
-#if defined(linux) && defined(i386)
-#define LOG_ALLOC(_fun, _size, _ret)						\
-	{	unsigned long *from;						\
-		__asm__("movl %%ebp,%0" : /*OUT*/ "=r" (from) : /*IN*/ );	\
-		LOG_BODY(fprintf(f, "%s\t%i\t%p\t[%lu]\n", _fun, _size, _ret, *(from+1))) \
-	}
-#else
-#define LOG_ALLOC(_fun, _size, _ret)				\
-	LOG_BODY(fprintf(f, "%s\t%i\t%p\n", _fun, _size, _ret))
-#endif
-#define LOG_REALLOC(_fun, _ptr, _size, _ret)			\
-	LOG_BODY(fprintf(f, "%s\t%p\t%i\t%p\n", _fun, _ptr, _size, _ret))
-#define LOG_FREE(_fun, _ptr)					\
-	LOG_BODY(fprintf(f, "%s\t%p\n", _fun, _ptr))
-#else
-#define LOG_ALLOC(_fun, _size, _ret)
-#define LOG_REALLOC(_fun, _ptr, _size, _ret)
-#define LOG_FREE(_fun, _ptr)
-#endif /* XALLOC_LOG */
-
-static unsigned long *free_lists[MAX_SMALL/SIZE_STEPS];
-
-/*
- * systems that support it should define HAS_MMAP_ANON or MMAP_DEV_ZERO
- * and include the appropriate header files for
- * mmap(), munmap(), PROT_READ, PROT_WRITE, MAP_PRIVATE,
- * PAGE_SIZE or _SC_PAGESIZE (and MAP_ANON for HAS_MMAP_ANON).
- *
- * systems that don't support MAP_ANON fall through to the 2 fold behaviour
- */
-
-#if defined(linux)
-#define HAS_MMAP_ANON
-#include <sys/types.h>
-#include <sys/mman.h>
-#include <asm/page.h>	/* PAGE_SIZE */
-#define HAS_SC_PAGESIZE	/* _SC_PAGESIZE may be an enum for Linux */
-#define HAS_GETPAGESIZE
-#endif /* linux */
-
-#if defined(__GNU__)
-#define HAS_MMAP_ANON
-#include <sys/types.h>
-#include <sys/mman.h>
-#include <mach/vm_param.h>     /* PAGE_SIZE */
-#define HAS_SC_PAGESIZE
-#define HAS_GETPAGESIZE
-#endif /* __GNU__ */
-
-#if defined(CSRG_BASED)
-#define HAS_MMAP_ANON
-#define HAS_GETPAGESIZE
-#include <sys/types.h>
-#include <sys/mman.h>
-#endif /* CSRG_BASED */
-
-#if defined(DGUX)
-#define HAS_GETPAGESIZE
-#define MMAP_DEV_ZERO
-#include <sys/types.h>
-#include <sys/mman.h>
-#include <unistd.h>
-#endif /* DGUX */
-
-#if defined(SVR4) && !defined(DGUX)
-#define MMAP_DEV_ZERO
-#include <sys/types.h>
-#include <sys/mman.h>
-#include <unistd.h>
-#endif /* SVR4 && !DGUX */
-
-#if defined(sun) && !defined(SVR4) /* SunOS */
-#define MMAP_DEV_ZERO	/* doesn't SunOS have MAP_ANON ?? */
-#define HAS_GETPAGESIZE
-#include <sys/types.h>
-#include <sys/mman.h>
-#endif /* sun && !SVR4 */
-
-#ifdef XNO_SYSCONF
-#undef _SC_PAGESIZE
-#endif
-
-#if defined(HAS_MMAP_ANON) || defined (MMAP_DEV_ZERO)
-static int pagesize;
-#endif
-
-#ifdef MMAP_DEV_ZERO
-static int devzerofd = -1;
-#include <errno.h>
-#endif
-
-/*
- * empty trap function for gdb. Breakpoint here
- * to find who tries to free a free area
- */
-void XfreeTrap(void)
-{
-}
-
-void *
-Xalloc (unsigned long amount)
-{
-    register unsigned long *ptr;
-    int indx;
-
-    /* sanity checks */
-
-    /* zero size requested */
-    if (amount == 0) {
-	LOG_ALLOC("Xalloc=0", amount, 0);
-	return NULL;
-    }
-    /* negative size (or size > 2GB) - what do we do? */
-    if ((long)amount < 0) {
-	/* Diagnostic */
-#ifdef FATALERRORS
- 	FatalError("Xalloc: Xalloc(<0)\n");
-#else
- 	ErrorF("Xalloc warning: Xalloc(<0) ignored..\n");
-#endif
- 	LOG_ALLOC("Xalloc<0", amount, 0);
-	return NULL;
-    }
-
-    /* alignment check */
-#if defined(__alpha__) || defined(__alpha) || \
-    defined(__sparc__) || \
-    defined(__mips__) || \
-    defined(__powerpc__) || \
-    defined(__arm32__) || \
-    defined(__ia64__) || defined(ia64) || \
-    defined(__s390x__) || defined(__s390__)
-    amount = (amount + (sizeof(long)-1)) & ~(sizeof(long)-1);
-#endif
-
-    if (amount <= MAX_SMALL) {
-	/*
-	 * small block
-	 */
-	/* pick a ready to use small chunk */
-	indx = (amount-1) / SIZE_STEPS;
-	ptr = free_lists[indx];
-	if (NULL == ptr) {
-		/* list empty - get 20 or 40 more */
-		/* amount = size rounded up */
-		amount = (indx+1) * SIZE_STEPS;
-		ptr = (unsigned long *)calloc(1,(amount+SIZE_HEADER+TAIL_SIZE)
-						* (amount<100 ? 40 : 20));
-		if (NULL!=ptr) {
-			int i;
-			unsigned long *p1, *p2;
-			p1 = 0;
-			p2 = (unsigned long *)((char *)ptr + SIZE_HEADER);
-			for (i=0; i<(amount<100 ? 40 : 20); i++) {
-				p1 = p2;
-				p1[-2] = amount;
-#ifdef XALLOC_DEBUG
-				p1[-1] = MAGIC_FREE;
-#endif /* XALLOC_DEBUG */
-#ifdef SIZE_TAIL
-				*(unsigned long *)((unsigned char *)p1 + amount) = MAGIC2;
-#endif /* SIZE_TAIL */
-				p2 = (unsigned long *)((char *)p1 + SIZE_HEADER + amount + TAIL_SIZE);
-				*(unsigned long **)p1 = p2;
-			}
-			/* last one has no next one */
-			*(unsigned long **)p1 = NULL;
-			/* put the second in the list */
-			free_lists[indx] = (unsigned long *)((char *)ptr + SIZE_HEADER + amount + TAIL_SIZE + SIZE_HEADER);
-			/* take the fist one */
-			ptr = (unsigned long *)((char *)ptr + SIZE_HEADER);
-			LOG_ALLOC("Xalloc-S", amount, ptr);
-			ptr[-1] = MAGIC;
-			return (void *)ptr;
-		} /* else fall through to 'Out of memory' */
-	} else {
-		/* take that piece of mem out of the list */
-		free_lists[indx] = *((unsigned long **)ptr);
-		/* already has size (and evtl. magic) filled in */
-#ifdef XALLOC_DEBUG
-		ptr[-1] = MAGIC;
-#endif /* XALLOC_DEBUG */
-		LOG_ALLOC("Xalloc-S", amount, ptr);
-		return (void *)ptr;
-	}
-
-#if defined(HAS_MMAP_ANON) || defined(MMAP_DEV_ZERO)
-    } else if (amount >= MIN_LARGE) {
-	/*
-	 * large block
-	 */
-	/* mmapped malloc */
-	/* round up amount */
-	amount += SIZE_HEADER + TAIL_SIZE;
-	/* round up brutto amount to a multiple of the page size */
-	amount = (amount + pagesize-1) & ~(pagesize-1);
-#ifdef MMAP_DEV_ZERO
-	ptr = (unsigned long *)mmap((caddr_t)0,
-					(size_t)amount,
-					PROT_READ | PROT_WRITE,
-					MAP_PRIVATE,
-					devzerofd,
-					(off_t)0);
-#else
-	ptr = (unsigned long *)mmap((caddr_t)0,
-					(size_t)amount,
-					PROT_READ | PROT_WRITE,
-					MAP_ANON | MAP_PRIVATE,
-					-1,
-					(off_t)0);
-#endif
-	if (-1!=(long)ptr) {
-		ptr[0] = amount - SIZE_HEADER - TAIL_SIZE;
-#ifdef XALLOC_DEBUG
-		ptr[1] = MAGIC;
-#endif /* XALLOC_DEBUG */
-#ifdef SIZE_TAIL
-		((unsigned long *)((char *)ptr + amount - TAIL_SIZE))[0] = MAGIC2;
-#endif /* SIZE_TAIL */
-		ptr = (unsigned long *)((char *)ptr + SIZE_HEADER);
-		LOG_ALLOC("Xalloc-L", amount, ptr);
-		return (void *)ptr;
-	} /* else fall through to 'Out of memory' */
-#endif /* HAS_MMAP_ANON || MMAP_DEV_ZERO */
-    } else {
-	/*
-	 * medium sized block
-	 */
-	/* 'normal' malloc() */
-	ptr=(unsigned long *)calloc(1,amount+SIZE_HEADER+TAIL_SIZE);
-	if (ptr != (unsigned long *)NULL) {
-		ptr[0] = amount;
-#ifdef XALLOC_DEBUG
-		ptr[1] = MAGIC;
-#endif /* XALLOC_DEBUG */
-#ifdef SIZE_TAIL
-		*(unsigned long *)((char *)ptr + amount + SIZE_HEADER) = MAGIC2;
-#endif /* SIZE_TAIL */
-		ptr = (unsigned long *)((char *)ptr + SIZE_HEADER);
-		LOG_ALLOC("Xalloc-M", amount, ptr);
-		return (void *)ptr;
-	}
-    }
-    if (Must_have_memory)
-	FatalError("Out of memory");
-    LOG_ALLOC("Xalloc-oom", amount, 0);
-    return NULL;
-}
-
-/*****************
- * XNFalloc 
- * "no failure" realloc, alternate interface to Xalloc w/o Must_have_memory
- *****************/
-
-void *
-XNFalloc (unsigned long amount)
-{
-    register void * ptr;
-
-    /* zero size requested */
-    if (amount == 0) {
-	LOG_ALLOC("XNFalloc=0", amount, 0);
-	return NULL;
-    }
-    /* negative size (or size > 2GB) - what do we do? */
-    if ((long)amount < 0) {
-	/* Diagnostic */
-#ifdef FATALERRORS
-	FatalError("Xalloc: XNFalloc(<0)\n");
-#else
-	ErrorF("Xalloc warning: XNFalloc(<0) ignored..\n");
-#endif
- 	LOG_ALLOC("XNFalloc<0", amount, 0);
-	return (unsigned long *)NULL;
-    }
-    ptr = Xalloc(amount);
-    if (!ptr)
-    {
-        FatalError("Out of memory");
-    }
-    return ptr;
-}
-
-/*****************
- * Xcalloc
- *****************/
-
-void *
-Xcalloc (unsigned long amount)
-{
-    void * ret;
-
-    ret = Xalloc (amount);
-    if (ret != 0
-#if defined(HAS_MMAP_ANON) || defined(MMAP_DEV_ZERO)
-	    && (amount < MIN_LARGE)	/* mmaped anonymous mem is already cleared */
-#endif
-       )
-	bzero ((char *) ret, (int) amount);
-    return ret;
-}
-
-/*****************
- * XNFcalloc
- *****************/
-void *
-XNFcalloc (unsigned long amount)
-{
-    void * ret;
-
-    ret = XNFalloc (amount);
-    if (ret != 0
-#if defined(HAS_MMAP_ANON) || defined(MMAP_DEV_ZERO)
-	    && (amount < MIN_LARGE)	/* mmaped anonymous mem is already cleared */
-#endif
-       )
-	bzero ((char *) ret, (int) amount);
-    return ret;
-}
-
-/*****************
- * Xrealloc
- *****************/
-
-void *
-Xrealloc (void * ptr, unsigned long amount)
-{
-    register unsigned long *new_ptr;
-
-    /* zero size requested */
-    if (amount == 0) {
-	if (ptr)
-		Xfree(ptr);
-	LOG_REALLOC("Xrealloc=0", ptr, amount, 0);
-	return NULL;
-    }
-    /* negative size (or size > 2GB) - what do we do? */
-    if ((long)amount < 0) {
-	/* Diagnostic */
-#ifdef FATALERRORS
-	FatalError("Xalloc: Xrealloc(<0)\n");
-#else
-	ErrorF("Xalloc warning: Xrealloc(<0) ignored..\n");
-#endif
-	if (ptr)
-		Xfree(ptr);	/* ?? */
-	LOG_REALLOC("Xrealloc<0", ptr, amount, 0);
-	return NULL;
-    }
-
-    new_ptr = Xalloc(amount);
-    if ( (new_ptr) && (ptr) ) {
-	unsigned long old_size;
-	old_size = ((unsigned long *)ptr)[-2];
-#ifdef XALLOC_DEBUG
-	if (MAGIC != ((unsigned long *)ptr)[-1]) {
-	    if (MAGIC_FREE == ((unsigned long *)ptr)[-1]) {
-#ifdef FATALERRORS
-		XfreeTrap();
-		FatalError("Xalloc error: range already freed in Xrealloc() :-(\n");
-#else
-		ErrorF("Xalloc error: range already freed in Xrealloc() :-(\a\n");
-		sleep(5);
-		XfreeTrap();
-#endif
-		LOG_REALLOC("Xalloc error: ranged already freed in Xrealloc() :-(",
-			ptr, amount, 0);
-		return NULL;
-	    }
-#ifdef FATALERRORS
-	    XfreeTrap();
-		FatalError("Xalloc error: header corrupt in Xrealloc() :-(\n");
-#else
-		ErrorF("Xalloc error: header corrupt in Xrealloc() :-(\n");
-		XfreeTrap();
-#endif
-		LOG_REALLOC("Xalloc error: header corrupt in Xrealloc() :-(",
-			ptr, amount, 0);
-		return NULL;
-	}
-#endif /* XALLOC_DEBUG */
-	/* copy min(old size, new size) */
-	memcpy((char *)new_ptr, (char *)ptr, (amount < old_size ? amount : old_size));
-    }
-    if (ptr)
-	Xfree(ptr);
-    if (new_ptr) {
-	LOG_REALLOC("Xrealloc", ptr, amount, new_ptr);
-	return (void *)new_ptr;
-    }
-    if (Must_have_memory)
-	FatalError("Out of memory");
-    LOG_REALLOC("Xrealloc", ptr, amount, 0);
-    return NULL;
-}
-                    
-/*****************
- * XNFrealloc 
- * "no failure" realloc, alternate interface to Xrealloc w/o Must_have_memory
- *****************/
-
-void *
-XNFrealloc (void * ptr, unsigned long amount)
-{
-    if (( ptr = (void *)Xrealloc( ptr, amount ) ) == NULL)
-    {
-        FatalError( "Out of memory" );
-    }
-    return ptr;
-}
-
-/*****************
- *  Xfree
- *    calls free 
- *****************/    
-
-void
-Xfree(void * ptr)
-{
-    unsigned long size;
-    unsigned long *pheader;
-
-    /* free(NULL) IS valid :-(  - and widely used throughout the server.. */
-    if (!ptr)
-	return;
-
-    pheader = (unsigned long *)((char *)ptr - SIZE_HEADER);
-#ifdef XALLOC_DEBUG
-    if (MAGIC != pheader[1]) {
-	/* Diagnostic */
-	if (MAGIC_FREE == pheader[1]) {
-#ifdef FATALERRORS
-	    XfreeTrap();
-	    FatalError("Xalloc error: range already freed in Xrealloc() :-(\n");
-#else
-	    ErrorF("Xalloc error: range already freed in Xrealloc() :-(\a\n");
-	    sleep(5);
-	    XfreeTrap();
-#endif
-	    LOG_FREE("Xalloc error: ranged already freed in Xrealloc() :-(", ptr);
-	    return;
-	}
-#ifdef FATALERRORS
-	XfreeTrap();
-	FatalError("Xalloc error: Header corrupt in Xfree() :-(\n");
-#else
-	ErrorF("Xalloc error: Header corrupt in Xfree() :-(\n");
-	XfreeTrap();
-#endif
-	LOG_FREE("Xalloc error:  Header corrupt in Xfree() :-(", ptr);
-	return;
-    }
-#endif /* XALLOC_DEBUG */
-
-    size = pheader[0];
-    if (size <= MAX_SMALL) {
-	int indx;
-	/*
-	 * small block
-	 */
-#ifdef SIZE_TAIL
-	if (MAGIC2 != *(unsigned long *)((char *)ptr + size)) {
-		/* Diagnostic */
-#ifdef FATALERRORS
-	    	XfreeTrap();
-		FatalError("Xalloc error: Tail corrupt in Xfree() for small block (adr=0x%x, val=0x%x)\n",(char *)ptr + size,*(unsigned long *)((char *)ptr + size));
-#else
-		ErrorF("Xalloc error: Tail corrupt in Xfree() for small block (adr=0x%x, val=0x%x)\n",(char *)ptr + size,*(unsigned long *)((char *)ptr + size));
-		XfreeTrap();
-#endif
-		LOG_FREE("Xalloc error: Tail corrupt in Xfree() for small block", ptr);
-		return;
-	}
-#endif /* SIZE_TAIL */
-
-#ifdef XFREE_ERASES
-	memset(ptr,0xF0,size);
-#endif /* XFREE_ERASES */
-#ifdef XALLOC_DEBUG
-	pheader[1] = MAGIC_FREE;
-#endif
-	/* put this small block at the head of the list */
-	indx = (size-1) / SIZE_STEPS;
-	*(unsigned long **)(ptr) = free_lists[indx];
-	free_lists[indx] = (unsigned long *)ptr;
-	LOG_FREE("Xfree", ptr);
-	return;
-
-#if defined(HAS_MMAP_ANON) || defined(MMAP_DEV_ZERO)
-    } else if (size >= MIN_LARGE) {
-	/*
-	 * large block
-	 */
-#ifdef SIZE_TAIL
-	if (MAGIC2 != ((unsigned long *)((char *)ptr + size))[0]) {
-		/* Diagnostic */
-#ifdef FATALERRORS
-	    XfreeTrap();
-		FatalError("Xalloc error: Tail corrupt in Xfree() for big block (adr=0x%x, val=0x%x)\n",(char *)ptr+size,((unsigned long *)((char *)ptr + size))[0]);
-#else
-		ErrorF("Xalloc error: Tail corrupt in Xfree() for big block (adr=0x%x, val=0x%x)\n",(char *)ptr+size,((unsigned long *)((char *)ptr + size))[0]);
-		XfreeTrap();
-#endif
-		LOG_FREE("Xalloc error: Tail corrupt in Xfree() for big block", ptr);
-		return;
-	}
-	size += SIZE_TAIL;
-#endif /* SIZE_TAIL */
-
-	LOG_FREE("Xfree", ptr);
-	size += SIZE_HEADER;
-	munmap((caddr_t)pheader, (size_t)size);
-	/* no need to clear - mem is inaccessible after munmap.. */
-#endif /* HAS_MMAP_ANON */
-
-    } else {
-	/*
-	 * medium sized block
-	 */
-#ifdef SIZE_TAIL
-	if (MAGIC2 != *(unsigned long *)((char *)ptr + size)) {
-		/* Diagnostic */
-#ifdef FATALERRORS
-	    XfreeTrap();
-		FatalError("Xalloc error: Tail corrupt in Xfree() for medium block (adr=0x%x, val=0x%x)\n",(char *)ptr + size,*(unsigned long *)((char *)ptr + size));
-#else
-		ErrorF("Xalloc error: Tail corrupt in Xfree() for medium block (adr=0x%x, val=0x%x)\n",(char *)ptr + size,*(unsigned long *)((char *)ptr + size));
-		XfreeTrap();
-#endif
-		LOG_FREE("Xalloc error: Tail corrupt in Xfree() for medium block", ptr);
-		return;
-	}
-#endif /* SIZE_TAIL */
-
-#ifdef XFREE_ERASES
-	memset(pheader,0xF0,size+SIZE_HEADER);
-#endif /* XFREE_ERASES */
-#ifdef XALLOC_DEBUG
-	pheader[1] = MAGIC_FREE;
-#endif
-
-	LOG_FREE("Xfree", ptr);
-	free((char *)pheader);
-    }
-}
-
-void
-OsInitAllocator (void)
-{
-    static Bool beenhere = FALSE;
-
-    if (beenhere)
-	return;
-    beenhere = TRUE;
-
-#if defined(HAS_MMAP_ANON) || defined (MMAP_DEV_ZERO)
-    pagesize = -1;
-#if defined(_SC_PAGESIZE) || defined(HAS_SC_PAGESIZE)
-    pagesize = sysconf(_SC_PAGESIZE);
-#endif
-#ifdef _SC_PAGE_SIZE
-    if (pagesize == -1)
-	pagesize = sysconf(_SC_PAGE_SIZE);
-#endif
-#ifdef HAS_GETPAGESIZE
-    if (pagesize == -1)
-	pagesize = getpagesize();
-#endif
-#ifdef PAGE_SIZE
-    if (pagesize == -1)
-	pagesize = PAGE_SIZE;
-#endif
-    if (pagesize == -1)
-	FatalError("OsInitAllocator: Cannot determine page size\n");
-#endif
-
-    /* set up linked lists of free blocks */
-    bzero ((char *) free_lists, MAX_SMALL/SIZE_STEPS*sizeof(unsigned long *));
-
-#ifdef MMAP_DEV_ZERO
-    /* open /dev/zero on systems that have mmap, but not MAP_ANON */
-    if (devzerofd < 0) {
-	if ((devzerofd = open("/dev/zero", O_RDWR, 0)) < 0)
-	    FatalError("OsInitAllocator: Cannot open /dev/zero (errno=%d)\n",
-			errno);
-    }
-#endif
-
-#ifdef XALLOC_LOG
-    /* reset the log file to zero length */
-    {
-	FILE *f;
-	f = fopen(XALLOC_LOG_FILE, "w");
-	if (NULL!=f)
-		fclose(f);
-    }
-#endif
-}
-
-#else /* !INTERNAL_MALLOC */
-/* This is to avoid an empty .o */
-static int no_internal_xalloc;
-#endif /* INTERNAL_MALLOC */
diff --git a/nx-X11/programs/Xserver/os/xdmauth.c b/nx-X11/programs/Xserver/os/xdmauth.c
index b55f75a36..a89c5b0c0 100644
--- a/nx-X11/programs/Xserver/os/xdmauth.c
+++ b/nx-X11/programs/Xserver/os/xdmauth.c
@@ -260,7 +260,7 @@ XdmAuthorizationValidate (unsigned char *plain, int length,
 	    *reason = "Bad XDM authorization key length";
 	return NULL;
     }
-    client = (XdmClientAuthPtr) xalloc (sizeof (XdmClientAuthRec));
+    client = (XdmClientAuthPtr) malloc (sizeof (XdmClientAuthRec));
     if (!client)
 	return NULL;
     XdmClientAuthDecode (plain, client);
@@ -364,7 +364,7 @@ XdmAddCookie (unsigned short data_length, char *data, XID id)
     /* the first octet of the key must be zero */
     if (key_bits[0] != '\0')
 	return 0;
-    new = (XdmAuthorizationPtr) xalloc (sizeof (XdmAuthorizationRec));
+    new = (XdmAuthorizationPtr) malloc (sizeof (XdmAuthorizationRec));
     if (!new)
 	return 0;
     new->next = xdmAuth;
@@ -386,7 +386,7 @@ XdmCheckCookie (unsigned short cookie_length, char *cookie,
     /* Auth packets must be a multiple of 8 bytes long */
     if (cookie_length & 7)
 	return (XID) -1;
-    plain = (unsigned char *) xalloc (cookie_length);
+    plain = (unsigned char *) malloc (cookie_length);
     if (!plain)
 	return (XID) -1;
     for (auth = xdmAuth; auth; auth=auth->next) {
@@ -431,7 +431,7 @@ XdmToID (unsigned short cookie_length, char *cookie)
     XdmClientAuthPtr	client;
     unsigned char	*plain;
 
-    plain = (unsigned char *) xalloc (cookie_length);
+    plain = (unsigned char *) malloc (cookie_length);
     if (!plain)
 	return (XID) -1;
     for (auth = xdmAuth; auth; auth=auth->next) {
diff --git a/nx-X11/programs/Xserver/os/xdmcp.c b/nx-X11/programs/Xserver/os/xdmcp.c
index 29785f48e..d48012759 100644
--- a/nx-X11/programs/Xserver/os/xdmcp.c
+++ b/nx-X11/programs/Xserver/os/xdmcp.c
@@ -407,7 +407,7 @@ XdmcpRegisterAuthentication (
 				     AuthenticationNames.length + 1) &&
 	  XdmcpReallocARRAYofARRAY8 (&AuthenticationDatas,
 				     AuthenticationDatas.length + 1) &&
-	  (newFuncs = (AuthenticationFuncsPtr) xalloc (
+	  (newFuncs = (AuthenticationFuncsPtr) malloc (
 			(AuthenticationNames.length + 1) * sizeof (AuthenticationFuncsRec)))))
     {
 	XdmcpDisposeARRAY8 (&AuthenticationName);
@@ -507,7 +507,7 @@ XdmcpRegisterConnection (
 	    return;
 	}
     }
-    newAddress = (CARD8 *) xalloc (addrlen * sizeof (CARD8));
+    newAddress = (CARD8 *) malloc (addrlen * sizeof (CARD8));
     if (!newAddress)
 	return;
     if (!XdmcpReallocARRAY16 (&ConnectionTypes, ConnectionTypes.length + 1))
@@ -548,7 +548,7 @@ XdmcpRegisterAuthorization (char *name, int namelen)
     ARRAY8  authName;
     int	    i;
 
-    authName.data = (CARD8 *) xalloc (namelen * sizeof (CARD8));
+    authName.data = (CARD8 *) malloc (namelen * sizeof (CARD8));
     if (!authName.data)
 	return;
     if (!XdmcpReallocARRAYofARRAY8 (&AuthorizationNames, AuthorizationNames.length +1))
diff --git a/nx-X11/programs/Xserver/os/xprintf.c b/nx-X11/programs/Xserver/os/xprintf.c
index 4423208ff..1bcb36d3c 100644
--- a/nx-X11/programs/Xserver/os/xprintf.c
+++ b/nx-X11/programs/Xserver/os/xprintf.c
@@ -1,5 +1,5 @@
 /* 
- * printf routines which xalloc their buffer
+ * printf routines which malloc their buffer
  */ 
 /*
  * Copyright (c) 2004 Alexander Gottwald
@@ -111,7 +111,7 @@ Xvprintf(const char *format, va_list va)
     size = vsnprintf(NULL, 0, format, va2);
     va_end(va2);
 
-    ret = (char *)Xalloc(size + 1);
+    ret = (char *)malloc(size + 1);
     if (ret == NULL)
         return NULL;
 
diff --git a/nx-X11/programs/Xserver/randr/rrcrtc.c b/nx-X11/programs/Xserver/randr/rrcrtc.c
index 6fb6e02e6..e7add9d60 100644
--- a/nx-X11/programs/Xserver/randr/rrcrtc.c
+++ b/nx-X11/programs/Xserver/randr/rrcrtc.c
@@ -90,7 +90,7 @@ RRCrtcCreate(ScreenPtr pScreen, void *devPrivate)
                          (pScrPriv->numCrtcs + 1) * sizeof(RRCrtcPtr));
 #endif                          /* !defined(NXAGENT_SERVER) */
     else
-        crtcs = xalloc(sizeof(RRCrtcPtr));
+        crtcs = malloc(sizeof(RRCrtcPtr));
     if (!crtcs)
         return FALSE;
     pScrPriv->crtcs = crtcs;
@@ -209,7 +209,7 @@ RRCrtcNotify(RRCrtcPtr crtc,
 #ifndef NXAGENT_SERVER
                 newoutputs = xallocarray(numOutputs, sizeof(RROutputPtr));
 #else                           /* !defined(NXAGENT_SERVER) */
-                newoutputs = xalloc(numOutputs * sizeof(RROutputPtr));
+                newoutputs = malloc(numOutputs * sizeof(RROutputPtr));
 #endif                          /* !defined(NXAGENT_SERVER) */
             if (!newoutputs)
                 return FALSE;
@@ -892,7 +892,7 @@ RRCrtcGammaSetSize(RRCrtcPtr crtc, int size)
 #ifndef NXAGENT_SERVER
         gamma = xallocarray(size, 3 * sizeof(CARD16));
 #else                           /* !defined(NXAGENT_SERVER) */
-        gamma = xalloc(size * 3 * sizeof(CARD16));
+        gamma = malloc(size * 3 * sizeof(CARD16));
 #endif                          /* !defined(NXAGENT_SERVER) */
         if (!gamma)
             return FALSE;
@@ -1047,7 +1047,7 @@ ProcRRGetCrtcInfo(ClientPtr client)
 
     extraLen = rep.length << 2;
     if (extraLen) {
-        extra = xalloc(extraLen);
+        extra = malloc(extraLen);
         if (!extra)
             return BadAlloc;
     }
@@ -1136,7 +1136,7 @@ ProcRRSetCrtcConfig(ClientPtr client)
 #ifndef NXAGENT_SERVER
         outputs = xallocarray(numOutputs, sizeof(RROutputPtr));
 #else                           /* !defined(NXAGENT_SERVER) */
-        outputs = xalloc(numOutputs * sizeof(RROutputPtr));
+        outputs = malloc(numOutputs * sizeof(RROutputPtr));
 #endif                          /* !defined(NXAGENT_SERVER) */
         if (!outputs)
             return BadAlloc;
@@ -1514,7 +1514,7 @@ ProcRRGetCrtcGamma(ClientPtr client)
     len = crtc->gammaSize * 3 * 2;
 
     if (crtc->gammaSize) {
-        extra = xalloc(len);
+        extra = malloc(len);
         if (!extra)
             return BadAlloc;
     }
@@ -1825,7 +1825,7 @@ RRReplaceScanoutPixmap(DrawablePtr pDrawable, PixmapPtr pPixmap, Bool enable)
     PixmapPtr *saved_scanout_pixmap;
     int i;
 
-    saved_scanout_pixmap = xalloc(sizeof(PixmapPtr) * pScrPriv->numCrtcs);
+    saved_scanout_pixmap = malloc(sizeof(PixmapPtr) * pScrPriv->numCrtcs);
     if (saved_scanout_pixmap == NULL)
         return FALSE;
 
diff --git a/nx-X11/programs/Xserver/randr/rrdispatch.c b/nx-X11/programs/Xserver/randr/rrdispatch.c
index 271d5d939..50f2011c6 100644
--- a/nx-X11/programs/Xserver/randr/rrdispatch.c
+++ b/nx-X11/programs/Xserver/randr/rrdispatch.c
@@ -125,7 +125,7 @@ ProcRRSelectInput(ClientPtr client)
 
         if (!pRREvent) {
             /* build the entry */
-            pRREvent = (RREventPtr) xalloc(sizeof(RREventRec));
+            pRREvent = (RREventPtr) malloc(sizeof(RREventRec));
             if (!pRREvent)
                 return BadAlloc;
             pRREvent->next = 0;
@@ -147,7 +147,7 @@ ProcRRSelectInput(ClientPtr client)
              * done through the resource database.
              */
             if (!pHead) {
-                pHead = (RREventPtr *) xalloc(sizeof(RREventPtr));
+                pHead = (RREventPtr *) malloc(sizeof(RREventPtr));
                 if (!pHead ||
                     !AddResource(pWin->drawable.id, RREventType,
                                  (void *) pHead)) {
diff --git a/nx-X11/programs/Xserver/randr/rrinfo.c b/nx-X11/programs/Xserver/randr/rrinfo.c
index 4c47fb903..c5075572f 100644
--- a/nx-X11/programs/Xserver/randr/rrinfo.c
+++ b/nx-X11/programs/Xserver/randr/rrinfo.c
@@ -63,7 +63,7 @@ RROldModeAdd(RROutputPtr output, RRScreenSizePtr size, int refresh)
                          (output->numModes + 1) * sizeof(RRModePtr));
 #endif                          /* !defined(NXAGENT_SERVER) */
     else
-        modes = xalloc(sizeof(RRModePtr));
+        modes = malloc(sizeof(RRModePtr));
     if (!modes) {
         RRModeDestroy(mode);
         FreeResource(mode->mode.id, 0);
diff --git a/nx-X11/programs/Xserver/randr/rrmode.c b/nx-X11/programs/Xserver/randr/rrmode.c
index 3d84a0516..e8dd208a1 100644
--- a/nx-X11/programs/Xserver/randr/rrmode.c
+++ b/nx-X11/programs/Xserver/randr/rrmode.c
@@ -85,7 +85,7 @@ RRModeCreate(xRRModeInfo * modeInfo, const char *name, ScreenPtr userScreen)
     if (!RRInit())
         return NULL;
 
-    mode = xalloc(sizeof(RRModeRec) + modeInfo->nameLength + 1);
+    mode = malloc(sizeof(RRModeRec) + modeInfo->nameLength + 1);
     if (!mode)
         return NULL;
     mode->refcnt = 1;
@@ -103,7 +103,7 @@ RRModeCreate(xRRModeInfo * modeInfo, const char *name, ScreenPtr userScreen)
 #endif                          /* !defined(NXAGENT_SERVER) */
 
     else
-        newModes = xalloc(sizeof(RRModePtr));
+        newModes = malloc(sizeof(RRModePtr));
 
     if (!newModes) {
         free(mode);
@@ -211,7 +211,7 @@ RRModesForScreen(ScreenPtr pScreen, int *num_ret)
 #ifndef NXAGENT_SERVER
     screen_modes = xallocarray((num_modes ? num_modes : 1), sizeof(RRModePtr));
 #else                           /* !defined(NXAGENT_SERVER) */
-    screen_modes = xalloc((num_modes ? num_modes : 1) * sizeof(RRModePtr));
+    screen_modes = malloc((num_modes ? num_modes : 1) * sizeof(RRModePtr));
 #endif                          /* !defined(NXAGENT_SERVER) */
     if (!screen_modes)
         return NULL;
diff --git a/nx-X11/programs/Xserver/randr/rrmonitor.c b/nx-X11/programs/Xserver/randr/rrmonitor.c
index 36543cb4c..0e5514415 100644
--- a/nx-X11/programs/Xserver/randr/rrmonitor.c
+++ b/nx-X11/programs/Xserver/randr/rrmonitor.c
@@ -516,7 +516,7 @@ RRMonitorAdd(ClientPtr client, ScreenPtr screen, RRMonitorPtr monitor)
                             (pScrPriv->numMonitors + 1) * sizeof(RRMonitorPtr));
 #endif                          /* !defined(NXAGENT_SERVER) */
     else
-        monitors = xalloc(sizeof(RRMonitorPtr));
+        monitors = malloc(sizeof(RRMonitorPtr));
 
     if (!monitors)
         return BadAlloc;
diff --git a/nx-X11/programs/Xserver/randr/rroutput.c b/nx-X11/programs/Xserver/randr/rroutput.c
index 46948c577..7be00ab5e 100644
--- a/nx-X11/programs/Xserver/randr/rroutput.c
+++ b/nx-X11/programs/Xserver/randr/rroutput.c
@@ -83,13 +83,13 @@ RROutputCreate(ScreenPtr pScreen,
                            (pScrPriv->numOutputs + 1) * sizeof(RROutputPtr));
 #endif                          /* !defined(NXAGENT_SERVER) */
     else
-        outputs = xalloc(sizeof(RROutputPtr));
+        outputs = malloc(sizeof(RROutputPtr));
     if (!outputs)
         return FALSE;
 
     pScrPriv->outputs = outputs;
 
-    output = xalloc(sizeof(RROutputRec) + nameLength + 1);
+    output = malloc(sizeof(RROutputRec) + nameLength + 1);
     if (!output)
         return NULL;
     output->id = FakeClientID(0);
@@ -147,7 +147,7 @@ RROutputSetClones(RROutputPtr output, RROutputPtr * clones, int numClones)
 #ifndef NXAGENT_SERVER
         newClones = xallocarray(numClones, sizeof(RROutputPtr));
 #else                           /* !defined(NXAGENT_SERVER) */
-        newClones = xalloc(numClones * sizeof(RROutputPtr));
+        newClones = malloc(numClones * sizeof(RROutputPtr));
 #endif                          /* !defined(NXAGENT_SERVER) */
         if (!newClones)
             return FALSE;
@@ -184,7 +184,7 @@ RROutputSetModes(RROutputPtr output,
 #ifndef NXAGENT_SERVER
         newModes = xallocarray(numModes, sizeof(RRModePtr));
 #else                           /* !defined(NXAGENT_SERVER) */
-        newModes = xalloc(numModes * sizeof(RRModePtr));
+        newModes = malloc(numModes * sizeof(RRModePtr));
 #endif                          /* !defined(NXAGENT_SERVER) */
         if (!newModes)
             return FALSE;
@@ -236,7 +236,7 @@ RROutputAddUserMode(RROutputPtr output, RRModePtr mode)
                             (output->numUserModes + 1) * sizeof(RRModePtr));
 #endif                          /* !defined(NXAGENT_SERVER) */
     else
-        newModes = xalloc(sizeof(RRModePtr));
+        newModes = malloc(sizeof(RRModePtr));
     if (!newModes)
         return BadAlloc;
 
@@ -292,7 +292,7 @@ RROutputSetCrtcs(RROutputPtr output, RRCrtcPtr * crtcs, int numCrtcs)
 #ifndef NXAGENT_SERVER
         newCrtcs = xallocarray(numCrtcs, sizeof(RRCrtcPtr));
 #else                           /* !defined(NXAGENT_SERVER) */
-        newCrtcs = xalloc(numCrtcs * sizeof(RRCrtcPtr));
+        newCrtcs = malloc(numCrtcs * sizeof(RRCrtcPtr));
 #endif                          /* !defined(NXAGENT_SERVER) */
         if (!newCrtcs)
             return FALSE;
@@ -494,7 +494,7 @@ ProcRRGetOutputInfo(ClientPtr client)
 
     if (extraLen) {
         rep.length += bytes_to_int32(extraLen);
-        extra = xalloc(extraLen);
+        extra = malloc(extraLen);
         if (!extra)
             return BadAlloc;
     }
diff --git a/nx-X11/programs/Xserver/randr/rrproperty.c b/nx-X11/programs/Xserver/randr/rrproperty.c
index 7275cd34f..cf13ca23e 100644
--- a/nx-X11/programs/Xserver/randr/rrproperty.c
+++ b/nx-X11/programs/Xserver/randr/rrproperty.c
@@ -111,7 +111,7 @@ RRCreateOutputProperty(Atom property)
 {
     RRPropertyPtr prop;
 
-    prop = (RRPropertyPtr) xalloc(sizeof(RRPropertyRec));
+    prop = (RRPropertyPtr) malloc(sizeof(RRPropertyRec));
     if (!prop)
         return NULL;
     prop->next = NULL;
@@ -189,7 +189,7 @@ RRChangeOutputProperty(RROutputPtr output, Atom property, Atom type,
 #ifndef NXAGENT_SERVER
         new_value.data = xallocarray(total_len, size_in_bytes);
 #else                           /* !defined(NXAGENT_SERVER) */
-        new_value.data = xalloc(total_len * size_in_bytes);
+        new_value.data = malloc(total_len * size_in_bytes);
 #endif                          /* !defined(NXAGENT_SERVER) */
         if (!new_value.data && total_len && size_in_bytes) {
             if (add)
@@ -362,7 +362,7 @@ RRConfigureOutputProperty(RROutputPtr output, Atom property,
 #ifndef NXAGENT_SERVER
     new_values = xallocarray(num_values, sizeof(INT32));
 #else                           /* !defined(NXAGENT_SERVER) */
-    new_values = xalloc(num_values * sizeof(INT32));
+    new_values = malloc(num_values * sizeof(INT32));
 #endif                          /* !defined(NXAGENT_SERVER) */
     if (!new_values && num_values) {
         if (add)
@@ -417,7 +417,7 @@ ProcRRListOutputProperties(ClientPtr client)
 #ifndef NXAGENT_SERVER
         if (!(pAtoms = xallocarray(numProps, sizeof(Atom))))
 #else                           /* !defined(NXAGENT_SERVER) */
-        if (!(pAtoms = xalloc(numProps * sizeof(Atom))))
+        if (!(pAtoms = malloc(numProps * sizeof(Atom))))
 #endif                          /* !defined(NXAGENT_SERVER) */
             return BadAlloc;
 
@@ -469,7 +469,7 @@ ProcRRQueryOutputProperty(ClientPtr client)
 #ifndef NXAGENT_SERVER
         extra = xallocarray(prop->num_valid, sizeof(INT32));
 #else                           /* !defined(NXAGENT_SERVER) */
-        extra = xalloc(prop->num_valid * sizeof(INT32));
+        extra = malloc(prop->num_valid * sizeof(INT32));
 #endif                          /* !defined(NXAGENT_SERVER) */
         if (!extra)
             return BadAlloc;
@@ -702,7 +702,7 @@ ProcRRGetOutputProperty(ClientPtr client)
     len = min(n - ind, 4 * stuff->longLength);
 
     if (len) {
-        extra = xalloc(len);
+        extra = malloc(len);
         if (!extra)
             return BadAlloc;
     }
diff --git a/nx-X11/programs/Xserver/randr/rrprovider.c b/nx-X11/programs/Xserver/randr/rrprovider.c
index 4911f8fd8..1c292b05e 100644
--- a/nx-X11/programs/Xserver/randr/rrprovider.c
+++ b/nx-X11/programs/Xserver/randr/rrprovider.c
@@ -121,7 +121,7 @@ ProcRRGetProviders(ClientPtr client)
         };
         extraLen = rep.length << 2;
         if (extraLen) {
-            extra = xalloc(extraLen);
+            extra = malloc(extraLen);
             if (!extra)
                 return BadAlloc;
         } else
@@ -217,7 +217,7 @@ ProcRRGetProviderInfo(ClientPtr client)
 
     extraLen = rep.length << 2;
     if (extraLen) {
-        extra = xalloc(extraLen);
+        extra = malloc(extraLen);
         if (!extra)
             return BadAlloc;
     }
diff --git a/nx-X11/programs/Xserver/randr/rrproviderproperty.c b/nx-X11/programs/Xserver/randr/rrproviderproperty.c
index 9aa2135df..b7ba8ab53 100644
--- a/nx-X11/programs/Xserver/randr/rrproviderproperty.c
+++ b/nx-X11/programs/Xserver/randr/rrproviderproperty.c
@@ -108,7 +108,7 @@ RRCreateProviderProperty(Atom property)
 {
     RRPropertyPtr prop;
 
-    prop = (RRPropertyPtr) xalloc(sizeof(RRPropertyRec));
+    prop = (RRPropertyPtr) malloc(sizeof(RRPropertyRec));
     if (!prop)
         return NULL;
     prop->next = NULL;
@@ -185,7 +185,7 @@ RRChangeProviderProperty(RRProviderPtr provider, Atom property, Atom type,
         void *new_data = NULL, *old_data = NULL;
 
         total_size = total_len * size_in_bytes;
-        new_value.data = (void *) xalloc(total_size);
+        new_value.data = (void *) malloc(total_size);
         if (!new_value.data && total_size) {
             if (add)
                 RRDestroyProviderProperty(prop);
@@ -357,7 +357,7 @@ RRConfigureProviderProperty(RRProviderPtr provider, Atom property,
 #ifndef NXAGENT_SERVER
     new_values = xallocarray(num_values, sizeof(INT32));
 #else                           /* !defined(NXAGENT_SERVER) */
-    new_values = xalloc(num_values * sizeof(INT32));
+    new_values = malloc(num_values * sizeof(INT32));
 #endif                          /* !defined(NXAGENT_SERVER) */
 
     if (!new_values && num_values) {
@@ -413,7 +413,7 @@ ProcRRListProviderProperties(ClientPtr client)
 #ifndef NXAGENT_SERVER
         if (!(pAtoms = xallocarray(numProps, sizeof(Atom))))
 #else                           /* !defined(NXAGENT_SERVER) */
-        if (!(pAtoms = xalloc(numProps * sizeof(Atom))))
+        if (!(pAtoms = malloc(numProps * sizeof(Atom))))
 #endif                          /* !defined(NXAGENT_SERVER) */
             return BadAlloc;
 
@@ -464,7 +464,7 @@ ProcRRQueryProviderProperty(ClientPtr client)
 #ifndef NXAGENT_SERVER
         extra = xallocarray(prop->num_valid, sizeof(INT32));
 #else                           /* !defined(NXAGENT_SERVER) */
-        extra = xalloc(prop->num_valid * sizeof(INT32));
+        extra = malloc(prop->num_valid * sizeof(INT32));
 #endif                          /* !defined(NXAGENT_SERVER) */
         if (!extra)
             return BadAlloc;
@@ -694,7 +694,7 @@ ProcRRGetProviderProperty(ClientPtr client)
     len = min(n - ind, 4 * stuff->longLength);
 
     if (len) {
-        extra = xalloc(len);
+        extra = malloc(len);
         if (!extra)
             return BadAlloc;
     }
diff --git a/nx-X11/programs/Xserver/randr/rrscreen.c b/nx-X11/programs/Xserver/randr/rrscreen.c
index 7047d80a5..017ff0143 100644
--- a/nx-X11/programs/Xserver/randr/rrscreen.c
+++ b/nx-X11/programs/Xserver/randr/rrscreen.c
@@ -456,7 +456,7 @@ rrGetMultiScreenResources(ClientPtr client, Bool query, ScreenPtr pScreen)
 
     extraLen = rep.length << 2;
     if (extraLen) {
-        extra = xalloc(extraLen);
+        extra = malloc(extraLen);
         if (!extra) {
             return BadAlloc;
         }
@@ -595,7 +595,7 @@ rrGetScreenResources(ClientPtr client, Bool query)
 
         extraLen = rep.length << 2;
         if (extraLen) {
-            extra = xalloc(extraLen);
+            extra = malloc(extraLen);
             if (!extra) {
                 free(modes);
                 return BadAlloc;
@@ -714,7 +714,7 @@ RR10GetData(ScreenPtr pScreen, RROutputPtr output)
     Bool *used;
 
     /* Make sure there is plenty of space for any combination */
-    data = xalloc(sizeof(RR10DataRec) +
+    data = malloc(sizeof(RR10DataRec) +
                   sizeof(RRScreenSize) * nmode +
                   sizeof(RRScreenRate) * nmode + sizeof(Bool) * nmode);
     if (!data)
@@ -874,7 +874,7 @@ ProcRRGetScreenInfo(ClientPtr client)
             extraLen += rep.nrateEnts * sizeof(CARD16);
 
         if (extraLen) {
-            extra = (CARD8 *) xalloc(extraLen);
+            extra = (CARD8 *) malloc(extraLen);
             if (!extra) {
                 free(pData);
                 return BadAlloc;
diff --git a/nx-X11/programs/Xserver/randr/rrtransform.c b/nx-X11/programs/Xserver/randr/rrtransform.c
index 743e227ea..f0c5dd8c7 100644
--- a/nx-X11/programs/Xserver/randr/rrtransform.c
+++ b/nx-X11/programs/Xserver/randr/rrtransform.c
@@ -73,7 +73,7 @@ RRTransformSetFilter(RRTransformPtr dst,
 #ifndef NXAGENT_SERVER
         new_params = xallocarray(nparams, sizeof(xFixed));
 #else                           /* !defined(NXAGENT_SERVER) */
-        new_params = xalloc(nparams * sizeof(xFixed));
+        new_params = malloc(nparams * sizeof(xFixed));
 #endif                          /* !defined(NXAGENT_SERVER) */
         if (!new_params)
             return FALSE;
diff --git a/nx-X11/programs/Xserver/record/record.c b/nx-X11/programs/Xserver/record/record.c
index 7fabf79c6..1718c2810 100644
--- a/nx-X11/programs/Xserver/record/record.c
+++ b/nx-X11/programs/Xserver/record/record.c
@@ -1002,7 +1002,7 @@ RecordInstallHooks(pRCAP, oneclient)
 		    RecordClientPrivatePtr pClientPriv;
 		    /* no Record proc vector; allocate one */
 		    pClientPriv = (RecordClientPrivatePtr)
-				xalloc(sizeof(RecordClientPrivateRec));
+				malloc(sizeof(RecordClientPrivateRec));
 		    if (!pClientPriv)
 			return BadAlloc;
 		    /* copy old proc vector to new */
@@ -1238,7 +1238,7 @@ RecordAddClientToRCAP(pRCAP, clientspec)
 	}
 	else
 	{
-	    XID *pNewIDs = (XID *)xalloc((pRCAP->sizeClients +
+	    XID *pNewIDs = (XID *)malloc((pRCAP->sizeClients +
 				CLIENT_ARRAY_GROWTH_INCREMENT) * sizeof(XID));
 	    if (!pNewIDs)
 		return;
@@ -1345,7 +1345,7 @@ RecordSanityCheckClientSpecifiers(clientspecs, nspecs, errorspec)
  *	  - XRecordCurrentClients expanded to a list of all currently
  *	    connected clients - excludespec (if non-zero)
  *	The returned array may be the passed array modified in place, or
- *	it may be an Xalloc'ed array.  The caller should keep a pointer to the
+ *	it may be an malloc'ed array.  The caller should keep a pointer to the
  *	original array and free the returned array if it is different.
  *
  *	*pNumClientspecs is set to the number of elements in the returned
@@ -1380,7 +1380,7 @@ RecordCanonicalizeClientSpecifiers(pClientspecs, pNumClientspecs, excludespec)
 	    pClientspecs[i] == XRecordCurrentClients)
 	{ /* expand All/Current */
 	    int j, nc;
-	    XID *pCanon = (XID *)xalloc(sizeof(XID) * (currentMaxClients + 1));
+	    XID *pCanon = (XID *)malloc(sizeof(XID) * (currentMaxClients + 1));
 	    if (!pCanon) return NULL;
 	    for (nc = 0, j = 1; j < currentMaxClients; j++)
 	    {
@@ -1599,7 +1599,7 @@ RecordAllocIntervals(psi, nIntervals)
 {
     assert(!psi->intervals);
     psi->intervals = (RecordSetInterval *)
-			xalloc(nIntervals * sizeof(RecordSetInterval));
+			malloc(nIntervals * sizeof(RecordSetInterval));
     if (!psi->intervals)
 	return BadAlloc;
     bzero(psi->intervals, nIntervals * sizeof(RecordSetInterval));
@@ -1865,7 +1865,7 @@ RecordRegisterClients(pContext, client, stuff)
 
     /* allocate memory for the whole RCAP */
 
-    pRCAP = (RecordClientsAndProtocolPtr)xalloc(totRCAPsize);
+    pRCAP = (RecordClientsAndProtocolPtr)malloc(totRCAPsize);
     if (!pRCAP) 
     {
 	err = BadAlloc;
@@ -2030,7 +2030,7 @@ ProcRecordCreateContext(client)
     REQUEST_AT_LEAST_SIZE(xRecordCreateContextReq);
     LEGAL_NEW_RESOURCE(stuff->context, client);
 
-    pContext = (RecordContextPtr)xalloc(sizeof(RecordContextRec));
+    pContext = (RecordContextPtr)malloc(sizeof(RecordContextRec));
     if (!pContext)
 	goto bailout;
 
diff --git a/nx-X11/programs/Xserver/record/set.c b/nx-X11/programs/Xserver/record/set.c
index 28547f3d0..b8e4cc44c 100644
--- a/nx-X11/programs/Xserver/record/set.c
+++ b/nx-X11/programs/Xserver/record/set.c
@@ -72,7 +72,6 @@ typedef int Bool;
 
 typedef unsigned short CARD16;
 
-#define xalloc malloc
 #define ALLOCATE_LOCAL malloc
 #define DEALLOCATE_LOCAL free
 
@@ -424,7 +423,7 @@ IntervalListCreateSet(pIntervals, nIntervals, pMem, memsize)
     else
     {
 	prls = (IntervalListSetPtr)
-	    xalloc(sizeof(IntervalListSet) + nIntervals * sizeof(RecordSetInterval));
+	    malloc(sizeof(IntervalListSet) + nIntervals * sizeof(RecordSetInterval));
 	if (!prls) goto bailout;
 	prls->baseSet.ops = &IntervalListSetOperations;
     }
@@ -611,7 +610,7 @@ int main(argc, argv)
 	    _RecordForceSetImplementation(IntervalListImplementation);
 	    rsize = RecordSetMemoryRequirements(intervals, nIntervals, &ralign);
 	    pad = (ralign - (bsize & (ralign - 1))) & (ralign - 1);
-	    bs = (RecordSetPtr)xalloc(bsize + pad + rsize );
+	    bs = (RecordSetPtr)malloc(bsize + pad + rsize );
 	    if (!bs)
 	    {
 		fprintf(stderr, "%d: failed to alloc memory for  sets\n",
diff --git a/nx-X11/programs/Xserver/render/animcur.c b/nx-X11/programs/Xserver/render/animcur.c
index 993800c7e..c5535050e 100644
--- a/nx-X11/programs/Xserver/render/animcur.c
+++ b/nx-X11/programs/Xserver/render/animcur.c
@@ -334,7 +334,7 @@ AnimCurInit (ScreenPtr pScreen)
 	animCurState.elt = 0;
 	animCurState.time = 0;
     }
-    as = (AnimCurScreenPtr) xalloc (sizeof (AnimCurScreenRec));
+    as = (AnimCurScreenPtr) malloc (sizeof (AnimCurScreenRec));
     if (!as)
 	return FALSE;
     Wrap(as, pScreen, CloseScreen, AnimCurCloseScreen);
@@ -366,7 +366,7 @@ AnimCursorCreate (CursorPtr *cursors, CARD32 *deltas, int ncursor, CursorPtr *pp
 	if (IsAnimCur (cursors[i]))
 	    return BadMatch;
 	
-    pCursor = (CursorPtr) xalloc (sizeof (CursorRec) +
+    pCursor = (CursorPtr) malloc (sizeof (CursorRec) +
 				  sizeof (AnimCurRec) +
 				  ncursor * sizeof (AnimCurElt));
     if (!pCursor)
diff --git a/nx-X11/programs/Xserver/render/filter.c b/nx-X11/programs/Xserver/render/filter.c
index 31d5481c9..065ffa682 100644
--- a/nx-X11/programs/Xserver/render/filter.c
+++ b/nx-X11/programs/Xserver/render/filter.c
@@ -62,7 +62,7 @@ PictureGetFilterId (char *filter, int len, Bool makeit)
 	    return i;
     if (!makeit)
 	return -1;
-    name = xalloc (len + 1);
+    name = malloc (len + 1);
     if (!name)
 	return -1;
     memcpy (name, filter, len);
@@ -70,7 +70,7 @@ PictureGetFilterId (char *filter, int len, Bool makeit)
     if (filterNames)
 	names = xrealloc (filterNames, (nfilterNames + 1) * sizeof (char *));
     else
-	names = xalloc (sizeof (char *));
+	names = malloc (sizeof (char *));
     if (!names)
     {
 	free (name);
@@ -146,7 +146,7 @@ PictureAddFilter (ScreenPtr			    pScreen,
     if (ps->filters)
 	filters = xrealloc (ps->filters, (ps->nfilters + 1) * sizeof (PictFilterRec));
     else
-	filters = xalloc (sizeof (PictFilterRec));
+	filters = malloc (sizeof (PictFilterRec));
     if (!filters)
 	return -1;
     ps->filters = filters;
@@ -179,7 +179,7 @@ PictureSetFilterAlias (ScreenPtr pScreen, char *filter, char *alias)
 				(ps->nfilterAliases + 1) *
 				sizeof (PictFilterAliasRec));
 	else
-	    aliases = xalloc (sizeof (PictFilterAliasRec));
+	    aliases = malloc (sizeof (PictFilterAliasRec));
 	if (!aliases)
 	    return FALSE;
 	ps->filterAliases = aliases;
@@ -336,7 +336,7 @@ SetPicturePictFilter (PicturePtr pPicture, PictFilterPtr pFilter,
     }
 
     if (nparams != pPicture->filter_nparams) {
-        xFixed *new_params = xalloc (nparams * sizeof (xFixed));
+        xFixed *new_params = malloc (nparams * sizeof (xFixed));
 
         if (!new_params && nparams)
             return BadAlloc;
diff --git a/nx-X11/programs/Xserver/render/glyph.c b/nx-X11/programs/Xserver/render/glyph.c
index f956c44b2..4cba50d0f 100644
--- a/nx-X11/programs/Xserver/render/glyph.c
+++ b/nx-X11/programs/Xserver/render/glyph.c
@@ -122,7 +122,7 @@ _GlyphSetSetNewPrivate (GlyphSetPtr glyphSet, int n, void * ptr)
 	    if (!new)
 		return FALSE;
 	} else {
-	    new = (void **) xalloc ((n + 1) * sizeof (void *));
+	    new = (void **) malloc ((n + 1) * sizeof (void *));
 	    if (!new)
 		return FALSE;
 	    if (glyphSet->devPrivates)
@@ -346,7 +346,7 @@ AllocateGlyph (xGlyphInfo *gi, int fdepth)
     if (gi->height && padded_width > (UINT32_MAX - sizeof(GlyphRec))/gi->height)
 	return 0;
     size = gi->height * padded_width;
-    glyph = (GlyphPtr) xalloc (size + sizeof (GlyphRec));
+    glyph = (GlyphPtr) malloc (size + sizeof (GlyphRec));
     if (!glyph)
 	return 0;
     glyph->refcnt = 0;
@@ -358,7 +358,7 @@ AllocateGlyph (xGlyphInfo *gi, int fdepth)
 Bool
 AllocateGlyphHash (GlyphHashPtr hash, GlyphHashSetPtr hashSet)
 {
-    hash->table = (GlyphRefPtr) xalloc (hashSet->size * sizeof (GlyphRefRec));
+    hash->table = (GlyphRefPtr) malloc (hashSet->size * sizeof (GlyphRefRec));
     if (!hash->table)
 	return FALSE;
     memset (hash->table, 0, hashSet->size * sizeof (GlyphRefRec));
@@ -434,7 +434,7 @@ AllocateGlyphSet (int fdepth, PictFormatPtr format)
 
     size = (sizeof (GlyphSetRec) +
 	    (sizeof (void *) * _GlyphSetPrivateAllocateIndex));
-    glyphSet = xalloc (size);
+    glyphSet = malloc (size);
     if (!glyphSet)
 	return FALSE;
     bzero((char *)glyphSet, size);
diff --git a/nx-X11/programs/Xserver/render/miindex.c b/nx-X11/programs/Xserver/render/miindex.c
index ad2653c14..ce31c00fb 100644
--- a/nx-X11/programs/Xserver/render/miindex.c
+++ b/nx-X11/programs/Xserver/render/miindex.c
@@ -259,12 +259,12 @@ miInitIndexed (ScreenPtr	pScreen,
 	    pixels[p] = p;
     }
     
-    pIndexed = xalloc (sizeof (miIndexedRec));
+    pIndexed = malloc (sizeof (miIndexedRec));
     if (!pIndexed)
 	return FALSE;
     
     pFormat->index.nvalues = num;
-    pFormat->index.pValues = xalloc (num * sizeof (xIndexValue));
+    pFormat->index.pValues = malloc (num * sizeof (xIndexValue));
     if (!pFormat->index.pValues)
     {
 	free (pIndexed);
diff --git a/nx-X11/programs/Xserver/render/picture.c b/nx-X11/programs/Xserver/render/picture.c
index 1e653b0c3..1131696d5 100644
--- a/nx-X11/programs/Xserver/render/picture.c
+++ b/nx-X11/programs/Xserver/render/picture.c
@@ -365,7 +365,7 @@ PictureCreateDefaultFormats (ScreenPtr pScreen, int *nformatp)
     }
     
 
-    pFormats = (PictFormatPtr) xalloc (nformats * sizeof (PictFormatRec));
+    pFormats = (PictFormatPtr) malloc (nformats * sizeof (PictFormatRec));
     if (!pFormats)
 	return 0;
     memset (pFormats, '\0', nformats * sizeof (PictFormatRec));
@@ -689,7 +689,7 @@ PictureInit (ScreenPtr pScreen, PictFormatPtr formats, int nformats)
 	}
 	formats[n].format = PICT_FORMAT(0,type,a,r,g,b);
     }
-    ps = (PictureScreenPtr) xalloc (sizeof (PictureScreenRec));
+    ps = (PictureScreenPtr) malloc (sizeof (PictureScreenRec));
     if (!ps)
     {
 	free (formats);
@@ -784,7 +784,7 @@ AllocatePicture (ScreenPtr  pScreen)
     unsigned int    	size;
     int			i;
 
-    pPicture = (PicturePtr) xalloc (ps->totalPictureSize);
+    pPicture = (PicturePtr) malloc (ps->totalPictureSize);
     if (!pPicture)
 	return 0;
     ppriv = (DevUnion *)(pPicture + 1);
@@ -961,7 +961,7 @@ static void initGradient(SourcePictPtr pGradient, int stopCount,
         dpos = stopPoints[i];
     }
 
-    pGradient->linear.stops = xalloc(stopCount*sizeof(PictGradientStop));
+    pGradient->linear.stops = malloc(stopCount*sizeof(PictGradientStop));
     if (!pGradient->linear.stops) {
         *error = BadAlloc;
         return;
@@ -980,7 +980,7 @@ static void initGradient(SourcePictPtr pGradient, int stopCount,
 static PicturePtr createSourcePicture(void)
 {
     PicturePtr pPicture;
-    pPicture = (PicturePtr) xalloc(sizeof(PictureRec));
+    pPicture = (PicturePtr) malloc(sizeof(PictureRec));
     pPicture->pDrawable = 0;
     pPicture->pFormat = 0;
     pPicture->pNext = 0;
@@ -1000,7 +1000,7 @@ CreateSolidPicture (Picture pid, xRenderColor *color, int *error)
     }
 
     pPicture->id = pid;
-    pPicture->pSourcePict = (SourcePictPtr) xalloc(sizeof(PictSolidFill));
+    pPicture->pSourcePict = (SourcePictPtr) malloc(sizeof(PictSolidFill));
     if (!pPicture->pSourcePict) {
         *error = BadAlloc;
         free(pPicture);
@@ -1034,7 +1034,7 @@ CreateLinearGradientPicture (Picture pid, xPointFixed *p1, xPointFixed *p2,
     }
 
     pPicture->id = pid;
-    pPicture->pSourcePict = (SourcePictPtr) xalloc(sizeof(PictLinearGradient));
+    pPicture->pSourcePict = (SourcePictPtr) malloc(sizeof(PictLinearGradient));
     if (!pPicture->pSourcePict) {
         *error = BadAlloc;
         free(pPicture);
@@ -1083,7 +1083,7 @@ CreateRadialGradientPicture (Picture pid, xPointFixed *inner, xPointFixed *outer
     }
 
     pPicture->id = pid;
-    pPicture->pSourcePict = (SourcePictPtr) xalloc(sizeof(PictRadialGradient));
+    pPicture->pSourcePict = (SourcePictPtr) malloc(sizeof(PictRadialGradient));
     if (!pPicture->pSourcePict) {
         *error = BadAlloc;
         free(pPicture);
@@ -1134,7 +1134,7 @@ CreateConicalGradientPicture (Picture pid, xPointFixed *center, xFixed angle,
     }
 
     pPicture->id = pid;
-    pPicture->pSourcePict = (SourcePictPtr) xalloc(sizeof(PictConicalGradient));
+    pPicture->pSourcePict = (SourcePictPtr) malloc(sizeof(PictConicalGradient));
     if (!pPicture->pSourcePict) {
         *error = BadAlloc;
         free(pPicture);
@@ -1477,7 +1477,7 @@ SetPictureTransform (PicturePtr	    pPicture,
     {
 	if (!pPicture->transform)
 	{
-	    pPicture->transform = (PictTransform *) xalloc (sizeof (PictTransform));
+	    pPicture->transform = (PictTransform *) malloc (sizeof (PictTransform));
 	    if (!pPicture->transform)
 		return BadAlloc;
 	}
diff --git a/nx-X11/programs/Xserver/render/render.c b/nx-X11/programs/Xserver/render/render.c
index 58b3dbc88..c6cb7bce7 100644
--- a/nx-X11/programs/Xserver/render/render.c
+++ b/nx-X11/programs/Xserver/render/render.c
@@ -413,7 +413,7 @@ ProcRenderQueryPictFormats (ClientPtr client)
 	       ndepth * sizeof (xPictDepth) +
 	       nvisual * sizeof (xPictVisual) +
 	       numSubpixel * sizeof (CARD32));
-    reply = (xRenderQueryPictFormatsReply *) xalloc (rlength);
+    reply = (xRenderQueryPictFormatsReply *) malloc (rlength);
     if (!reply)
 	return BadAlloc;
     memset(reply, 0, rlength);
@@ -588,7 +588,7 @@ ProcRenderQueryPictIndexValues (ClientPtr client)
     num = pFormat->index.nvalues;
     rlength = (sizeof (xRenderQueryPictIndexValuesReply) + 
 	       num * sizeof(xIndexValue));
-    reply = (xRenderQueryPictIndexValuesReply *) xalloc (rlength);
+    reply = (xRenderQueryPictIndexValuesReply *) malloc (rlength);
     if (!reply)
 	return BadAlloc;
 
@@ -1139,7 +1139,7 @@ ProcRenderAddGlyphs (ClientPtr client)
 	glyphsBase = glyphsLocal;
     else
     {
-	glyphsBase = (GlyphNewPtr) Xalloc (nglyphs * sizeof (GlyphNewRec));
+	glyphsBase = (GlyphNewPtr) malloc (nglyphs * sizeof (GlyphNewRec));
 	if (!glyphsBase)
 	    return BadAlloc;
     }
@@ -1533,19 +1533,19 @@ ProcRenderCreateCursor (ClientPtr client)
     if ( stuff->x > width 
       || stuff->y > height )
 	return (BadMatch);
-    argbbits = xalloc (width * height * sizeof (CARD32));
+    argbbits = malloc (width * height * sizeof (CARD32));
     if (!argbbits)
 	return (BadAlloc);
     
     stride = BitmapBytePad(width);
     nbytes_mono = stride*height;
-    srcbits = (unsigned char *)xalloc(nbytes_mono);
+    srcbits = (unsigned char *)malloc(nbytes_mono);
     if (!srcbits)
     {
 	free (argbbits);
 	return (BadAlloc);
     }
-    mskbits = (unsigned char *)xalloc(nbytes_mono);
+    mskbits = (unsigned char *)malloc(nbytes_mono);
     if (!mskbits)
     {
 	free(argbbits);
@@ -1748,7 +1748,7 @@ ProcRenderQueryFilters (ClientPtr client)
     }
     len = ((nnames + 1) >> 1) + ((nbytesName + 3) >> 2);
     total_bytes = sizeof (xRenderQueryFiltersReply) + (len << 2);
-    reply = (xRenderQueryFiltersReply *) xalloc (total_bytes);
+    reply = (xRenderQueryFiltersReply *) malloc (total_bytes);
     if (!reply)
 	return BadAlloc;
     aliases = (INT16 *) (reply + 1);
@@ -1862,7 +1862,7 @@ ProcRenderCreateAnimCursor (ClientPtr client)
     if (client->req_len & 1)
 	return BadLength;
     ncursor = (client->req_len - (SIZEOF(xRenderCreateAnimCursorReq) >> 2)) >> 1;
-    cursors = xalloc (ncursor * (sizeof (CursorPtr) + sizeof (CARD32)));
+    cursors = malloc (ncursor * (sizeof (CursorPtr) + sizeof (CARD32)));
     if (!cursors)
 	return BadAlloc;
     deltas = (CARD32 *) (cursors + ncursor);
@@ -2681,7 +2681,7 @@ PanoramiXRenderCreatePicture (ClientPtr client)
     if(!(refDraw = (PanoramiXRes *)SecurityLookupIDByClass(
 		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
 	return BadDrawable;
-    if(!(newPict = (PanoramiXRes *) xalloc(sizeof(PanoramiXRes))))
+    if(!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
 	return BadAlloc;
     newPict->type = XRT_PICTURE;
     newPict->info[0].id = stuff->pid;
diff --git a/nx-X11/programs/Xserver/xfixes/cursor.c b/nx-X11/programs/Xserver/xfixes/cursor.c
index 6618dd45a..c60d4b37c 100755
--- a/nx-X11/programs/Xserver/xfixes/cursor.c
+++ b/nx-X11/programs/Xserver/xfixes/cursor.c
@@ -157,7 +157,7 @@ XFixesSelectCursorInput (ClientPtr	pClient,
     }
     if (!e)
     {
-	e = (CursorEventPtr) xalloc (sizeof (CursorEventRec));
+	e = (CursorEventPtr) malloc (sizeof (CursorEventRec));
 	if (!e)
 	    return BadAlloc;
 
@@ -312,7 +312,7 @@ ProcXFixesGetCursorImage (ClientPtr client)
     width = pCursor->bits->width;
     height = pCursor->bits->height;
     npixels = width * height;
-    rep = xalloc (sizeof (xXFixesGetCursorImageReply) +
+    rep = malloc (sizeof (xXFixesGetCursorImageReply) +
 		  npixels * sizeof (CARD32));
     if (!rep)
 	return BadAlloc;
@@ -463,7 +463,7 @@ ProcXFixesGetCursorImageAndName (ClientPtr client)
     name = pCursor->name ? NameForAtom (pCursor->name) : "";
     nbytes = strlen (name);
     nbytesRound = (nbytes + 3) & ~3;
-    rep = xalloc (sizeof (xXFixesGetCursorImageAndNameReply) +
+    rep = malloc (sizeof (xXFixesGetCursorImageAndNameReply) +
 		  npixels * sizeof (CARD32) + nbytesRound);
     if (!rep)
 	return BadAlloc;
@@ -740,7 +740,7 @@ XFixesCursorInit (void)
 	ScreenPtr	pScreen = screenInfo.screens[i];
 	CursorScreenPtr	cs;
 
-	cs = (CursorScreenPtr) xalloc (sizeof (CursorScreenRec));
+	cs = (CursorScreenPtr) malloc (sizeof (CursorScreenRec));
 	if (!cs)
 	    return FALSE;
 	Wrap (cs, pScreen, CloseScreen, CursorCloseScreen);
diff --git a/nx-X11/programs/Xserver/xfixes/region.c b/nx-X11/programs/Xserver/xfixes/region.c
index ba840f4b3..09f33d0ac 100755
--- a/nx-X11/programs/Xserver/xfixes/region.c
+++ b/nx-X11/programs/Xserver/xfixes/region.c
@@ -575,7 +575,7 @@ ProcXFixesFetchRegion (ClientPtr client)
     pBox = RegionRects (pRegion);
     nBox = RegionNumRects (pRegion);
     
-    reply = xalloc (sizeof (xXFixesFetchRegionReply) +
+    reply = malloc (sizeof (xXFixesFetchRegionReply) +
 		    nBox * sizeof (xRectangle));
     if (!reply)
 	return BadAlloc;
@@ -822,7 +822,7 @@ ProcXFixesExpandRegion (ClientPtr client)
     pSrc = RegionRects(pSource);
     if (nBoxes)
     {
-	pTmp = xalloc (nBoxes * sizeof (BoxRec));
+	pTmp = malloc (nBoxes * sizeof (BoxRec));
 	if (!pTmp)
 	    return BadAlloc;
 	for (i = 0; i < nBoxes; i++)
diff --git a/nx-X11/programs/Xserver/xfixes/select.c b/nx-X11/programs/Xserver/xfixes/select.c
index 4abad3f19..6fe632c0d 100755
--- a/nx-X11/programs/Xserver/xfixes/select.c
+++ b/nx-X11/programs/Xserver/xfixes/select.c
@@ -156,7 +156,7 @@ XFixesSelectSelectionInput (ClientPtr	pClient,
     }
     if (!e)
     {
-	e = (SelectionEventPtr) xalloc (sizeof (SelectionEventRec));
+	e = (SelectionEventPtr) malloc (sizeof (SelectionEventRec));
 	if (!e)
 	    return BadAlloc;
 
diff --git a/nx-X11/programs/Xserver/xkb/xkbActions.c b/nx-X11/programs/Xserver/xkb/xkbActions.c
index eb1c80448..7bc6b3476 100644
--- a/nx-X11/programs/Xserver/xkb/xkbActions.c
+++ b/nx-X11/programs/Xserver/xkb/xkbActions.c
@@ -75,7 +75,7 @@ XkbSetExtension(DeviceIntPtr device, ProcessInputProc proc)
     if (!AllocateDevicePrivate(device, xkbDevicePrivateIndex))
 	return;
 
-    xkbPrivPtr = (xkbDeviceInfoPtr) xalloc(sizeof(xkbDeviceInfoRec));
+    xkbPrivPtr = (xkbDeviceInfoPtr) malloc(sizeof(xkbDeviceInfoRec));
     if (!xkbPrivPtr)
 	return;
     xkbPrivPtr->unwrapProc = NULL;
-- 
cgit v1.2.3


From 286d83260216e8e53db701eed5c785aae1c716bf Mon Sep 17 00:00:00 2001
From: Mike Gabriel <mike.gabriel@das-netzwerkteam.de>
Date: Wed, 29 Jun 2016 01:36:31 +0200
Subject: Use internal temp variable for swap macros. Make swaps/swapl type
 safe (introducing wrong_size check at build time).
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

 While working on this changeset, various spots got discovered where
 swapl or swaps was used on a wrong type, where byte swapping calls had
 been forgotten or done on the wrong variable.

 This backport at least includes changes from the following X.org
 commits, listed in non-chronological order:

 commit 2c7c520cfe0df30f4bc3adba59d9c62582823bf8
 Author: Matt Turner <mattst88@gmail.com>
 Date:   Thu Aug 4 15:35:41 2011 -0400

    Use internal temp variable for swap macros

    Also, fix whitespace, mainly around
        swaps(&rep.sequenceNumber)

    Reviewed-by: Peter Harris <pharris@opentext.com>
    Signed-off-by: Matt Turner <mattst88@gmail.com>

 commit 9edcae78c46286baff42e74bfe26f6ae4d00fe01
 Author: Matt Turner <mattst88@gmail.com>
 Date:   Wed Sep 21 17:14:16 2011 -0400

    Use correct swap{l,s} (or none at all for CARD8)

    Swapping the wrong size was never caught because swap{l,s} are macros.

    It's clear in the case of Xext/xres.c, that the author believed
    client_major/minor to be CARD16 from looking at the code in the first
    hunk.

    v2: dmx.c fixes from Keith.

    Reviewed-by: Peter Harris <pharris@opentext.com>
    Signed-off-by: Matt Turner <mattst88@gmail.com>

 commit dab064fa5e0b1f5c67222562ad5367005832cba1
 Author: Andrea Canciani <ranma42@gmail.com>
 Date:   Tue Nov 2 20:10:32 2010 +0100

    render: Fix byteswapping of gradient stops

    The function swapStops repeatedly swaps the color components as
    CARD16, but incorrectly steps over them as if they were CARD32.

    This causes half of the stops not to be swapped at all and some
    unrelated data be swapped instead.

    Signed-off-by: Andrea Canciani <ranma42@gmail.com>
    Reviewed-by: Soren Sandmann <sandmann@daimi.au.dk>
    Reviewed-by: Julien Cristau <jcristau@debian.org>
    Signed-off-by: Keith Packard <keithp@keithp.com>

 commit 54770c980cd2b91a8377f975a58ed69def5cfa42
 Author: Matt Turner <mattst88@gmail.com>
 Date:   Tue Aug 16 16:59:07 2011 -0400

    Cast char* buffers to swap functions

    Reviewed-by: Peter Harris <pharris@opentext.com>
    Signed-off-by: Matt Turner <mattst88@gmail.com>

 commit 6844bd2e63490870bab3c469eec6030354ef2865
 Author: Alan Coopersmith <alan.coopersmith@sun.com>
 Date:   Wed Jan 9 19:52:00 2008 -0800

    More Xv extension byte swapping fixes

 commit e46f6ddeccd082b2d507a1e8b57ea30e6b0a2c83
 Author: Michel Dänzer <michel@tungstengraphics.com>
 Date:   Wed Jan 16 14:24:22 2008 +0100

    Yet another Xv extension byte swapping fix.
---
 nx-X11/programs/Xserver/Xext/bigreq.c              |   7 +-
 nx-X11/programs/Xserver/Xext/dpms.c                |  60 +-
 nx-X11/programs/Xserver/Xext/panoramiX.c           |  55 +-
 nx-X11/programs/Xserver/Xext/panoramiXSwap.c       |  18 +-
 nx-X11/programs/Xserver/Xext/saver.c               |  56 +-
 nx-X11/programs/Xserver/Xext/security.c            |  37 +-
 nx-X11/programs/Xserver/Xext/shape.c               | 105 ++-
 nx-X11/programs/Xserver/Xext/shm.c                 | 107 ++-
 nx-X11/programs/Xserver/Xext/sync.c                | 132 ++--
 nx-X11/programs/Xserver/Xext/xcmisc.c              |  36 +-
 nx-X11/programs/Xserver/Xext/xf86bigfont.c         |  70 +-
 nx-X11/programs/Xserver/Xext/xres.c                |  62 +-
 nx-X11/programs/Xserver/Xext/xtest.c               |  29 +-
 nx-X11/programs/Xserver/Xext/xtest1di.c            |  78 +--
 nx-X11/programs/Xserver/Xext/xvdisp.c              | 406 +++++-------
 nx-X11/programs/Xserver/Xi/allowev.c               |   6 +-
 nx-X11/programs/Xserver/Xi/chgdctl.c               |  12 +-
 nx-X11/programs/Xserver/Xi/chgfctl.c               |  52 +-
 nx-X11/programs/Xserver/Xi/chgkbd.c                |  10 +-
 nx-X11/programs/Xserver/Xi/chgkmap.c               |   3 +-
 nx-X11/programs/Xserver/Xi/chgprop.c               |   8 +-
 nx-X11/programs/Xserver/Xi/chgptr.c                |  10 +-
 nx-X11/programs/Xserver/Xi/closedev.c              |   4 +-
 nx-X11/programs/Xserver/Xi/devbell.c               |   4 +-
 nx-X11/programs/Xserver/Xi/extinit.c               |  42 +-
 nx-X11/programs/Xserver/Xi/getbmap.c               |  10 +-
 nx-X11/programs/Xserver/Xi/getdctl.c               |  21 +-
 nx-X11/programs/Xserver/Xi/getfctl.c               |  64 +-
 nx-X11/programs/Xserver/Xi/getfocus.c              |  14 +-
 nx-X11/programs/Xserver/Xi/getkmap.c               |  10 +-
 nx-X11/programs/Xserver/Xi/getmmap.c               |  10 +-
 nx-X11/programs/Xserver/Xi/getprop.c               |  14 +-
 nx-X11/programs/Xserver/Xi/getselev.c              |  16 +-
 nx-X11/programs/Xserver/Xi/getvers.c               |  16 +-
 nx-X11/programs/Xserver/Xi/grabdev.c               |  16 +-
 nx-X11/programs/Xserver/Xi/grabdevb.c              |  10 +-
 nx-X11/programs/Xserver/Xi/grabdevk.c              |  10 +-
 nx-X11/programs/Xserver/Xi/gtmotion.c              |  20 +-
 nx-X11/programs/Xserver/Xi/listdev.c               |  28 +-
 nx-X11/programs/Xserver/Xi/opendev.c               |  10 +-
 nx-X11/programs/Xserver/Xi/queryst.c               |  13 +-
 nx-X11/programs/Xserver/Xi/selectev.c              |   8 +-
 nx-X11/programs/Xserver/Xi/sendexev.c              |   9 +-
 nx-X11/programs/Xserver/Xi/setbmap.c               |  10 +-
 nx-X11/programs/Xserver/Xi/setdval.c               |  10 +-
 nx-X11/programs/Xserver/Xi/setfocus.c              |   8 +-
 nx-X11/programs/Xserver/Xi/setmmap.c               |  10 +-
 nx-X11/programs/Xserver/Xi/setmode.c               |  10 +-
 nx-X11/programs/Xserver/Xi/ungrdev.c               |   6 +-
 nx-X11/programs/Xserver/Xi/ungrdevb.c              |   8 +-
 nx-X11/programs/Xserver/Xi/ungrdevk.c              |   8 +-
 nx-X11/programs/Xserver/composite/compext.c        |  74 +--
 nx-X11/programs/Xserver/damageext/damageext.c      |  37 +-
 nx-X11/programs/Xserver/dbe/dbe.c                  |  63 +-
 nx-X11/programs/Xserver/dix/dispatch.c             |   2 +-
 nx-X11/programs/Xserver/dix/swaprep.c              | 401 +++++-------
 nx-X11/programs/Xserver/dix/swapreq.c              | 728 +++++++++------------
 nx-X11/programs/Xserver/hw/nxagent/NXrender.c      |  56 +-
 nx-X11/programs/Xserver/include/misc.h             | 117 +++-
 nx-X11/programs/Xserver/os/connection.c            |   6 +-
 nx-X11/programs/Xserver/os/io.c                    |   6 +-
 nx-X11/programs/Xserver/randr/rrcrtc.c             |  98 ++-
 nx-X11/programs/Xserver/randr/rrdispatch.c         |  10 +-
 nx-X11/programs/Xserver/randr/rrmode.c             |   7 +-
 nx-X11/programs/Xserver/randr/rrmonitor.c          |  28 +-
 nx-X11/programs/Xserver/randr/rroutput.c           |  34 +-
 nx-X11/programs/Xserver/randr/rrproperty.c         |  43 +-
 nx-X11/programs/Xserver/randr/rrprovider.c         |  36 +-
 nx-X11/programs/Xserver/randr/rrproviderproperty.c |  42 +-
 nx-X11/programs/Xserver/randr/rrscreen.c           | 155 +++--
 nx-X11/programs/Xserver/randr/rrsdispatch.c        | 411 +++++-------
 nx-X11/programs/Xserver/randr/rrxinerama.c         |  83 +--
 nx-X11/programs/Xserver/record/record.c            |  98 ++-
 nx-X11/programs/Xserver/render/render.c            | 443 ++++++-------
 nx-X11/programs/Xserver/xfixes/cursor.c            | 111 ++--
 nx-X11/programs/Xserver/xfixes/region.c            | 200 +++---
 nx-X11/programs/Xserver/xfixes/saveset.c           |   5 +-
 nx-X11/programs/Xserver/xfixes/select.c            |   9 +-
 nx-X11/programs/Xserver/xfixes/xfixes.c            |  16 +-
 nx-X11/programs/Xserver/xkb/ddxList.c              |   5 +-
 nx-X11/programs/Xserver/xkb/xkb.c                  | 423 ++++++------
 nx-X11/programs/Xserver/xkb/xkbEvents.c            | 108 ++-
 nx-X11/programs/Xserver/xkb/xkbSwap.c              | 336 ++++------
 83 files changed, 2593 insertions(+), 3376 deletions(-)

(limited to 'nx-X11/programs/Xserver/xfixes/select.c')

diff --git a/nx-X11/programs/Xserver/Xext/bigreq.c b/nx-X11/programs/Xserver/Xext/bigreq.c
index eba552cfe..a43031d7e 100644
--- a/nx-X11/programs/Xserver/Xext/bigreq.c
+++ b/nx-X11/programs/Xserver/Xext/bigreq.c
@@ -85,10 +85,9 @@ ProcBigReqDispatch (client)
 {
     REQUEST(xBigReqEnableReq);
     xBigReqEnableReply rep;
-    register int n;
 
     if (client->swapped) {
-	swaps(&stuff->length, n);
+	swaps(&stuff->length);
     }
     if (stuff->brReqType != X_BigReqEnable)
 	return BadRequest;
@@ -100,8 +99,8 @@ ProcBigReqDispatch (client)
     rep.sequenceNumber = client->sequence;
     rep.max_request_size = maxBigRequestSize;
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-	swapl(&rep.max_request_size, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.max_request_size);
     }
     WriteToClient(client, sizeof(xBigReqEnableReply), (char *)&rep);
     return(client->noClientException);
diff --git a/nx-X11/programs/Xserver/Xext/dpms.c b/nx-X11/programs/Xserver/Xext/dpms.c
index fc40193e4..f88e1656e 100644
--- a/nx-X11/programs/Xserver/Xext/dpms.c
+++ b/nx-X11/programs/Xserver/Xext/dpms.c
@@ -105,7 +105,6 @@ ProcDPMSGetVersion(client)
 {
     /* REQUEST(xDPMSGetVersionReq); */
     xDPMSGetVersionReply rep;
-    register int n;
 
     REQUEST_SIZE_MATCH(xDPMSGetVersionReq);
 
@@ -115,9 +114,9 @@ ProcDPMSGetVersion(client)
     rep.majorVersion = DPMSMajorVersion;
     rep.minorVersion = DPMSMinorVersion;
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-	swaps(&rep.majorVersion, n);
-	swaps(&rep.minorVersion, n);
+	swaps(&rep.sequenceNumber);
+	swaps(&rep.majorVersion);
+	swaps(&rep.minorVersion);
     }
     WriteToClient(client, sizeof(xDPMSGetVersionReply), (char *)&rep);
     return(client->noClientException);
@@ -128,7 +127,6 @@ ProcDPMSCapable(register ClientPtr client)
 {
     /* REQUEST(xDPMSCapableReq); */
     xDPMSCapableReply rep;
-    register int n;
 
     REQUEST_SIZE_MATCH(xDPMSCapableReq);
 
@@ -138,7 +136,7 @@ ProcDPMSCapable(register ClientPtr client)
     rep.capable = DPMSCapableFlag;
 
     if (client->swapped) {
-	swaps(&rep.sequenceNumber, n);
+	swaps(&rep.sequenceNumber);
     }
     WriteToClient(client, sizeof(xDPMSCapableReply), (char *)&rep);
     return(client->noClientException);
@@ -150,7 +148,6 @@ ProcDPMSGetTimeouts(client)
 {
     /* REQUEST(xDPMSGetTimeoutsReq); */
     xDPMSGetTimeoutsReply rep;
-    register int n;
 
     REQUEST_SIZE_MATCH(xDPMSGetTimeoutsReq);
 
@@ -162,10 +159,10 @@ ProcDPMSGetTimeouts(client)
     rep.off = DPMSOffTime / MILLI_PER_SECOND;
 
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-	swaps(&rep.standby, n);
-	swaps(&rep.suspend, n);
-	swaps(&rep.off, n);
+	swaps(&rep.sequenceNumber);
+	swaps(&rep.standby);
+	swaps(&rep.suspend);
+	swaps(&rep.off);
     }
     WriteToClient(client, sizeof(xDPMSGetTimeoutsReply), (char *)&rep);
     return(client->noClientException);
@@ -265,7 +262,6 @@ ProcDPMSInfo(register ClientPtr client)
 {
     /* REQUEST(xDPMSInfoReq); */
     xDPMSInfoReply rep;
-    register int n;
 
     REQUEST_SIZE_MATCH(xDPMSInfoReq);
 
@@ -276,8 +272,8 @@ ProcDPMSInfo(register ClientPtr client)
     rep.state = DPMSEnabled;
 
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-	swaps(&rep.power_level, n);
+	swaps(&rep.sequenceNumber);
+	swaps(&rep.power_level);
     }
     WriteToClient(client, sizeof(xDPMSInfoReply), (char *)&rep);
     return(client->noClientException);
@@ -316,13 +312,12 @@ static int
 SProcDPMSGetVersion(client)
     register ClientPtr	client;
 {
-    register int n;
     REQUEST(xDPMSGetVersionReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xDPMSGetVersionReq);
-    swaps(&stuff->majorVersion, n);
-    swaps(&stuff->minorVersion, n);
+    swaps(&stuff->majorVersion);
+    swaps(&stuff->minorVersion);
     return ProcDPMSGetVersion(client);
 }
 
@@ -330,9 +325,8 @@ static int
 SProcDPMSCapable(register ClientPtr client)
 {
     REQUEST(xDPMSCapableReq);
-    register int n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xDPMSCapableReq);
 
     return ProcDPMSCapable(client);
@@ -343,9 +337,8 @@ SProcDPMSGetTimeouts(client)
     register ClientPtr client;
 {
     REQUEST(xDPMSGetTimeoutsReq);
-    register int n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xDPMSGetTimeoutsReq);
 
     return ProcDPMSGetTimeouts(client);
@@ -356,14 +349,13 @@ SProcDPMSSetTimeouts(client)
     register ClientPtr client;
 {
     REQUEST(xDPMSSetTimeoutsReq);
-    register int n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xDPMSSetTimeoutsReq);
 
-    swaps(&stuff->standby, n);
-    swaps(&stuff->suspend, n);
-    swaps(&stuff->off, n);
+    swaps(&stuff->standby);
+    swaps(&stuff->suspend);
+    swaps(&stuff->off);
     return ProcDPMSSetTimeouts(client);
 }
 
@@ -372,9 +364,8 @@ SProcDPMSEnable(client)
     register ClientPtr client;
 {
     REQUEST(xDPMSEnableReq);
-    register int n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xDPMSEnableReq);
 
     return ProcDPMSEnable(client);
@@ -385,9 +376,8 @@ SProcDPMSDisable(client)
     register ClientPtr client;
 {
     REQUEST(xDPMSDisableReq);
-    register int n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xDPMSDisableReq);
 
     return ProcDPMSDisable(client);
@@ -398,12 +388,11 @@ SProcDPMSForceLevel(client)
     register ClientPtr client;
 {
     REQUEST(xDPMSForceLevelReq);
-    register int n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xDPMSForceLevelReq);
 
-    swaps(&stuff->level, n);
+    swaps(&stuff->level);
 
     return ProcDPMSForceLevel(client);
 }
@@ -413,9 +402,8 @@ SProcDPMSInfo(client)
     register ClientPtr client;
 {
     REQUEST(xDPMSInfoReq);
-    register int n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xDPMSInfoReq);
 
     return ProcDPMSInfo(client);
diff --git a/nx-X11/programs/Xserver/Xext/panoramiX.c b/nx-X11/programs/Xserver/Xext/panoramiX.c
index c00d003a5..322204763 100644
--- a/nx-X11/programs/Xserver/Xext/panoramiX.c
+++ b/nx-X11/programs/Xserver/Xext/panoramiX.c
@@ -936,7 +936,6 @@ ProcPanoramiXQueryVersion (ClientPtr client)
 {
     /* REQUEST(xPanoramiXQueryVersionReq); */
     xPanoramiXQueryVersionReply		rep;
-    register 	int			n;
 
     REQUEST_SIZE_MATCH (xPanoramiXQueryVersionReq);
     rep.type = X_Reply;
@@ -945,10 +944,10 @@ ProcPanoramiXQueryVersion (ClientPtr client)
     rep.majorVersion = SERVER_PANORAMIX_MAJOR_VERSION;
     rep.minorVersion = SERVER_PANORAMIX_MINOR_VERSION;
     if (client->swapped) { 
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);     
-        swaps(&rep.majorVersion, n);
-        swaps(&rep.minorVersion, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swaps(&rep.majorVersion);
+        swaps(&rep.minorVersion);
     }
     WriteToClient(client, sizeof (xPanoramiXQueryVersionReply), (char *)&rep);
     return (client->noClientException);
@@ -960,7 +959,6 @@ ProcPanoramiXGetState(ClientPtr client)
 	REQUEST(xPanoramiXGetStateReq);
     	WindowPtr			pWin;
 	xPanoramiXGetStateReply		rep;
-	register int			n;
 	
 	REQUEST_SIZE_MATCH(xPanoramiXGetStateReq);
 	pWin = LookupWindow (stuff->window, client);
@@ -971,9 +969,9 @@ ProcPanoramiXGetState(ClientPtr client)
 	rep.sequenceNumber = client->sequence;
 	rep.state = !noPanoramiXExtension;
     	if (client->swapped) {
-	    swaps (&rep.sequenceNumber, n);
-	    swapl (&rep.length, n);
-	    swaps (&rep.state, n);
+	    swaps (&rep.sequenceNumber);
+	    swapl (&rep.length);
+	    swapl ((int* )&rep.state);
 	}	
 	WriteToClient (client, sizeof (xPanoramiXGetStateReply), (char *) &rep);
 	return client->noClientException;
@@ -986,7 +984,6 @@ ProcPanoramiXGetScreenCount(ClientPtr client)
 	REQUEST(xPanoramiXGetScreenCountReq);
     	WindowPtr			pWin;
 	xPanoramiXGetScreenCountReply	rep;
-	register int			n;
 
 	REQUEST_SIZE_MATCH(xPanoramiXGetScreenCountReq);
 	pWin = LookupWindow (stuff->window, client);
@@ -997,9 +994,9 @@ ProcPanoramiXGetScreenCount(ClientPtr client)
 	rep.sequenceNumber = client->sequence;
 	rep.ScreenCount = PanoramiXNumScreens;
     	if (client->swapped) {
-	    swaps (&rep.sequenceNumber, n);
-	    swapl (&rep.length, n);
-	    swaps (&rep.ScreenCount, n);
+	    swaps (&rep.sequenceNumber);
+	    swapl (&rep.length);
+	    swapl ((int* )&rep.ScreenCount);
 	}	
 	WriteToClient (client, sizeof (xPanoramiXGetScreenCountReply), (char *) &rep);
 	return client->noClientException;
@@ -1011,7 +1008,6 @@ ProcPanoramiXGetScreenSize(ClientPtr client)
 	REQUEST(xPanoramiXGetScreenSizeReq);
     	WindowPtr			pWin;
 	xPanoramiXGetScreenSizeReply	rep;
-	register int			n;
 	
 	REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
 	pWin = LookupWindow (stuff->window, client);
@@ -1024,10 +1020,10 @@ ProcPanoramiXGetScreenSize(ClientPtr client)
 	rep.width  = panoramiXdataPtr[stuff->screen].width; 
 	rep.height = panoramiXdataPtr[stuff->screen].height; 
     	if (client->swapped) {
-	    swaps (&rep.sequenceNumber, n);
-	    swapl (&rep.length, n);
-	    swaps (&rep.width, n);
-	    swaps (&rep.height, n);
+	    swaps (&rep.sequenceNumber);
+	    swapl (&rep.length);
+	    swapl (&rep.width);
+	    swapl (&rep.height);
 	}	
 	WriteToClient (client, sizeof (xPanoramiXGetScreenSizeReply), (char *) &rep);
 	return client->noClientException;
@@ -1047,10 +1043,9 @@ ProcXineramaIsActive(ClientPtr client)
     rep.sequenceNumber = client->sequence;
     rep.state = !noPanoramiXExtension;
     if (client->swapped) {
-	register int n;
-	swaps (&rep.sequenceNumber, n);
-	swapl (&rep.length, n);
-	swapl (&rep.state, n);
+	swaps (&rep.sequenceNumber);
+	swapl (&rep.length);
+	swapl (&rep.state);
     }	
     WriteToClient (client, sizeof (xXineramaIsActiveReply), (char *) &rep);
     return client->noClientException;
@@ -1070,10 +1065,9 @@ ProcXineramaQueryScreens(ClientPtr client)
     rep.number = (noPanoramiXExtension) ? 0 : PanoramiXNumScreens;
     rep.length = rep.number * sz_XineramaScreenInfo >> 2;
     if (client->swapped) {
-	register int n;
-	swaps (&rep.sequenceNumber, n);
-	swapl (&rep.length, n);
-	swapl (&rep.number, n);
+	swaps (&rep.sequenceNumber);
+	swapl (&rep.length);
+	swapl (&rep.number);
     }	
     WriteToClient (client, sizeof (xXineramaQueryScreensReply), (char *) &rep);
 
@@ -1088,11 +1082,10 @@ ProcXineramaQueryScreens(ClientPtr client)
 	    scratch.height = panoramiXdataPtr[i].height;
 	
 	    if(client->swapped) {
-		register int n;
-		swaps (&scratch.x_org, n);
-		swaps (&scratch.y_org, n);
-		swaps (&scratch.width, n);
-		swaps (&scratch.height, n);
+		swaps (&scratch.x_org);
+		swaps (&scratch.y_org);
+		swaps (&scratch.width);
+		swaps (&scratch.height);
 	    }
 	    WriteToClient (client, sz_XineramaScreenInfo, (char *) &scratch);
 	}
diff --git a/nx-X11/programs/Xserver/Xext/panoramiXSwap.c b/nx-X11/programs/Xserver/Xext/panoramiXSwap.c
index 76346fa34..5ea3bf3a6 100644
--- a/nx-X11/programs/Xserver/Xext/panoramiXSwap.c
+++ b/nx-X11/programs/Xserver/Xext/panoramiXSwap.c
@@ -57,9 +57,8 @@ static int
 SProcPanoramiXQueryVersion (ClientPtr client)
 {
 	REQUEST(xPanoramiXQueryVersionReq);
-	register int n;
 
-	swaps(&stuff->length,n);
+	swaps(&stuff->length);
 	REQUEST_SIZE_MATCH (xPanoramiXQueryVersionReq);
 	return ProcPanoramiXQueryVersion(client);
 }
@@ -68,9 +67,8 @@ static int
 SProcPanoramiXGetState(ClientPtr client)
 {
 	REQUEST(xPanoramiXGetStateReq);
-	register int n;
 
- 	swaps (&stuff->length, n);	
+	swaps (&stuff->length);
 	REQUEST_SIZE_MATCH(xPanoramiXGetStateReq);
 	return ProcPanoramiXGetState(client);
 }
@@ -79,9 +77,8 @@ static int
 SProcPanoramiXGetScreenCount(ClientPtr client)
 {
 	REQUEST(xPanoramiXGetScreenCountReq);
-	register int n;
 
-	swaps (&stuff->length, n);
+	swaps (&stuff->length);
 	REQUEST_SIZE_MATCH(xPanoramiXGetScreenCountReq);
 	return ProcPanoramiXGetScreenCount(client);
 }
@@ -90,9 +87,8 @@ static int
 SProcPanoramiXGetScreenSize(ClientPtr client)
 {
 	REQUEST(xPanoramiXGetScreenSizeReq);
-	register int n;
 
-	swaps (&stuff->length, n);
+	swaps (&stuff->length);
 	REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
 	return ProcPanoramiXGetScreenSize(client);
 }
@@ -102,9 +98,8 @@ static int
 SProcXineramaIsActive(ClientPtr client)
 {
 	REQUEST(xXineramaIsActiveReq);
-	register int n;
 
-	swaps (&stuff->length, n);
+	swaps (&stuff->length);
 	REQUEST_SIZE_MATCH(xXineramaIsActiveReq);
 	return ProcXineramaIsActive(client);
 }
@@ -114,9 +109,8 @@ static int
 SProcXineramaQueryScreens(ClientPtr client)
 {
 	REQUEST(xXineramaQueryScreensReq);
-	register int n;
 
-	swaps (&stuff->length, n);
+	swaps (&stuff->length);
 	REQUEST_SIZE_MATCH(xXineramaQueryScreensReq);
 	return ProcXineramaQueryScreens(client);
 }
diff --git a/nx-X11/programs/Xserver/Xext/saver.c b/nx-X11/programs/Xserver/Xext/saver.c
index f9a86899f..1f78be9c8 100644
--- a/nx-X11/programs/Xserver/Xext/saver.c
+++ b/nx-X11/programs/Xserver/Xext/saver.c
@@ -490,9 +490,9 @@ SScreenSaverNotifyEvent (from, to)
     to->type = from->type;
     to->state = from->state;
     cpswaps (from->sequenceNumber, to->sequenceNumber);
-    cpswapl (from->timestamp, to->timestamp);    
-    cpswapl (from->root, to->root);    
-    cpswapl (from->window, to->window);    
+    cpswapl (from->timestamp, to->timestamp);
+    cpswapl (from->root, to->root);
+    cpswapl (from->window, to->window);
     to->kind = from->kind;
     to->forced = from->forced;
 }
@@ -704,8 +704,8 @@ ProcScreenSaverQueryVersion (client)
     rep.majorVersion = SERVER_SAVER_MAJOR_VERSION;
     rep.minorVersion = SERVER_SAVER_MINOR_VERSION;
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-    	swapl(&rep.length, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
     }
     WriteToClient(client, sizeof (xScreenSaverQueryVersionReply), (char *)&rep);
     return (client->noClientException);
@@ -772,12 +772,12 @@ ProcScreenSaverQueryInfo (client)
 	rep.kind = ScreenSaverInternal;
     if (client->swapped)
     {
-	swaps (&rep.sequenceNumber, n);
-	swapl (&rep.length, n);
-	swapl (&rep.window, n);
-	swapl (&rep.tilOrSince, n);
-	swapl (&rep.idle, n);
-	swapl (&rep.eventMask, n);
+	swaps (&rep.sequenceNumber);
+	swapl (&rep.length);
+	swapl (&rep.window);
+	swapl (&rep.tilOrSince);
+	swapl (&rep.idle);
+	swapl (&rep.eventMask);
     }
     WriteToClient(client, sizeof (xScreenSaverQueryInfoReply), (char *)&rep);
     return (client->noClientException);
@@ -1331,7 +1331,7 @@ SProcScreenSaverQueryVersion (client)
     REQUEST(xScreenSaverQueryVersionReq);
     int	    n;
 
-    swaps (&stuff->length, n);
+    swaps (&stuff->length);
     REQUEST_SIZE_MATCH(xScreenSaverQueryVersionReq);
     return ProcScreenSaverQueryVersion (client);
 }
@@ -1343,9 +1343,9 @@ SProcScreenSaverQueryInfo (client)
     REQUEST(xScreenSaverQueryInfoReq);
     int	    n;
 
-    swaps (&stuff->length, n);
+    swaps (&stuff->length);
     REQUEST_SIZE_MATCH(xScreenSaverQueryInfoReq);
-    swapl (&stuff->drawable, n);
+    swapl (&stuff->drawable);
     return ProcScreenSaverQueryInfo (client);
 }
 
@@ -1356,10 +1356,10 @@ SProcScreenSaverSelectInput (client)
     REQUEST(xScreenSaverSelectInputReq);
     int	    n;
 
-    swaps (&stuff->length, n);
+    swaps (&stuff->length);
     REQUEST_SIZE_MATCH(xScreenSaverSelectInputReq);
-    swapl (&stuff->drawable, n);
-    swapl (&stuff->eventMask, n);
+    swapl (&stuff->drawable);
+    swapl (&stuff->eventMask);
     return ProcScreenSaverSelectInput (client);
 }
 
@@ -1370,16 +1370,16 @@ SProcScreenSaverSetAttributes (client)
     REQUEST(xScreenSaverSetAttributesReq);
     int	    n;
 
-    swaps (&stuff->length, n);
+    swaps (&stuff->length);
     REQUEST_AT_LEAST_SIZE(xScreenSaverSetAttributesReq);
-    swapl (&stuff->drawable, n);
-    swaps (&stuff->x, n);
-    swaps (&stuff->y, n);
-    swaps (&stuff->width, n);
-    swaps (&stuff->height, n);
-    swaps (&stuff->borderWidth, n);
-    swapl (&stuff->visualID, n);
-    swapl (&stuff->mask, n);
+    swapl (&stuff->drawable);
+    swaps (&stuff->x);
+    swaps (&stuff->y);
+    swaps (&stuff->width);
+    swaps (&stuff->height);
+    swaps (&stuff->borderWidth);
+    swapl (&stuff->visualID);
+    swapl (&stuff->mask);
     SwapRestL(stuff);
     return ProcScreenSaverSetAttributes (client);
 }
@@ -1391,9 +1391,9 @@ SProcScreenSaverUnsetAttributes (client)
     REQUEST(xScreenSaverUnsetAttributesReq);
     int	    n;
 
-    swaps (&stuff->length, n);
+    swaps (&stuff->length);
     REQUEST_SIZE_MATCH(xScreenSaverUnsetAttributesReq);
-    swapl (&stuff->drawable, n);
+    swapl (&stuff->drawable);
     return ProcScreenSaverUnsetAttributes (client);
 }
 
diff --git a/nx-X11/programs/Xserver/Xext/security.c b/nx-X11/programs/Xserver/Xext/security.c
index a68cbf998..14fa1ce0e 100644
--- a/nx-X11/programs/Xserver/Xext/security.c
+++ b/nx-X11/programs/Xserver/Xext/security.c
@@ -491,10 +491,9 @@ ProcSecurityQueryVersion(
     rep.minorVersion  	= SERVER_SECURITY_MINOR_VERSION;
     if(client->swapped)
     {
-	register char n;
-    	swaps(&rep.sequenceNumber, n);
-	swaps(&rep.majorVersion, n);
-	swaps(&rep.minorVersion, n);
+	swaps(&rep.sequenceNumber);
+	swaps(&rep.majorVersion);
+	swaps(&rep.minorVersion);
     }
     (void)WriteToClient(client, SIZEOF(xSecurityQueryVersionReply),
 			(char *)&rep);
@@ -709,11 +708,10 @@ ProcSecurityGenerateAuthorization(
 
     if (client->swapped)
     {
-	register char n;
-    	swapl(&rep.length, n);
-    	swaps(&rep.sequenceNumber, n);
-    	swapl(&rep.authId, n);
-    	swaps(&rep.dataLength, n);
+	swapl(&rep.length);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.authId);
+	swaps(&rep.dataLength);
     }
 
     WriteToClient(client, SIZEOF(xSecurityGenerateAuthorizationReply),
@@ -788,12 +786,11 @@ SProcSecurityQueryVersion(
     ClientPtr client)
 {
     REQUEST(xSecurityQueryVersionReq);
-    register char 	n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xSecurityQueryVersionReq);
-    swaps(&stuff->majorVersion, n);
-    swaps(&stuff->minorVersion,n);
+    swaps(&stuff->majorVersion);
+    swaps(&stuff->minorVersion);
     return ProcSecurityQueryVersion(client);
 } /* SProcSecurityQueryVersion */
 
@@ -803,16 +800,15 @@ SProcSecurityGenerateAuthorization(
     ClientPtr client)
 {
     REQUEST(xSecurityGenerateAuthorizationReq);
-    register char 	n;
     CARD32 *values;
     unsigned long nvalues;
     int values_offset;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xSecurityGenerateAuthorizationReq);
-    swaps(&stuff->nbytesAuthProto, n);
-    swaps(&stuff->nbytesAuthData, n);
-    swapl(&stuff->valueMask, n);
+    swaps(&stuff->nbytesAuthProto);
+    swaps(&stuff->nbytesAuthData);
+    swapl(&stuff->valueMask);
     values_offset = ((stuff->nbytesAuthProto + (unsigned)3) >> 2) +
 		    ((stuff->nbytesAuthData + (unsigned)3) >> 2);
     if (values_offset > 
@@ -830,11 +826,10 @@ SProcSecurityRevokeAuthorization(
     ClientPtr client)
 {
     REQUEST(xSecurityRevokeAuthorizationReq);
-    register char 	n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xSecurityRevokeAuthorizationReq);
-    swapl(&stuff->authId, n);
+    swapl(&stuff->authId);
     return ProcSecurityRevokeAuthorization(client);
 } /* SProcSecurityRevokeAuthorization */
 
diff --git a/nx-X11/programs/Xserver/Xext/shape.c b/nx-X11/programs/Xserver/Xext/shape.c
index b929dded0..07fa62018 100644
--- a/nx-X11/programs/Xserver/Xext/shape.c
+++ b/nx-X11/programs/Xserver/Xext/shape.c
@@ -289,7 +289,6 @@ ProcShapeQueryVersion (client)
     register ClientPtr	client;
 {
     xShapeQueryVersionReply	rep;
-    register int		n;
 
     REQUEST_SIZE_MATCH (xShapeQueryVersionReq);
     memset(&rep, 0, sizeof(xShapeQueryVersionReply));
@@ -299,10 +298,10 @@ ProcShapeQueryVersion (client)
     rep.majorVersion = SERVER_SHAPE_MAJOR_VERSION;
     rep.minorVersion = SERVER_SHAPE_MINOR_VERSION;
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-    	swapl(&rep.length, n);
-	swaps(&rep.majorVersion, n);
-	swaps(&rep.minorVersion, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swaps(&rep.majorVersion);
+	swaps(&rep.minorVersion);
     }
     WriteToClient(client, sizeof (xShapeQueryVersionReply), (char *)&rep);
     return (client->noClientException);
@@ -714,7 +713,6 @@ ProcShapeQueryExtents (client)
     WindowPtr		pWin;
     xShapeQueryExtentsReply	rep;
     BoxRec		extents, *pExtents;
-    register int	n;
     RegionPtr		region;
 
     REQUEST_SIZE_MATCH (xShapeQueryExtentsReq);
@@ -756,16 +754,16 @@ ProcShapeQueryExtents (client)
     rep.widthClipShape = extents.x2 - extents.x1;
     rep.heightClipShape = extents.y2 - extents.y1;
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-    	swapl(&rep.length, n);
-	swaps(&rep.xBoundingShape, n);
-	swaps(&rep.yBoundingShape, n);
-	swaps(&rep.widthBoundingShape, n);
-	swaps(&rep.heightBoundingShape, n);
-	swaps(&rep.xClipShape, n);
-	swaps(&rep.yClipShape, n);
-	swaps(&rep.widthClipShape, n);
-	swaps(&rep.heightClipShape, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swaps(&rep.xBoundingShape);
+	swaps(&rep.yBoundingShape);
+	swaps(&rep.widthBoundingShape);
+	swaps(&rep.heightBoundingShape);
+	swaps(&rep.xClipShape);
+	swaps(&rep.yClipShape);
+	swaps(&rep.widthClipShape);
+	swaps(&rep.heightClipShape);
     }
     WriteToClient(client, sizeof (xShapeQueryExtentsReply), (char *)&rep);
     return (client->noClientException);
@@ -998,7 +996,6 @@ ProcShapeInputSelected (client)
     ShapeEventPtr	pShapeEvent, *pHead;
     int			enabled;
     xShapeInputSelectedReply	rep;
-    register int		n;
 
     REQUEST_SIZE_MATCH (xShapeInputSelectedReq);
     pWin = LookupWindow (stuff->window, client);
@@ -1023,8 +1020,8 @@ ProcShapeInputSelected (client)
     rep.sequenceNumber = client->sequence;
     rep.enabled = enabled;
     if (client->swapped) {
-	swaps (&rep.sequenceNumber, n);
-	swapl (&rep.length, n);
+	swaps (&rep.sequenceNumber);
+	swapl (&rep.length);
     }
     WriteToClient (client, sizeof (xShapeInputSelectedReply), (char *) &rep);
     return (client->noClientException);
@@ -1040,7 +1037,6 @@ ProcShapeGetRectangles (client)
     xRectangle			*rects;
     int				nrects, i;
     RegionPtr			region;
-    register int		n;
 
     REQUEST_SIZE_MATCH(xShapeGetRectanglesReq);
     pWin = LookupWindow (stuff->window, client);
@@ -1105,9 +1101,9 @@ ProcShapeGetRectangles (client)
     rep.ordering = YXBanded;
     rep.nrects = nrects;
     if (client->swapped) {
-	swaps (&rep.sequenceNumber, n);
-	swapl (&rep.length, n);
-	swapl (&rep.nrects, n);
+	swaps (&rep.sequenceNumber);
+	swapl (&rep.length);
+	swapl (&rep.nrects);
 	SwapShorts ((short *)rects, (unsigned long)nrects * 4);
     }
     WriteToClient (client, sizeof (rep), (char *) &rep);
@@ -1185,10 +1181,9 @@ static int
 SProcShapeQueryVersion (client)
     register ClientPtr	client;
 {
-    register int    n;
     REQUEST (xShapeQueryVersionReq);
 
-    swaps (&stuff->length, n);
+    swaps (&stuff->length);
     return ProcShapeQueryVersion (client);
 }
 
@@ -1196,14 +1191,13 @@ static int
 SProcShapeRectangles (client)
     register ClientPtr	client;
 {
-    register char   n;
     REQUEST (xShapeRectanglesReq);
 
-    swaps (&stuff->length, n);
+    swaps (&stuff->length);
     REQUEST_AT_LEAST_SIZE (xShapeRectanglesReq);
-    swapl (&stuff->dest, n);
-    swaps (&stuff->xOff, n);
-    swaps (&stuff->yOff, n);
+    swapl (&stuff->dest);
+    swaps (&stuff->xOff);
+    swaps (&stuff->yOff);
     SwapRestS(stuff);
     return ProcShapeRectangles (client);
 }
@@ -1212,15 +1206,14 @@ static int
 SProcShapeMask (client)
     register ClientPtr	client;
 {
-    register char   n;
     REQUEST (xShapeMaskReq);
 
-    swaps (&stuff->length, n);
+    swaps (&stuff->length);
     REQUEST_SIZE_MATCH (xShapeMaskReq);
-    swapl (&stuff->dest, n);
-    swaps (&stuff->xOff, n);
-    swaps (&stuff->yOff, n);
-    swapl (&stuff->src, n);
+    swapl (&stuff->dest);
+    swaps (&stuff->xOff);
+    swaps (&stuff->yOff);
+    swapl (&stuff->src);
     return ProcShapeMask (client);
 }
 
@@ -1228,15 +1221,14 @@ static int
 SProcShapeCombine (client)
     register ClientPtr	client;
 {
-    register char   n;
     REQUEST (xShapeCombineReq);
 
-    swaps (&stuff->length, n);
+    swaps (&stuff->length);
     REQUEST_SIZE_MATCH (xShapeCombineReq);
-    swapl (&stuff->dest, n);
-    swaps (&stuff->xOff, n);
-    swaps (&stuff->yOff, n);
-    swapl (&stuff->src, n);
+    swapl (&stuff->dest);
+    swaps (&stuff->xOff);
+    swaps (&stuff->yOff);
+    swapl (&stuff->src);
     return ProcShapeCombine (client);
 }
 
@@ -1244,14 +1236,13 @@ static int
 SProcShapeOffset (client)
     register ClientPtr	client;
 {
-    register char   n;
     REQUEST (xShapeOffsetReq);
 
-    swaps (&stuff->length, n);
+    swaps (&stuff->length);
     REQUEST_SIZE_MATCH (xShapeOffsetReq);
-    swapl (&stuff->dest, n);
-    swaps (&stuff->xOff, n);
-    swaps (&stuff->yOff, n);
+    swapl (&stuff->dest);
+    swaps (&stuff->xOff);
+    swaps (&stuff->yOff);
     return ProcShapeOffset (client);
 }
 
@@ -1259,12 +1250,11 @@ static int
 SProcShapeQueryExtents (client)
     register ClientPtr	client;
 {
-    register char   n;
     REQUEST (xShapeQueryExtentsReq);
 
-    swaps (&stuff->length, n);
+    swaps (&stuff->length);
     REQUEST_SIZE_MATCH (xShapeQueryExtentsReq);
-    swapl (&stuff->window, n);
+    swapl (&stuff->window);
     return ProcShapeQueryExtents (client);
 }
 
@@ -1272,12 +1262,11 @@ static int
 SProcShapeSelectInput (client)
     register ClientPtr	client;
 {
-    register char   n;
     REQUEST (xShapeSelectInputReq);
 
-    swaps (&stuff->length, n);
+    swaps (&stuff->length);
     REQUEST_SIZE_MATCH (xShapeSelectInputReq);
-    swapl (&stuff->window, n);
+    swapl (&stuff->window);
     return ProcShapeSelectInput (client);
 }
 
@@ -1285,12 +1274,11 @@ static int
 SProcShapeInputSelected (client)
     register ClientPtr	client;
 {
-    register int    n;
     REQUEST (xShapeInputSelectedReq);
 
-    swaps (&stuff->length, n);
+    swaps (&stuff->length);
     REQUEST_SIZE_MATCH (xShapeInputSelectedReq);
-    swapl (&stuff->window, n);
+    swapl (&stuff->window);
     return ProcShapeInputSelected (client);
 }
 
@@ -1299,11 +1287,10 @@ SProcShapeGetRectangles (client)
     register ClientPtr	client;
 {
     REQUEST(xShapeGetRectanglesReq);
-    register char   n;
 
-    swaps (&stuff->length, n);
+    swaps (&stuff->length);
     REQUEST_SIZE_MATCH(xShapeGetRectanglesReq);
-    swapl (&stuff->window, n);
+    swapl (&stuff->window);
     return ProcShapeGetRectangles (client);
 }
 
diff --git a/nx-X11/programs/Xserver/Xext/shm.c b/nx-X11/programs/Xserver/Xext/shm.c
index af529e46f..902bee7a1 100644
--- a/nx-X11/programs/Xserver/Xext/shm.c
+++ b/nx-X11/programs/Xserver/Xext/shm.c
@@ -346,7 +346,6 @@ ProcShmQueryVersion(client)
     register ClientPtr client;
 {
     xShmQueryVersionReply rep;
-    register int n;
 
     REQUEST_SIZE_MATCH(xShmQueryVersionReq);
     memset(&rep, 0, sizeof(xShmQueryVersionReply));
@@ -360,12 +359,12 @@ ProcShmQueryVersion(client)
     rep.uid = geteuid();
     rep.gid = getegid();
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-    	swapl(&rep.length, n);
-	swaps(&rep.majorVersion, n);
-	swaps(&rep.minorVersion, n);
-	swaps(&rep.uid, n);
-	swaps(&rep.gid, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swaps(&rep.majorVersion);
+	swaps(&rep.minorVersion);
+	swaps(&rep.uid);
+	swaps(&rep.gid);
     }
     WriteToClient(client, sizeof(xShmQueryVersionReply), (char *)&rep);
     return (client->noClientException);
@@ -712,11 +711,10 @@ ProcPanoramiXShmGetImage(ClientPtr client)
     }
     
     if (client->swapped) {
-	register int n;
-    	swaps(&xgi.sequenceNumber, n);
-    	swapl(&xgi.length, n);
-	swapl(&xgi.visual, n);
-	swapl(&xgi.size, n);
+	swaps(&xgi.sequenceNumber);
+	swapl(&xgi.length);
+	swapl(&xgi.visual);
+	swapl(&xgi.size);
     }
     WriteToClient(client, sizeof(xShmGetImageReply), (char *)&xgi);
 
@@ -952,7 +950,6 @@ ProcShmGetImage(client)
     Mask		plane = 0;
     xShmGetImageReply	xgi;
     ShmDescPtr		shmdesc;
-    int			n;
 
     REQUEST(xShmGetImageReq);
 
@@ -1043,10 +1040,10 @@ ProcShmGetImage(client)
     }
     
     if (client->swapped) {
-    	swaps(&xgi.sequenceNumber, n);
-    	swapl(&xgi.length, n);
-	swapl(&xgi.visual, n);
-	swapl(&xgi.size, n);
+	swaps(&xgi.sequenceNumber);
+	swapl(&xgi.length);
+	swapl(&xgi.visual);
+	swapl(&xgi.size);
     }
     WriteToClient(client, sizeof(xShmGetImageReply), (char *)&xgi);
 
@@ -1205,10 +1202,9 @@ static int
 SProcShmQueryVersion(client)
     register ClientPtr	client;
 {
-    register int n;
     REQUEST(xShmQueryVersionReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     return ProcShmQueryVersion(client);
 }
 
@@ -1216,12 +1212,11 @@ static int
 SProcShmAttach(client)
     ClientPtr client;
 {
-    register int n;
     REQUEST(xShmAttachReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xShmAttachReq);
-    swapl(&stuff->shmseg, n);
-    swapl(&stuff->shmid, n);
+    swapl(&stuff->shmseg);
+    swapl(&stuff->shmid);
     return ProcShmAttach(client);
 }
 
@@ -1229,11 +1224,10 @@ static int
 SProcShmDetach(client)
     ClientPtr client;
 {
-    register int n;
     REQUEST(xShmDetachReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xShmDetachReq);
-    swapl(&stuff->shmseg, n);
+    swapl(&stuff->shmseg);
     return ProcShmDetach(client);
 }
 
@@ -1241,22 +1235,21 @@ static int
 SProcShmPutImage(client)
     ClientPtr client;
 {
-    register int n;
     REQUEST(xShmPutImageReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xShmPutImageReq);
-    swapl(&stuff->drawable, n);
-    swapl(&stuff->gc, n);
-    swaps(&stuff->totalWidth, n);
-    swaps(&stuff->totalHeight, n);
-    swaps(&stuff->srcX, n);
-    swaps(&stuff->srcY, n);
-    swaps(&stuff->srcWidth, n);
-    swaps(&stuff->srcHeight, n);
-    swaps(&stuff->dstX, n);
-    swaps(&stuff->dstY, n);
-    swapl(&stuff->shmseg, n);
-    swapl(&stuff->offset, n);
+    swapl(&stuff->drawable);
+    swapl(&stuff->gc);
+    swaps(&stuff->totalWidth);
+    swaps(&stuff->totalHeight);
+    swaps(&stuff->srcX);
+    swaps(&stuff->srcY);
+    swaps(&stuff->srcWidth);
+    swaps(&stuff->srcHeight);
+    swaps(&stuff->dstX);
+    swaps(&stuff->dstY);
+    swapl(&stuff->shmseg);
+    swapl(&stuff->offset);
     return ProcShmPutImage(client);
 }
 
@@ -1264,18 +1257,17 @@ static int
 SProcShmGetImage(client)
     ClientPtr client;
 {
-    register int n;
     REQUEST(xShmGetImageReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xShmGetImageReq);
-    swapl(&stuff->drawable, n);
-    swaps(&stuff->x, n);
-    swaps(&stuff->y, n);
-    swaps(&stuff->width, n);
-    swaps(&stuff->height, n);
-    swapl(&stuff->planeMask, n);
-    swapl(&stuff->shmseg, n);
-    swapl(&stuff->offset, n);
+    swapl(&stuff->drawable);
+    swaps(&stuff->x);
+    swaps(&stuff->y);
+    swaps(&stuff->width);
+    swaps(&stuff->height);
+    swapl(&stuff->planeMask);
+    swapl(&stuff->shmseg);
+    swapl(&stuff->offset);
     return ProcShmGetImage(client);
 }
 
@@ -1283,16 +1275,15 @@ static int
 SProcShmCreatePixmap(client)
     ClientPtr client;
 {
-    register int n;
     REQUEST(xShmCreatePixmapReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xShmCreatePixmapReq);
-    swapl(&stuff->pid, n);
-    swapl(&stuff->drawable, n);
-    swaps(&stuff->width, n);
-    swaps(&stuff->height, n);
-    swapl(&stuff->shmseg, n);
-    swapl(&stuff->offset, n);
+    swapl(&stuff->pid);
+    swapl(&stuff->drawable);
+    swaps(&stuff->width);
+    swaps(&stuff->height);
+    swapl(&stuff->shmseg);
+    swapl(&stuff->offset);
     return ProcShmCreatePixmap(client);
 }
 
diff --git a/nx-X11/programs/Xserver/Xext/sync.c b/nx-X11/programs/Xserver/Xext/sync.c
index aab85666e..8899b7c17 100644
--- a/nx-X11/programs/Xserver/Xext/sync.c
+++ b/nx-X11/programs/Xserver/Xext/sync.c
@@ -1343,7 +1343,6 @@ ProcSyncInitialize(client)
     ClientPtr       client;
 {
     xSyncInitializeReply  rep;
-    int   n;
 
     REQUEST_SIZE_MATCH(xSyncInitializeReq);
 
@@ -1356,7 +1355,7 @@ ProcSyncInitialize(client)
 
     if (client->swapped)
     {
-	swaps(&rep.sequenceNumber, n);
+	swaps(&rep.sequenceNumber);
     }
     WriteToClient(client, sizeof(rep), (char *) &rep);
     return (client->noClientException);
@@ -1397,10 +1396,9 @@ ProcSyncListSystemCounters(client)
 
     if (client->swapped)
     {
-	register char n;
-	swaps(&rep.sequenceNumber, n);
-	swapl(&rep.length, n);
-	swapl(&rep.nCounters, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swapl(&rep.nCounters);
     }
 
     for (i = 0; i < SyncNumSystemCounters; i++)
@@ -1417,11 +1415,10 @@ ProcSyncListSystemCounters(client)
 
 	if (client->swapped)
 	{
-	    register char n;
-	    swapl(&walklist->counter, n);
-	    swapl(&walklist->resolution_hi, n);
-	    swapl(&walklist->resolution_lo, n);
-	    swaps(&walklist->name_length, n);
+	    swapl(&walklist->counter);
+	    swapl(&walklist->resolution_hi);
+	    swapl(&walklist->resolution_lo);
+	    swaps(&walklist->name_length);
 	}
 
 	pname_in_reply = ((char *)walklist) + sz_xSyncSystemCounter;
@@ -1502,9 +1499,8 @@ ProcSyncGetPriority(client)
 
     if (client->swapped)
     {
-	register char n;
-	swaps(&rep.sequenceNumber, n);
-	swapl(&rep.priority, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.priority);
     }
 
     WriteToClient(client, sizeof(xSyncGetPriorityReply), (char *) &rep);
@@ -1787,11 +1783,10 @@ ProcSyncQueryCounter(client)
     rep.value_lo = XSyncValueLow32(pCounter->value);
     if (client->swapped)
     {
-	register char n;
-	swaps(&rep.sequenceNumber, n);
-	swapl(&rep.length, n);
-	swapl(&rep.value_hi, n);
-	swapl(&rep.value_lo, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swapl(&rep.value_hi);
+	swapl(&rep.value_lo);
     }
     WriteToClient(client, sizeof(xSyncQueryCounterReply), (char *) &rep);
     return (client->noClientException);
@@ -1969,15 +1964,14 @@ ProcSyncQueryAlarm(client)
 
     if (client->swapped)
     {
-	register char n;
-	swaps(&rep.sequenceNumber, n);
-	swapl(&rep.length, n);
-	swapl(&rep.counter, n);
-	swapl(&rep.wait_value_hi, n);
-	swapl(&rep.wait_value_lo, n);
-	swapl(&rep.test_type, n);
-	swapl(&rep.delta_hi, n);
-	swapl(&rep.delta_lo, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swapl(&rep.counter);
+	swapl(&rep.wait_value_hi);
+	swapl(&rep.wait_value_lo);
+	swapl(&rep.test_type);
+	swapl(&rep.delta_hi);
+	swapl(&rep.delta_lo);
     }
 
     WriteToClient(client, sizeof(xSyncQueryAlarmReply), (char *) &rep);
@@ -2058,9 +2052,8 @@ SProcSyncInitialize(client)
     ClientPtr       client;
 {
     REQUEST(xSyncInitializeReq);
-    register char   n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH (xSyncInitializeReq);
 
     return ProcSyncInitialize(client);
@@ -2071,9 +2064,8 @@ SProcSyncListSystemCounters(client)
     ClientPtr       client;
 {
     REQUEST(xSyncListSystemCountersReq);
-    register char   n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH (xSyncListSystemCountersReq);
 
     return ProcSyncListSystemCounters(client);
@@ -2084,13 +2076,12 @@ SProcSyncCreateCounter(client)
     ClientPtr       client;
 {
     REQUEST(xSyncCreateCounterReq);
-    register char   n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH (xSyncCreateCounterReq);
-    swapl(&stuff->cid, n);
-    swapl(&stuff->initial_value_lo, n);
-    swapl(&stuff->initial_value_hi, n);
+    swapl(&stuff->cid);
+    swapl(&stuff->initial_value_lo);
+    swapl(&stuff->initial_value_hi);
 
     return ProcSyncCreateCounter(client);
 }
@@ -2100,13 +2091,12 @@ SProcSyncSetCounter(client)
     ClientPtr       client;
 {
     REQUEST(xSyncSetCounterReq);
-    register char   n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH (xSyncSetCounterReq);
-    swapl(&stuff->cid, n);
-    swapl(&stuff->value_lo, n);
-    swapl(&stuff->value_hi, n);
+    swapl(&stuff->cid);
+    swapl(&stuff->value_lo);
+    swapl(&stuff->value_hi);
 
     return ProcSyncSetCounter(client);
 }
@@ -2116,13 +2106,12 @@ SProcSyncChangeCounter(client)
     ClientPtr       client;
 {
     REQUEST(xSyncChangeCounterReq);
-    register char   n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH (xSyncChangeCounterReq);
-    swapl(&stuff->cid, n);
-    swapl(&stuff->value_lo, n);
-    swapl(&stuff->value_hi, n);
+    swapl(&stuff->cid);
+    swapl(&stuff->value_lo);
+    swapl(&stuff->value_hi);
 
     return ProcSyncChangeCounter(client);
 }
@@ -2132,11 +2121,10 @@ SProcSyncQueryCounter(client)
     ClientPtr       client;
 {
     REQUEST(xSyncQueryCounterReq);
-    register char   n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH (xSyncQueryCounterReq);
-    swapl(&stuff->counter, n);
+    swapl(&stuff->counter);
 
     return ProcSyncQueryCounter(client);
 }
@@ -2146,11 +2134,10 @@ SProcSyncDestroyCounter(client)
     ClientPtr       client;
 {
     REQUEST(xSyncDestroyCounterReq);
-    register char   n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH (xSyncDestroyCounterReq);
-    swapl(&stuff->counter, n);
+    swapl(&stuff->counter);
 
     return ProcSyncDestroyCounter(client);
 }
@@ -2160,9 +2147,8 @@ SProcSyncAwait(client)
     ClientPtr       client;
 {
     REQUEST(xSyncAwaitReq);
-    register char   n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xSyncAwaitReq);
     SwapRestL(stuff);
 
@@ -2175,12 +2161,11 @@ SProcSyncCreateAlarm(client)
     ClientPtr       client;
 {
     REQUEST(xSyncCreateAlarmReq);
-    register char   n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xSyncCreateAlarmReq);
-    swapl(&stuff->id, n);
-    swapl(&stuff->valueMask, n);
+    swapl(&stuff->id);
+    swapl(&stuff->valueMask);
     SwapRestL(stuff);
 
     return ProcSyncCreateAlarm(client);
@@ -2191,12 +2176,11 @@ SProcSyncChangeAlarm(client)
     ClientPtr       client;
 {
     REQUEST(xSyncChangeAlarmReq);
-    register char   n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xSyncChangeAlarmReq);
-    swapl(&stuff->alarm, n);
-    swapl(&stuff->valueMask, n);
+    swapl(&stuff->alarm);
+    swapl(&stuff->valueMask);
     SwapRestL(stuff);
     return ProcSyncChangeAlarm(client);
 }
@@ -2206,11 +2190,10 @@ SProcSyncQueryAlarm(client)
     ClientPtr       client;
 {
     REQUEST(xSyncQueryAlarmReq);
-    register char   n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH (xSyncQueryAlarmReq);
-    swapl(&stuff->alarm, n);
+    swapl(&stuff->alarm);
 
     return ProcSyncQueryAlarm(client);
 }
@@ -2220,11 +2203,10 @@ SProcSyncDestroyAlarm(client)
     ClientPtr       client;
 {
     REQUEST(xSyncDestroyAlarmReq);
-    register char   n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH (xSyncDestroyAlarmReq);
-    swapl(&stuff->alarm, n);
+    swapl(&stuff->alarm);
 
     return ProcSyncDestroyAlarm(client);
 }
@@ -2234,12 +2216,11 @@ SProcSyncSetPriority(client)
     ClientPtr       client;
 {
     REQUEST(xSyncSetPriorityReq);
-    register char   n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH (xSyncSetPriorityReq);
-    swapl(&stuff->id, n);
-    swapl(&stuff->priority, n);
+    swapl(&stuff->id);
+    swapl(&stuff->priority);
 
     return ProcSyncSetPriority(client);
 }
@@ -2249,11 +2230,10 @@ SProcSyncGetPriority(client)
     ClientPtr       client;
 {
     REQUEST(xSyncGetPriorityReq);
-    register char   n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH (xSyncGetPriorityReq);
-    swapl(&stuff->id, n);
+    swapl(&stuff->id);
 
     return ProcSyncGetPriority(client);
 }
diff --git a/nx-X11/programs/Xserver/Xext/xcmisc.c b/nx-X11/programs/Xserver/Xext/xcmisc.c
index 7021ed47e..bca5bca34 100644
--- a/nx-X11/programs/Xserver/Xext/xcmisc.c
+++ b/nx-X11/programs/Xserver/Xext/xcmisc.c
@@ -98,7 +98,6 @@ ProcXCMiscGetVersion(client)
     register ClientPtr client;
 {
     xXCMiscGetVersionReply rep;
-    register int n;
 
     REQUEST_SIZE_MATCH(xXCMiscGetVersionReq);
     rep.type = X_Reply;
@@ -107,9 +106,9 @@ ProcXCMiscGetVersion(client)
     rep.majorVersion = XCMiscMajorVersion;
     rep.minorVersion = XCMiscMinorVersion;
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-	swaps(&rep.majorVersion, n);
-	swaps(&rep.minorVersion, n);
+	swaps(&rep.sequenceNumber);
+	swaps(&rep.majorVersion);
+	swaps(&rep.minorVersion);
     }
     WriteToClient(client, sizeof(xXCMiscGetVersionReply), (char *)&rep);
     return(client->noClientException);
@@ -120,7 +119,6 @@ ProcXCMiscGetXIDRange(client)
     register ClientPtr client;
 {
     xXCMiscGetXIDRangeReply rep;
-    register int n;
     XID min_id, max_id;
 
     REQUEST_SIZE_MATCH(xXCMiscGetXIDRangeReq);
@@ -131,9 +129,9 @@ ProcXCMiscGetXIDRange(client)
     rep.start_id = min_id;
     rep.count = max_id - min_id + 1;
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-	swapl(&rep.start_id, n);
-	swapl(&rep.count, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.start_id);
+	swapl(&rep.count);
     }
     WriteToClient(client, sizeof(xXCMiscGetXIDRangeReply), (char *)&rep);
     return(client->noClientException);
@@ -145,7 +143,6 @@ ProcXCMiscGetXIDList(client)
 {
     REQUEST(xXCMiscGetXIDListReq);
     xXCMiscGetXIDListReply rep;
-    register int n;
     XID *pids;
     unsigned int count;
 
@@ -165,9 +162,9 @@ ProcXCMiscGetXIDList(client)
     rep.length = count;
     rep.count = count;
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-	swapl(&rep.length, n);
-	swapl(&rep.count, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swapl(&rep.count);
     }
     WriteToClient(client, sizeof(xXCMiscGetXIDListReply), (char *)&rep);
     if (count)
@@ -201,13 +198,12 @@ static int
 SProcXCMiscGetVersion(client)
     register ClientPtr	client;
 {
-    register int n;
     REQUEST(xXCMiscGetVersionReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXCMiscGetVersionReq);
-    swaps(&stuff->majorVersion, n);
-    swaps(&stuff->minorVersion, n);
+    swaps(&stuff->majorVersion);
+    swaps(&stuff->minorVersion);
     return ProcXCMiscGetVersion(client);
 }
 
@@ -215,10 +211,9 @@ static int
 SProcXCMiscGetXIDRange(client)
     register ClientPtr	client;
 {
-    register int n;
     REQUEST(xReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     return ProcXCMiscGetXIDRange(client);
 }
 
@@ -226,12 +221,11 @@ static int
 SProcXCMiscGetXIDList(client)
     register ClientPtr	client;
 {
-    register int n;
     REQUEST(xXCMiscGetXIDListReq);
     REQUEST_SIZE_MATCH(xXCMiscGetXIDListReq);
 
-    swaps(&stuff->length, n);
-    swapl(&stuff->count, n);
+    swaps(&stuff->length);
+    swapl(&stuff->count);
     return ProcXCMiscGetXIDList(client);
 }
 
diff --git a/nx-X11/programs/Xserver/Xext/xf86bigfont.c b/nx-X11/programs/Xserver/Xext/xf86bigfont.c
index a89005cde..18c96db13 100644
--- a/nx-X11/programs/Xserver/Xext/xf86bigfont.c
+++ b/nx-X11/programs/Xserver/Xext/xf86bigfont.c
@@ -375,14 +375,13 @@ ProcXF86BigfontQueryVersion(
 #endif
 	; /* may add more bits here in future versions */
     if (client->swapped) {
-	char tmp;
-	swaps(&reply.sequenceNumber, tmp);
-	swapl(&reply.length, tmp);
-	swaps(&reply.majorVersion, tmp);
-	swaps(&reply.minorVersion, tmp);
-	swapl(&reply.uid, tmp);
-	swapl(&reply.gid, tmp);
-	swapl(&reply.signature, tmp);
+	swaps(&reply.sequenceNumber);
+	swapl(&reply.length);
+	swaps(&reply.majorVersion);
+	swaps(&reply.minorVersion);
+	swapl(&reply.uid);
+	swapl(&reply.gid);
+	swapl(&reply.signature);
     }
     WriteToClient(client,
 		  sizeof(xXF86BigfontQueryVersionReply), (char *)&reply);
@@ -393,14 +392,12 @@ static void
 swapCharInfo(
     xCharInfo *pCI)
 {
-    char tmp;
-
-    swaps(&pCI->leftSideBearing, tmp);
-    swaps(&pCI->rightSideBearing, tmp);
-    swaps(&pCI->characterWidth, tmp);
-    swaps(&pCI->ascent, tmp);
-    swaps(&pCI->descent, tmp);
-    swaps(&pCI->attributes, tmp);
+    swaps(&pCI->leftSideBearing);
+    swaps(&pCI->rightSideBearing);
+    swaps(&pCI->characterWidth);
+    swaps(&pCI->ascent);
+    swaps(&pCI->descent);
+    swaps(&pCI->attributes);
 }
 
 /* static CARD32 hashCI (xCharInfo *p); */
@@ -671,21 +668,20 @@ ProcXF86BigfontQueryFont(
 	reply->shmid = shmid;
 	reply->shmsegoffset = 0;
 	if (client->swapped) {
-	    char tmp;
-	    swaps(&reply->sequenceNumber, tmp);
-	    swapl(&reply->length, tmp);
+	    swaps(&reply->sequenceNumber);
+	    swapl(&reply->length);
 	    swapCharInfo(&reply->minBounds);
 	    swapCharInfo(&reply->maxBounds);
-	    swaps(&reply->minCharOrByte2, tmp);
-	    swaps(&reply->maxCharOrByte2, tmp);
-	    swaps(&reply->defaultChar, tmp);
-	    swaps(&reply->nFontProps, tmp);
-	    swaps(&reply->fontAscent, tmp);
-	    swaps(&reply->fontDescent, tmp);
-	    swapl(&reply->nCharInfos, tmp);
-	    swapl(&reply->nUniqCharInfos, tmp);
-	    swapl(&reply->shmid, tmp);
-	    swapl(&reply->shmsegoffset, tmp);
+	    swaps(&reply->minCharOrByte2);
+	    swaps(&reply->maxCharOrByte2);
+	    swaps(&reply->defaultChar);
+	    swaps(&reply->nFontProps);
+	    swaps(&reply->fontAscent);
+	    swaps(&reply->fontDescent);
+	    swapl(&reply->nCharInfos);
+	    swapl(&reply->nUniqCharInfos);
+	    swapl(&reply->shmid);
+	    swapl(&reply->shmsegoffset);
 	}
 	p = (char*) &reply[1];
 	{
@@ -698,9 +694,8 @@ ProcXF86BigfontQueryFont(
 		prFP->name = pFP->name;
 		prFP->value = pFP->value;
 		if (client->swapped) {
-		    char tmp;
-		    swapl(&prFP->name, tmp);
-		    swapl(&prFP->value, tmp);
+		    swapl(&prFP->name);
+		    swapl(&prFP->value);
 		}
 	    }
 	    p = (char*) prFP;
@@ -719,8 +714,7 @@ ProcXF86BigfontQueryFont(
 	    for (j = 0; j < nCharInfos; j++, ps++) {
 		*ps = pIndex2UniqIndex[j];
 		if (client->swapped) {
-		    char tmp;
-		    swaps(ps, tmp);
+		    swaps(ps);
 		}
 	    }
 	}
@@ -755,9 +749,8 @@ SProcXF86BigfontQueryVersion(
     ClientPtr client)
 {
     REQUEST(xXF86BigfontQueryVersionReq);
-    char tmp;
 
-    swaps(&stuff->length, tmp);
+    swaps(&stuff->length);
     return ProcXF86BigfontQueryVersion(client);
 }
 
@@ -766,11 +759,10 @@ SProcXF86BigfontQueryFont(
     ClientPtr client)
 {
     REQUEST(xXF86BigfontQueryFontReq);
-    char tmp;
 
-    swaps(&stuff->length, tmp);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86BigfontQueryFontReq);
-    swapl(&stuff->id, tmp);
+    swapl(&stuff->id);
     return ProcXF86BigfontQueryFont(client);
 }
 
diff --git a/nx-X11/programs/Xserver/Xext/xres.c b/nx-X11/programs/Xserver/Xext/xres.c
index 3d5ae162c..d78fa68e1 100644
--- a/nx-X11/programs/Xserver/Xext/xres.c
+++ b/nx-X11/programs/Xserver/Xext/xres.c
@@ -27,26 +27,19 @@ ProcXResQueryVersion (ClientPtr client)
 {
     REQUEST(xXResQueryVersionReq);
     xXResQueryVersionReply rep;
-    CARD16 client_major, client_minor;  /* not used */
 
     REQUEST_SIZE_MATCH (xXResQueryVersionReq);
 
-    client_major = stuff->client_major;
-    client_minor = stuff->client_minor;
-    (void) client_major;
-    (void) client_minor;
-
     rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
     rep.server_major = SERVER_XRES_MAJOR_VERSION;
     rep.server_minor = SERVER_XRES_MINOR_VERSION;
     if (client->swapped) { 
-        int n;
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);     
-        swaps(&rep.server_major, n);
-        swaps(&rep.server_minor, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swaps(&rep.server_major);
+        swaps(&rep.server_minor);
     }
     WriteToClient(client, sizeof (xXResQueryVersionReply), (char *)&rep);
     return (client->noClientException);
@@ -77,10 +70,9 @@ ProcXResQueryClients (ClientPtr client)
     rep.num_clients = num_clients;
     rep.length = rep.num_clients * sz_xXResClient >> 2;
     if (client->swapped) {
-        int n;
-        swaps (&rep.sequenceNumber, n);
-        swapl (&rep.length, n);
-        swapl (&rep.num_clients, n);
+        swaps (&rep.sequenceNumber);
+        swapl (&rep.length);
+        swapl (&rep.num_clients);
     }   
     WriteToClient (client, sizeof (xXResQueryClientsReply), (char *) &rep);
 
@@ -92,9 +84,8 @@ ProcXResQueryClients (ClientPtr client)
             scratch.resource_mask = RESOURCE_ID_MASK;
         
             if(client->swapped) {
-                register int n;
-                swapl (&scratch.resource_base, n);
-                swapl (&scratch.resource_mask, n);
+                swapl (&scratch.resource_base);
+                swapl (&scratch.resource_mask);
             }
             WriteToClient (client, sz_xXResClient, (char *) &scratch);
         }
@@ -150,10 +141,9 @@ ProcXResQueryClientResources (ClientPtr client)
     rep.num_types = num_types;
     rep.length = rep.num_types * sz_xXResType >> 2;
     if (client->swapped) {
-        int n;
-        swaps (&rep.sequenceNumber, n);
-        swapl (&rep.length, n);
-        swapl (&rep.num_types, n);
+        swaps (&rep.sequenceNumber);
+        swapl (&rep.length);
+        swapl (&rep.num_types);
     }   
     WriteToClient (client,sizeof(xXResQueryClientResourcesReply),(char*)&rep);
 
@@ -173,9 +163,8 @@ ProcXResQueryClientResources (ClientPtr client)
             scratch.count = counts[i];
 
             if(client->swapped) {
-                register int n;
-                swapl (&scratch.resource_type, n);
-                swapl (&scratch.count, n);
+                swapl (&scratch.resource_type);
+                swapl (&scratch.count);
             }
             WriteToClient (client, sz_xXResType, (char *) &scratch);
         }
@@ -229,11 +218,10 @@ ProcXResQueryClientPixmapBytes (ClientPtr client)
     rep.bytes_overflow = 0;
 #endif
     if (client->swapped) {
-        int n;
-        swaps (&rep.sequenceNumber, n);
-        swapl (&rep.length, n);
-        swapl (&rep.bytes, n);
-        swapl (&rep.bytes_overflow, n);
+        swaps (&rep.sequenceNumber);
+        swapl (&rep.length);
+        swapl (&rep.bytes);
+        swapl (&rep.bytes_overflow);
     }
     WriteToClient (client,sizeof(xXResQueryClientPixmapBytesReply),(char*)&rep);
 
@@ -266,12 +254,7 @@ ProcResDispatch (ClientPtr client)
 static int
 SProcXResQueryVersion (ClientPtr client)
 {
-    REQUEST(xXResQueryVersionReq);
-    int n;
-
     REQUEST_SIZE_MATCH (xXResQueryVersionReq);
-    swaps(&stuff->client_major,n);
-    swaps(&stuff->client_minor,n);
     return ProcXResQueryVersion(client);
 }
 
@@ -279,10 +262,9 @@ static int
 SProcXResQueryClientResources (ClientPtr client)
 {
     REQUEST(xXResQueryClientResourcesReq);
-    int n;
 
     REQUEST_SIZE_MATCH (xXResQueryClientResourcesReq);
-    swaps(&stuff->xid,n);
+    swapl(&stuff->xid);
     return ProcXResQueryClientResources(client);
 }
 
@@ -290,10 +272,9 @@ static int
 SProcXResQueryClientPixmapBytes (ClientPtr client)
 {
     REQUEST(xXResQueryClientPixmapBytesReq);
-    int n;
 
     REQUEST_SIZE_MATCH (xXResQueryClientPixmapBytesReq);
-    swaps(&stuff->xid,n);
+    swapl(&stuff->xid);
     return ProcXResQueryClientPixmapBytes(client);
 }
 
@@ -301,9 +282,8 @@ static int
 SProcResDispatch (ClientPtr client)
 {
     REQUEST(xReq);
-    int n;
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
 
     switch (stuff->data) {
     case X_XResQueryVersion:
diff --git a/nx-X11/programs/Xserver/Xext/xtest.c b/nx-X11/programs/Xserver/Xext/xtest.c
index 565e8e8d7..7dd668fdb 100644
--- a/nx-X11/programs/Xserver/Xext/xtest.c
+++ b/nx-X11/programs/Xserver/Xext/xtest.c
@@ -121,7 +121,6 @@ ProcXTestGetVersion(client)
     register ClientPtr client;
 {
     xXTestGetVersionReply rep;
-    register int n;
 
     REQUEST_SIZE_MATCH(xXTestGetVersionReq);
     rep.type = X_Reply;
@@ -130,8 +129,8 @@ ProcXTestGetVersion(client)
     rep.majorVersion = XTestMajorVersion;
     rep.minorVersion = XTestMinorVersion;
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-	swaps(&rep.minorVersion, n);
+	swaps(&rep.sequenceNumber);
+	swaps(&rep.minorVersion);
     }
     WriteToClient(client, sizeof(xXTestGetVersionReply), (char *)&rep);
     return(client->noClientException);
@@ -145,7 +144,6 @@ ProcXTestCompareCursor(client)
     xXTestCompareCursorReply rep;
     WindowPtr pWin;
     CursorPtr pCursor;
-    register int n;
 
     REQUEST_SIZE_MATCH(xXTestCompareCursorReq);
     pWin = (WindowPtr)LookupWindow(stuff->window, client);
@@ -168,7 +166,7 @@ ProcXTestCompareCursor(client)
     rep.sequenceNumber = client->sequence;
     rep.same = (wCursor(pWin) == pCursor);
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
+	swaps(&rep.sequenceNumber);
     }
     WriteToClient(client, sizeof(xXTestCompareCursorReply), (char *)&rep);
     return(client->noClientException);
@@ -180,7 +178,7 @@ ProcXTestFakeInput(client)
 {
     REQUEST(xXTestFakeInputReq);
     int nev;
-    int	n;
+    int        n;
     xEvent *ev;
     DeviceIntPtr dev = NULL;
     WindowPtr root;
@@ -285,7 +283,7 @@ ProcXTestFakeInput(client)
 	if (client->swapped)
 	{
     	    (void) XTestSwapFakeInput(client, (xReq *)stuff);
-	    swaps(&stuff->length, n);
+	    swaps(&stuff->length);
 	}
 	ResetCurrentRequest (client);
 	client->sequence--;
@@ -512,12 +510,11 @@ static int
 SProcXTestGetVersion(client)
     register ClientPtr	client;
 {
-    register int n;
     REQUEST(xXTestGetVersionReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXTestGetVersionReq);
-    swaps(&stuff->minorVersion, n);
+    swaps(&stuff->minorVersion);
     return ProcXTestGetVersion(client);
 }
 
@@ -525,13 +522,12 @@ static int
 SProcXTestCompareCursor(client)
     register ClientPtr	client;
 {
-    register int n;
     REQUEST(xXTestCompareCursorReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXTestCompareCursorReq);
-    swapl(&stuff->window, n);
-    swapl(&stuff->cursor, n);
+    swapl(&stuff->window);
+    swapl(&stuff->cursor);
     return ProcXTestCompareCursor(client);
 }
 
@@ -568,7 +564,7 @@ SProcXTestFakeInput(client)
     register int n;
     REQUEST(xReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     n = XTestSwapFakeInput(client, stuff);
     if (n != Success)
 	return n;
@@ -579,10 +575,9 @@ static int
 SProcXTestGrabControl(client)
     register ClientPtr	client;
 {
-    register int n;
     REQUEST(xXTestGrabControlReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXTestGrabControlReq);
     return ProcXTestGrabControl(client);
 }
diff --git a/nx-X11/programs/Xserver/Xext/xtest1di.c b/nx-X11/programs/Xserver/Xext/xtest1di.c
index e7c3522ba..554f336b2 100644
--- a/nx-X11/programs/Xserver/Xext/xtest1di.c
+++ b/nx-X11/programs/Xserver/Xext/xtest1di.c
@@ -318,10 +318,6 @@ static int
 SProcTestFakeInput(client)
 	register ClientPtr	client;
 {
-	/*
-	 * used in the swaps and swapl macros for temporary storage space
-	 */
-	register char	n;
 	/*
 	 * index counter
 	 */
@@ -339,8 +335,8 @@ SProcTestFakeInput(client)
 	/*
 	 * byte-swap the fields in the request
 	 */
-	swaps(&stuff->length, n);
-	swapl(&stuff->ack, n);
+	swaps(&stuff->length);
+	swapl(&stuff->ack);
 	/*
 	 * have to parse and then byte-swap the input action list here
 	 */
@@ -363,7 +359,7 @@ SProcTestFakeInput(client)
 			/*
 			 * byte-swap the delay_time field
 			 */
-			swaps(&(((XTestKeyInfo *) input_action_ptr)->delay_time), n);
+			swaps(&(((XTestKeyInfo *) input_action_ptr)->delay_time));
 			/*
 			 * advance to the next input action
 			 */
@@ -373,7 +369,7 @@ SProcTestFakeInput(client)
 			/*
 			 * byte-swap the delay_time field
 			 */
-			swaps(&(((XTestMotionInfo *) input_action_ptr)->delay_time), n);
+			swaps(&(((XTestMotionInfo *) input_action_ptr)->delay_time));
 			/*
 			 * advance to the next input action
 			 */
@@ -383,15 +379,15 @@ SProcTestFakeInput(client)
 			/*
 			 * byte-swap the jumpx field
 			 */
-			swaps(&(((XTestJumpInfo *) input_action_ptr)->jumpx), n);
+			swaps(&(((XTestJumpInfo *) input_action_ptr)->jumpx));
 			/*
 			 * byte-swap the jumpy field
 			 */
-			swaps(&(((XTestJumpInfo *) input_action_ptr)->jumpy), n);
+			swaps(&(((XTestJumpInfo *) input_action_ptr)->jumpy));
 			/*
 			 * byte-swap the delay_time field
 			 */
-			swaps(&(((XTestJumpInfo *) input_action_ptr)->delay_time), n);
+			swaps(&(((XTestJumpInfo *) input_action_ptr)->delay_time));
 			/*
 			 * advance to the next input action
 			 */
@@ -409,7 +405,7 @@ SProcTestFakeInput(client)
 				/*
 				 * byte-swap the delay_time field
 				 */
-				swapl(&(((XTestDelayInfo *) input_action_ptr)->delay_time), n);
+				swapl(&(((XTestDelayInfo *) input_action_ptr)->delay_time));
 				/*
 				 * advance to the next input action
 				 */
@@ -440,17 +436,12 @@ static int
 SProcTestGetInput(client)
 	register ClientPtr	client;
 {
-	/*
-	 * used in the swaps and swapl macros for temporary storage space
-	 */
-	register char	n;
-
 	REQUEST(xTestGetInputReq);
 	/*
 	 * byte-swap the fields in the request
 	 */
-	swaps(&stuff->length, n);
-	swapl(&stuff->mode, n);
+	swaps(&stuff->length);
+	swapl(&stuff->mode);
 	return(ProcTestGetInput(client));
 }
 
@@ -464,16 +455,11 @@ static int
 SProcTestStopInput(client)
 	register ClientPtr	client;
 {
-	/*
-	 * used in the swaps and swapl macros for temporary storage space
-	 */
-	register char	n;
-
 	REQUEST(xTestStopInputReq);
 	/*
 	 * byte-swap the length field in the request
 	 */
-	swaps(&stuff->length, n);
+	swaps(&stuff->length);
 	return(ProcTestStopInput(client));
 }
 
@@ -487,16 +473,11 @@ static int
 SProcTestReset(client)
 	register ClientPtr	client;
 {
-	/*
-	 * used in the swaps and swapl macros for temporary storage space
-	 */
-	register char	n;
-
 	REQUEST(xTestResetReq);
 	/*
 	 * byte-swap the length field in the request
 	 */
-	swaps(&stuff->length, n);
+	swaps(&stuff->length);
 	return(ProcTestReset(client));
 }
 
@@ -510,16 +491,11 @@ static int
 SProcTestQueryInputSize(client)
 	register ClientPtr	client;
 {
-	/*
-	 * used in the swaps and swapl macros for temporary storage space
-	 */
-	register char	n;
-
 	REQUEST(xTestQueryInputSizeReq);
 	/*
 	 * byte-swap the length field in the request
 	 */
-	swaps(&stuff->length, n);
+	swaps(&stuff->length);
 	return(ProcTestQueryInputSize(client));
 }
 
@@ -780,10 +756,6 @@ SReplyXTestDispatch(client_ptr, size, reply_ptr)
 	int		size;
 	char		*reply_ptr;
 {
-	/*
-	 * used in the swaps and swapl macros for temporary storage space
-	 */
-	register char	n;
 	/*
 	 * pointer to xTestQueryInputSizeReply
 	 */
@@ -793,9 +765,9 @@ SReplyXTestDispatch(client_ptr, size, reply_ptr)
 	 * there is only one reply in this extension, so byte-swap it
 	 */
 	rep_ptr = (xTestQueryInputSizeReply *) reply_ptr;
-	swaps(&(rep_ptr->sequenceNumber), n);
-	swapl(&(rep_ptr->length), n);
-	swapl(&(rep_ptr->size_return), n);
+	swaps(&(rep_ptr->sequenceNumber));
+	swapl(&(rep_ptr->length));
+	swapl(&(rep_ptr->size_return));
 	/*
 	 * now write the swapped reply to the client
 	 */
@@ -813,10 +785,6 @@ SEventXTestDispatch(from, to)
 	xEvent	*from;
 	xEvent	*to;
 {
-	/*
-	 * used in the swaps and swapl macros for temporary storage space
-	 */
-	register char	n;
 	/*
 	 * index counter
 	 */
@@ -845,7 +813,7 @@ SEventXTestDispatch(from, to)
 	/*
 	 * byte-swap the sequence number in the "to" event
 	 */
-	swaps(&(((xTestInputActionEvent *) to)->sequenceNumber), n);
+	swaps(&(((xTestInputActionEvent *) to)->sequenceNumber));
 	/*
 	 * If the event is an xTestInputActionEvent, then it needs more
 	 * processing.  Otherwise, it is an xTestFakeAckEvent, which
@@ -886,7 +854,7 @@ SEventXTestDispatch(from, to)
 				/*
 				 * byte-swap the delay_time field
 				 */
-				swaps(&(((XTestKeyInfo *) input_action_ptr)->delay_time), n);
+				swaps(&(((XTestKeyInfo *) input_action_ptr)->delay_time));
 				/*
 				 * advance to the next input action
 				 */
@@ -896,7 +864,7 @@ SEventXTestDispatch(from, to)
 				/*
 				 * byte-swap the delay_time field
 				 */
-				swaps(&(((XTestMotionInfo *) input_action_ptr)->delay_time), n);
+				swaps(&(((XTestMotionInfo *) input_action_ptr)->delay_time));
 				/*
 				 * advance to the next input action
 				 */
@@ -906,15 +874,15 @@ SEventXTestDispatch(from, to)
 				/*
 				 * byte-swap the jumpx field
 				 */
-				swaps(&(((XTestJumpInfo *) input_action_ptr)->jumpx), n);
+				swaps(&(((XTestJumpInfo *) input_action_ptr)->jumpx));
 				/*
 				 * byte-swap the jumpy field
 				 */
-				swaps(&(((XTestJumpInfo *) input_action_ptr)->jumpy), n);
+				swaps(&(((XTestJumpInfo *) input_action_ptr)->jumpy));
 				/*
 				 * byte-swap the delay_time field
 				 */
-				swaps(&(((XTestJumpInfo *) input_action_ptr)->delay_time), n);
+				swaps(&(((XTestJumpInfo *) input_action_ptr)->delay_time));
 				/*
 				 * advance to the next input action
 				 */
@@ -932,7 +900,7 @@ SEventXTestDispatch(from, to)
 					/*
 					 * byte-swap the delay_time field
 					 */
-					swapl(&(((XTestDelayInfo *) input_action_ptr)->delay_time), n);
+					swapl(&(((XTestDelayInfo *) input_action_ptr)->delay_time));
 					/*
 					 * advance to the next input action
 					 */
diff --git a/nx-X11/programs/Xserver/Xext/xvdisp.c b/nx-X11/programs/Xserver/Xext/xvdisp.c
index e9250427d..905539c0b 100644
--- a/nx-X11/programs/Xserver/Xext/xvdisp.c
+++ b/nx-X11/programs/Xserver/Xext/xvdisp.c
@@ -1349,164 +1349,154 @@ ProcXvListImageFormats(ClientPtr client)
 static int
 SProcXvQueryExtension(ClientPtr client)
 {
-  register char n;
   REQUEST(xvQueryExtensionReq);
   REQUEST_SIZE_MATCH(xvQueryExtensionReq);
-  swaps(&stuff->length, n);
+  swaps(&stuff->length);
   return ProcXvQueryExtension(client);
 }
 
 static int
 SProcXvQueryAdaptors(ClientPtr client)
 {
-  register char n;
   REQUEST(xvQueryAdaptorsReq);
   REQUEST_SIZE_MATCH(xvQueryAdaptorsReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->window, n);
+  swaps(&stuff->length);
+  swapl(&stuff->window);
   return ProcXvQueryAdaptors(client);
 }
 
 static int
 SProcXvQueryEncodings(ClientPtr client)
 {
-  register char n;
   REQUEST(xvQueryEncodingsReq);
   REQUEST_SIZE_MATCH(xvQueryEncodingsReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
   return ProcXvQueryEncodings(client);
 }
 
 static int
 SProcXvGrabPort(ClientPtr client)
 {
-  register char n;
   REQUEST(xvGrabPortReq);
   REQUEST_SIZE_MATCH(xvGrabPortReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->time, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->time);
   return ProcXvGrabPort(client);
 }
 
 static int
 SProcXvUngrabPort(ClientPtr client)
 {
-  register char n;
   REQUEST(xvUngrabPortReq);
   REQUEST_SIZE_MATCH(xvUngrabPortReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->time, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->time);
   return ProcXvUngrabPort(client);
 }
 
 static int
 SProcXvPutVideo(ClientPtr client)
 {
-  register char n;
   REQUEST(xvPutVideoReq);
   REQUEST_SIZE_MATCH(xvPutVideoReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->drawable, n);
-  swapl(&stuff->gc, n);
-  swaps(&stuff->vid_x, n);
-  swaps(&stuff->vid_y, n);
-  swaps(&stuff->vid_w, n);
-  swaps(&stuff->vid_h, n);
-  swaps(&stuff->drw_x, n);
-  swaps(&stuff->drw_y, n);
-  swaps(&stuff->drw_w, n);
-  swaps(&stuff->drw_h, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->drawable);
+  swapl(&stuff->gc);
+  swaps(&stuff->vid_x);
+  swaps(&stuff->vid_y);
+  swaps(&stuff->vid_w);
+  swaps(&stuff->vid_h);
+  swaps(&stuff->drw_x);
+  swaps(&stuff->drw_y);
+  swaps(&stuff->drw_w);
+  swaps(&stuff->drw_h);
   return ProcXvPutVideo(client);
 }
 
 static int
 SProcXvPutStill(ClientPtr client)
 {
-  register char n;
   REQUEST(xvPutStillReq);
   REQUEST_SIZE_MATCH(xvPutStillReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->drawable, n);
-  swapl(&stuff->gc, n);
-  swaps(&stuff->vid_x, n);
-  swaps(&stuff->vid_y, n);
-  swaps(&stuff->vid_w, n);
-  swaps(&stuff->vid_h, n);
-  swaps(&stuff->drw_x, n);
-  swaps(&stuff->drw_y, n);
-  swaps(&stuff->drw_w, n);
-  swaps(&stuff->drw_h, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->drawable);
+  swapl(&stuff->gc);
+  swaps(&stuff->vid_x);
+  swaps(&stuff->vid_y);
+  swaps(&stuff->vid_w);
+  swaps(&stuff->vid_h);
+  swaps(&stuff->drw_x);
+  swaps(&stuff->drw_y);
+  swaps(&stuff->drw_w);
+  swaps(&stuff->drw_h);
   return ProcXvPutStill(client);
 }
 
 static int
 SProcXvGetVideo(ClientPtr client)
 {
-  register char n;
   REQUEST(xvGetVideoReq);
   REQUEST_SIZE_MATCH(xvGetVideoReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->drawable, n);
-  swapl(&stuff->gc, n);
-  swaps(&stuff->vid_x, n);
-  swaps(&stuff->vid_y, n);
-  swaps(&stuff->vid_w, n);
-  swaps(&stuff->vid_h, n);
-  swaps(&stuff->drw_x, n);
-  swaps(&stuff->drw_y, n);
-  swaps(&stuff->drw_w, n);
-  swaps(&stuff->drw_h, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->drawable);
+  swapl(&stuff->gc);
+  swaps(&stuff->vid_x);
+  swaps(&stuff->vid_y);
+  swaps(&stuff->vid_w);
+  swaps(&stuff->vid_h);
+  swaps(&stuff->drw_x);
+  swaps(&stuff->drw_y);
+  swaps(&stuff->drw_w);
+  swaps(&stuff->drw_h);
   return ProcXvGetVideo(client);
 }
 
 static int
 SProcXvGetStill(ClientPtr client)
 {
-  register char n;
   REQUEST(xvGetStillReq);
   REQUEST_SIZE_MATCH(xvGetStillReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->drawable, n);
-  swapl(&stuff->gc, n);
-  swaps(&stuff->vid_x, n);
-  swaps(&stuff->vid_y, n);
-  swaps(&stuff->vid_w, n);
-  swaps(&stuff->vid_h, n);
-  swaps(&stuff->drw_x, n);
-  swaps(&stuff->drw_y, n);
-  swaps(&stuff->drw_w, n);
-  swaps(&stuff->drw_h, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->drawable);
+  swapl(&stuff->gc);
+  swaps(&stuff->vid_x);
+  swaps(&stuff->vid_y);
+  swaps(&stuff->vid_w);
+  swaps(&stuff->vid_h);
+  swaps(&stuff->drw_x);
+  swaps(&stuff->drw_y);
+  swaps(&stuff->drw_w);
+  swaps(&stuff->drw_h);
   return ProcXvGetStill(client);
 }
 
 static int
 SProcXvPutImage(ClientPtr client)
 {
-  register char n;
   REQUEST(xvPutImageReq);
   REQUEST_AT_LEAST_SIZE(xvPutImageReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->drawable, n);
-  swapl(&stuff->gc, n);
-  swapl(&stuff->id, n);
-  swaps(&stuff->src_x, n);
-  swaps(&stuff->src_y, n);
-  swaps(&stuff->src_w, n);
-  swaps(&stuff->src_h, n);
-  swaps(&stuff->drw_x, n);
-  swaps(&stuff->drw_y, n);
-  swaps(&stuff->drw_w, n);
-  swaps(&stuff->drw_h, n);
-  swaps(&stuff->width, n);
-  swaps(&stuff->height, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->drawable);
+  swapl(&stuff->gc);
+  swapl(&stuff->id);
+  swaps(&stuff->src_x);
+  swaps(&stuff->src_y);
+  swaps(&stuff->src_w);
+  swaps(&stuff->src_h);
+  swaps(&stuff->drw_x);
+  swaps(&stuff->drw_y);
+  swaps(&stuff->drw_w);
+  swaps(&stuff->drw_h);
+  swaps(&stuff->width);
+  swaps(&stuff->height);
   return ProcXvPutImage(client);
 }
 
@@ -1514,26 +1504,25 @@ SProcXvPutImage(ClientPtr client)
 static int
 SProcXvShmPutImage(ClientPtr client)
 {
-  register char n;
   REQUEST(xvShmPutImageReq);
   REQUEST_SIZE_MATCH(xvShmPutImageReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->drawable, n);
-  swapl(&stuff->gc, n);
-  swapl(&stuff->shmseg, n);
-  swapl(&stuff->id, n);
-  swaps(&stuff->src_x, n);
-  swaps(&stuff->src_y, n);
-  swaps(&stuff->src_w, n);
-  swaps(&stuff->src_h, n);
-  swaps(&stuff->drw_x, n);
-  swaps(&stuff->drw_y, n);
-  swaps(&stuff->drw_w, n);
-  swaps(&stuff->drw_h, n);
-  swaps(&stuff->offset, n);
-  swaps(&stuff->width, n);
-  swaps(&stuff->height, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->drawable);
+  swapl(&stuff->gc);
+  swapl(&stuff->shmseg);
+  swapl(&stuff->id);
+  swapl(&stuff->offset);
+  swaps(&stuff->src_x);
+  swaps(&stuff->src_y);
+  swaps(&stuff->src_w);
+  swaps(&stuff->src_h);
+  swaps(&stuff->drw_x);
+  swaps(&stuff->drw_y);
+  swaps(&stuff->drw_w);
+  swaps(&stuff->drw_h);
+  swaps(&stuff->width);
+  swaps(&stuff->height);
   return ProcXvShmPutImage(client);
 }
 #endif
@@ -1542,108 +1531,101 @@ SProcXvShmPutImage(ClientPtr client)
 static int
 SProcXvSelectVideoNotify(ClientPtr client)
 {
-  register char n;
   REQUEST(xvSelectVideoNotifyReq);
   REQUEST_SIZE_MATCH(xvSelectVideoNotifyReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->drawable, n);
+  swaps(&stuff->length);
+  swapl(&stuff->drawable);
   return ProcXvSelectVideoNotify(client);
 }
 
 static int
 SProcXvSelectPortNotify(ClientPtr client)
 {
-  register char n;
   REQUEST(xvSelectPortNotifyReq);
   REQUEST_SIZE_MATCH(xvSelectPortNotifyReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
   return ProcXvSelectPortNotify(client);
 }
 
 static int
 SProcXvStopVideo(ClientPtr client)
 {
-  register char n;
   REQUEST(xvStopVideoReq);
   REQUEST_SIZE_MATCH(xvStopVideoReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->drawable, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->drawable);
   return ProcXvStopVideo(client);
 }
 
 static int
 SProcXvSetPortAttribute(ClientPtr client)
 {
-  register char n;
   REQUEST(xvSetPortAttributeReq);
   REQUEST_SIZE_MATCH(xvSetPortAttributeReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->attribute, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->attribute);
+  swapl(&stuff->value);
   return ProcXvSetPortAttribute(client);
 }
 
 static int
 SProcXvGetPortAttribute(ClientPtr client)
 {
-  register char n;
   REQUEST(xvGetPortAttributeReq);
   REQUEST_SIZE_MATCH(xvGetPortAttributeReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swapl(&stuff->attribute, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->attribute);
   return ProcXvGetPortAttribute(client);
 }
 
 static int
 SProcXvQueryBestSize(ClientPtr client)
 {
-  register char n;
   REQUEST(xvQueryBestSizeReq);
   REQUEST_SIZE_MATCH(xvQueryBestSizeReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
-  swaps(&stuff->vid_w, n);
-  swaps(&stuff->vid_h, n);
-  swaps(&stuff->drw_w, n);
-  swaps(&stuff->drw_h, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swaps(&stuff->vid_w);
+  swaps(&stuff->vid_h);
+  swaps(&stuff->drw_w);
+  swaps(&stuff->drw_h);
   return ProcXvQueryBestSize(client);
 }
 
 static int
 SProcXvQueryPortAttributes(ClientPtr client)
 {
-  register char n;
   REQUEST(xvQueryPortAttributesReq);
   REQUEST_SIZE_MATCH(xvQueryPortAttributesReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
   return ProcXvQueryPortAttributes(client);
 }
 
 static int
 SProcXvQueryImageAttributes(ClientPtr client)
 {
-  register char n;
   REQUEST(xvQueryImageAttributesReq);
   REQUEST_SIZE_MATCH(xvQueryImageAttributesReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->id, n);
-  swaps(&stuff->width, n);
-  swaps(&stuff->width, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
+  swapl(&stuff->id);
+  swaps(&stuff->width);
+  swaps(&stuff->height);
   return ProcXvQueryImageAttributes(client);
 }
 
 static int
 SProcXvListImageFormats(ClientPtr client)
 {
-  register char n;
   REQUEST(xvListImageFormatsReq);
   REQUEST_SIZE_MATCH(xvListImageFormatsReq);
-  swaps(&stuff->length, n);
-  swapl(&stuff->port, n);
+  swaps(&stuff->length);
+  swapl(&stuff->port);
   return ProcXvListImageFormats(client);
 }
 
@@ -1653,12 +1635,10 @@ SWriteQueryExtensionReply(
    ClientPtr client,
    xvQueryExtensionReply *rep
 ){
-  register char n;
-
-  swaps(&rep->sequenceNumber, n);
-  swapl(&rep->length, n);
-  swaps(&rep->version, n);
-  swaps(&rep->revision, n);
+  swaps(&rep->sequenceNumber);
+  swapl(&rep->length);
+  swaps(&rep->version);
+  swaps(&rep->revision);
   
   (void)WriteToClient(client, sz_xvQueryExtensionReply, (char *)&rep);
 
@@ -1670,11 +1650,9 @@ SWriteQueryAdaptorsReply(
    ClientPtr client,
    xvQueryAdaptorsReply *rep
 ){
-  register char n;
-
-  swaps(&rep->sequenceNumber, n);
-  swapl(&rep->length, n);
-  swaps(&rep->num_adaptors, n);
+  swaps(&rep->sequenceNumber);
+  swapl(&rep->length);
+  swaps(&rep->num_adaptors);
   
   (void)WriteToClient(client, sz_xvQueryAdaptorsReply, (char *)&rep);
 
@@ -1686,11 +1664,9 @@ SWriteQueryEncodingsReply(
    ClientPtr client,
    xvQueryEncodingsReply *rep
 ){
-  register char n;
-
-  swaps(&rep->sequenceNumber, n);
-  swapl(&rep->length, n);
-  swaps(&rep->num_encodings, n);
+  swaps(&rep->sequenceNumber);
+  swapl(&rep->length);
+  swaps(&rep->num_encodings);
   
   (void)WriteToClient(client, sz_xvQueryEncodingsReply, (char *)&rep);
 
@@ -1702,12 +1678,10 @@ SWriteAdaptorInfo(
    ClientPtr client,
    xvAdaptorInfo *pAdaptor
 ){
-  register char n;
-
-  swapl(&pAdaptor->base_id, n);
-  swaps(&pAdaptor->name_size, n);
-  swaps(&pAdaptor->num_ports, n);
-  swaps(&pAdaptor->num_formats, n);
+  swapl(&pAdaptor->base_id);
+  swaps(&pAdaptor->name_size);
+  swaps(&pAdaptor->num_ports);
+  swaps(&pAdaptor->num_formats);
 
   (void)WriteToClient(client, sz_xvAdaptorInfo, (char *)pAdaptor);
 
@@ -1719,14 +1693,12 @@ SWriteEncodingInfo(
    ClientPtr client,
    xvEncodingInfo *pEncoding
 ){
-  register char n;
-  
-  swapl(&pEncoding->encoding, n);
-  swaps(&pEncoding->name_size, n);
-  swaps(&pEncoding->width, n);
-  swaps(&pEncoding->height, n);
-  swapl(&pEncoding->rate.numerator, n);
-  swapl(&pEncoding->rate.denominator, n);
+  swapl(&pEncoding->encoding);
+  swaps(&pEncoding->name_size);
+  swaps(&pEncoding->width);
+  swaps(&pEncoding->height);
+  swapl(&pEncoding->rate.numerator);
+  swapl(&pEncoding->rate.denominator);
   (void)WriteToClient(client, sz_xvEncodingInfo, (char *)pEncoding);
 
   return Success;
@@ -1737,9 +1709,7 @@ SWriteFormat(
    ClientPtr client,
    xvFormat *pFormat
 ){
-  register char n;
-
-  swapl(&pFormat->visual, n);
+  swapl(&pFormat->visual);
   (void)WriteToClient(client, sz_xvFormat, (char *)pFormat);
 
   return Success;
@@ -1750,12 +1720,10 @@ SWriteAttributeInfo(
    ClientPtr client,
    xvAttributeInfo *pAtt
 ){
-  register char n;
-
-  swapl(&pAtt->flags, n);
-  swapl(&pAtt->size, n);
-  swapl(&pAtt->min, n);
-  swapl(&pAtt->max, n);
+  swapl(&pAtt->flags);
+  swapl(&pAtt->size);
+  swapl(&pAtt->min);
+  swapl(&pAtt->max);
   (void)WriteToClient(client, sz_xvAttributeInfo, (char *)pAtt);
 
   return Success;
@@ -1766,21 +1734,19 @@ SWriteImageFormatInfo(
    ClientPtr client,
    xvImageFormatInfo *pImage
 ){
-  register char n;
-
-  swapl(&pImage->id, n);
-  swapl(&pImage->red_mask, n);
-  swapl(&pImage->green_mask, n);
-  swapl(&pImage->blue_mask, n);
-  swapl(&pImage->y_sample_bits, n);
-  swapl(&pImage->u_sample_bits, n);
-  swapl(&pImage->v_sample_bits, n);
-  swapl(&pImage->horz_y_period, n);
-  swapl(&pImage->horz_u_period, n);
-  swapl(&pImage->horz_v_period, n);
-  swapl(&pImage->vert_y_period, n);
-  swapl(&pImage->vert_u_period, n);
-  swapl(&pImage->vert_v_period, n);
+  swapl(&pImage->id);
+  swapl(&pImage->red_mask);
+  swapl(&pImage->green_mask);
+  swapl(&pImage->blue_mask);
+  swapl(&pImage->y_sample_bits);
+  swapl(&pImage->u_sample_bits);
+  swapl(&pImage->v_sample_bits);
+  swapl(&pImage->horz_y_period);
+  swapl(&pImage->horz_u_period);
+  swapl(&pImage->horz_v_period);
+  swapl(&pImage->vert_y_period);
+  swapl(&pImage->vert_u_period);
+  swapl(&pImage->vert_v_period);
 
   (void)WriteToClient(client, sz_xvImageFormatInfo, (char *)pImage);
 
@@ -1794,10 +1760,8 @@ SWriteGrabPortReply(
    ClientPtr client,
    xvGrabPortReply *rep
 ){
-  register char n;
-
-  swaps(&rep->sequenceNumber, n);
-  swapl(&rep->length, n);
+  swaps(&rep->sequenceNumber);
+  swapl(&rep->length);
 
   (void)WriteToClient(client, sz_xvGrabPortReply, (char *)&rep);
 
@@ -1809,11 +1773,9 @@ SWriteGetPortAttributeReply(
    ClientPtr client,
    xvGetPortAttributeReply *rep
 ){
-  register char n;
-
-  swaps(&rep->sequenceNumber, n);
-  swapl(&rep->length, n);
-  swapl(&rep->value, n);
+  swaps(&rep->sequenceNumber);
+  swapl(&rep->length);
+  swapl(&rep->value);
 
   (void)WriteToClient(client, sz_xvGetPortAttributeReply, (char *)&rep);
 
@@ -1825,12 +1787,10 @@ SWriteQueryBestSizeReply(
    ClientPtr client,
    xvQueryBestSizeReply *rep
 ){
-  register char n;
-
-  swaps(&rep->sequenceNumber, n);
-  swapl(&rep->length, n);
-  swaps(&rep->actual_width, n);
-  swaps(&rep->actual_height, n);
+  swaps(&rep->sequenceNumber);
+  swapl(&rep->length);
+  swaps(&rep->actual_width);
+  swaps(&rep->actual_height);
 
   (void)WriteToClient(client, sz_xvQueryBestSizeReply, (char *)&rep);
 
@@ -1842,12 +1802,10 @@ SWriteQueryPortAttributesReply(
    ClientPtr client,
    xvQueryPortAttributesReply *rep
 ){
-  register char n;
-
-  swaps(&rep->sequenceNumber, n);
-  swapl(&rep->length, n);
-  swapl(&rep->num_attributes, n);
-  swapl(&rep->text_size, n);
+  swaps(&rep->sequenceNumber);
+  swapl(&rep->length);
+  swapl(&rep->num_attributes);
+  swapl(&rep->text_size);
 
   (void)WriteToClient(client, sz_xvQueryPortAttributesReply, (char *)&rep);
 
@@ -1859,14 +1817,12 @@ SWriteQueryImageAttributesReply(
    ClientPtr client,
    xvQueryImageAttributesReply *rep
 ){
-  register char n;
-
-  swaps(&rep->sequenceNumber, n);
-  swapl(&rep->length, n);
-  swapl(&rep->num_planes, n);
-  swapl(&rep->data_size, n);
-  swaps(&rep->width, n);
-  swaps(&rep->height, n);
+  swaps(&rep->sequenceNumber);
+  swapl(&rep->length);
+  swapl(&rep->num_planes);
+  swapl(&rep->data_size);
+  swaps(&rep->width);
+  swaps(&rep->height);
 
   (void)WriteToClient(client, sz_xvQueryImageAttributesReply, (char *)&rep);
 
@@ -1879,11 +1835,9 @@ SWriteListImageFormatsReply(
    ClientPtr client,
    xvListImageFormatsReply *rep
 ){
-  register char n;
-
-  swaps(&rep->sequenceNumber, n);
-  swapl(&rep->length, n);
-  swapl(&rep->num_formats, n);
+  swaps(&rep->sequenceNumber);
+  swapl(&rep->length);
+  swapl(&rep->num_formats);
 
   (void)WriteToClient(client, sz_xvListImageFormatsReply, (char *)&rep);
 
diff --git a/nx-X11/programs/Xserver/Xi/allowev.c b/nx-X11/programs/Xserver/Xi/allowev.c
index 8073649f1..06a402b6d 100644
--- a/nx-X11/programs/Xserver/Xi/allowev.c
+++ b/nx-X11/programs/Xserver/Xi/allowev.c
@@ -82,12 +82,10 @@ int
 SProcXAllowDeviceEvents(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xAllowDeviceEventsReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xAllowDeviceEventsReq);
-    swapl(&stuff->time, n);
+    swapl(&stuff->time);
     return(ProcXAllowDeviceEvents(client));
     }
 
diff --git a/nx-X11/programs/Xserver/Xi/chgdctl.c b/nx-X11/programs/Xserver/Xi/chgdctl.c
index c4fa46ba7..c2412df67 100644
--- a/nx-X11/programs/Xserver/Xi/chgdctl.c
+++ b/nx-X11/programs/Xserver/Xi/chgdctl.c
@@ -83,12 +83,10 @@ int
 SProcXChangeDeviceControl(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xChangeDeviceControlReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_EXTRA_SIZE(xChangeDeviceControlReq, sizeof(xDeviceCtl));
-    swaps(&stuff->control, n);
+    swaps(&stuff->control);
     return(ProcXChangeDeviceControl(client));
     }
 
@@ -210,10 +208,8 @@ SRepXChangeDeviceControl (client, size, rep)
     int		size;
     xChangeDeviceControlReply	*rep;
     {
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
+    swaps(&rep->sequenceNumber);
+    swapl(&rep->length);
     WriteToClient(client, size, (char *)rep);
     }
 
diff --git a/nx-X11/programs/Xserver/Xi/chgfctl.c b/nx-X11/programs/Xserver/Xi/chgfctl.c
index d78b32a17..9483cd295 100644
--- a/nx-X11/programs/Xserver/Xi/chgfctl.c
+++ b/nx-X11/programs/Xserver/Xi/chgfctl.c
@@ -84,12 +84,10 @@ int
 SProcXChangeFeedbackControl(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xChangeFeedbackControlReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xChangeFeedbackControlReq);
-    swapl(&stuff->mask, n);
+    swapl(&stuff->mask);
     return(ProcXChangeFeedbackControl(client));
     }
 
@@ -156,13 +154,12 @@ ProcXChangeFeedbackControl(client)
 	    break;
 	case StringFeedbackClass:
 	    {
-	    register char n;
 	    xStringFeedbackCtl *f = ((xStringFeedbackCtl *) &stuff[1]);
 	    if (client->swapped)
 		{
 		if (len < (sizeof(xStringFeedbackCtl) + 3) >> 2)
 		    return BadLength;
-		swaps(&f->num_keysyms,n);
+		swaps(&f->num_keysyms);
 		}
 	    if (len != ((sizeof(xStringFeedbackCtl)>>2) + f->num_keysyms))
 		{
@@ -242,18 +239,17 @@ ChangeKbdFeedback (client, dev, mask, k, f)
     KbdFeedbackPtr	k;
     xKbdFeedbackCtl 	*f;
     {
-    register char n;
     KeybdCtrl kctrl;
     int t;
     int key = DO_ALL;
 
     if (client->swapped)
 	{
-	swaps(&f->length,n);
-	swaps(&f->pitch,n);
-	swaps(&f->duration,n);
-	swapl(&f->led_mask,n);
-	swapl(&f->led_values,n);
+	swaps(&f->length);
+	swaps(&f->pitch);
+	swaps(&f->duration);
+	swapl(&f->led_mask);
+	swapl(&f->led_values);
 	}
 
     kctrl = k->ctrl;
@@ -398,15 +394,14 @@ ChangePtrFeedback (client, dev, mask, p, f)
     PtrFeedbackPtr 	p;
     xPtrFeedbackCtl 	*f;
     {
-    register char n;
     PtrCtrl pctrl;		/* might get BadValue part way through */
 
     if (client->swapped)
 	{
-	swaps(&f->length,n);
-	swaps(&f->num,n);
-	swaps(&f->denom,n);
-	swaps(&f->thresh,n);
+	swaps(&f->length);
+	swaps(&f->num);
+	swaps(&f->denom);
+	swaps(&f->thresh);
 	}
 
     pctrl = p->ctrl;
@@ -480,12 +475,10 @@ ChangeIntegerFeedback (client, dev, mask, i, f)
     IntegerFeedbackPtr 		i;
     xIntegerFeedbackCtl 	*f;
     {
-    register char n;
-
     if (client->swapped)
 	{
-	swaps(&f->length,n);
-	swapl(&f->int_to_display,n);
+	swaps(&f->length);
+	swapl(&f->int_to_display);
 	}
 
     i->ctrl.integer_displayed = f->int_to_display;
@@ -507,14 +500,13 @@ ChangeStringFeedback (client, dev, mask, s, f)
     StringFeedbackPtr 	s;
     xStringFeedbackCtl 	*f;
     {
-    register char n;
     int		i, j;
     KeySym	*syms, *sup_syms;
 
     syms = (KeySym *) (f+1);
     if (client->swapped)
 	{
-	swaps(&f->length,n);	/* swapped num_keysyms in calling proc */
+	swaps(&f->length);	/* swapped num_keysyms in calling proc */
 	SwapLongs((CARD32 *) syms, f->num_keysyms);
 	}
 
@@ -559,15 +551,14 @@ ChangeBellFeedback (client, dev, mask, b, f)
     BellFeedbackPtr 	b;
     xBellFeedbackCtl 	*f;
     {
-    register char n;
     int t;
     BellCtrl bctrl;		/* might get BadValue part way through */
 
     if (client->swapped)
 	{
-	swaps(&f->length,n);
-	swaps(&f->pitch,n);
-	swaps(&f->duration,n);
+	swaps(&f->length);
+	swaps(&f->pitch);
+	swaps(&f->duration);
 	}
 
     bctrl = b->ctrl;
@@ -634,14 +625,13 @@ ChangeLedFeedback (client, dev, mask, l, f)
     LedFeedbackPtr 	l;
     xLedFeedbackCtl 	*f;
     {
-    register char n;
     LedCtrl lctrl;		/* might get BadValue part way through */
 
     if (client->swapped)
 	{
-	swaps(&f->length,n);
-	swapl(&f->led_values,n);
-	swapl(&f->led_mask,n);
+	swaps(&f->length);
+	swapl(&f->led_values);
+	swapl(&f->led_mask);
 	}
 
     f->led_mask &= l->ctrl.led_mask;	/* set only supported leds */
diff --git a/nx-X11/programs/Xserver/Xi/chgkbd.c b/nx-X11/programs/Xserver/Xi/chgkbd.c
index 0cf8a1c87..f29c86e0d 100644
--- a/nx-X11/programs/Xserver/Xi/chgkbd.c
+++ b/nx-X11/programs/Xserver/Xi/chgkbd.c
@@ -85,10 +85,8 @@ int
 SProcXChangeKeyboardDevice(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xChangeKeyboardDeviceReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xChangeKeyboardDeviceReq);
     return(ProcXChangeKeyboardDevice(client));
     }
@@ -208,9 +206,7 @@ SRepXChangeKeyboardDevice (client, size, rep)
     int		size;
     xChangeKeyboardDeviceReply	*rep;
     {
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
+    swaps(&rep->sequenceNumber);
+    swapl(&rep->length);
     WriteToClient(client, size, (char *)rep);
     }
diff --git a/nx-X11/programs/Xserver/Xi/chgkmap.c b/nx-X11/programs/Xserver/Xi/chgkmap.c
index 88afd9df7..52fd9f5eb 100644
--- a/nx-X11/programs/Xserver/Xi/chgkmap.c
+++ b/nx-X11/programs/Xserver/Xi/chgkmap.c
@@ -82,11 +82,10 @@ int
 SProcXChangeDeviceKeyMapping(client)
     register ClientPtr client;
     {
-    register char n;
     unsigned int count;
 
     REQUEST(xChangeDeviceKeyMappingReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xChangeDeviceKeyMappingReq);
     count = stuff->keyCodes * stuff->keySymsPerKeyCode;
     REQUEST_FIXED_SIZE(xChangeDeviceKeyMappingReq, count * sizeof(CARD32));
diff --git a/nx-X11/programs/Xserver/Xi/chgprop.c b/nx-X11/programs/Xserver/Xi/chgprop.c
index 47db87293..fead6327c 100644
--- a/nx-X11/programs/Xserver/Xi/chgprop.c
+++ b/nx-X11/programs/Xserver/Xi/chgprop.c
@@ -84,13 +84,11 @@ int
 SProcXChangeDeviceDontPropagateList(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xChangeDeviceDontPropagateListReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xChangeDeviceDontPropagateListReq);
-    swapl(&stuff->window, n);
-    swaps(&stuff->count, n);
+    swapl(&stuff->window);
+    swaps(&stuff->count);
     REQUEST_FIXED_SIZE(xChangeDeviceDontPropagateListReq,
                       stuff->count * sizeof(CARD32));
     SwapLongs((CARD32 *) (&stuff[1]), stuff->count);
diff --git a/nx-X11/programs/Xserver/Xi/chgptr.c b/nx-X11/programs/Xserver/Xi/chgptr.c
index 2bbd7bc37..6d87df415 100644
--- a/nx-X11/programs/Xserver/Xi/chgptr.c
+++ b/nx-X11/programs/Xserver/Xi/chgptr.c
@@ -88,10 +88,8 @@ int
 SProcXChangePointerDevice(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xChangePointerDeviceReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xChangePointerDeviceReq);
     return(ProcXChangePointerDevice(client));
     }
@@ -254,9 +252,7 @@ SRepXChangePointerDevice (client, size, rep)
     int		size;
     xChangePointerDeviceReply	*rep;
     {
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
+    swaps(&rep->sequenceNumber);
+    swapl(&rep->length);
     WriteToClient(client, size, (char *)rep);
     }
diff --git a/nx-X11/programs/Xserver/Xi/closedev.c b/nx-X11/programs/Xserver/Xi/closedev.c
index 5f90b57a4..9452b220b 100644
--- a/nx-X11/programs/Xserver/Xi/closedev.c
+++ b/nx-X11/programs/Xserver/Xi/closedev.c
@@ -83,10 +83,8 @@ int
 SProcXCloseDevice(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xCloseDeviceReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xCloseDeviceReq);
     return(ProcXCloseDevice(client));
     }
diff --git a/nx-X11/programs/Xserver/Xi/devbell.c b/nx-X11/programs/Xserver/Xi/devbell.c
index 12c444137..c7de6cf10 100644
--- a/nx-X11/programs/Xserver/Xi/devbell.c
+++ b/nx-X11/programs/Xserver/Xi/devbell.c
@@ -81,10 +81,8 @@ int
 SProcXDeviceBell(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xDeviceBellReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     return(ProcXDeviceBell(client));
     }
 
diff --git a/nx-X11/programs/Xserver/Xi/extinit.c b/nx-X11/programs/Xserver/Xi/extinit.c
index d74ac5dc7..b3cd029f4 100644
--- a/nx-X11/programs/Xserver/Xi/extinit.c
+++ b/nx-X11/programs/Xserver/Xi/extinit.c
@@ -586,17 +586,16 @@ SEventDeviceValuator (from, to)
     deviceValuator	*from;
     deviceValuator	*to;
     {
-    register char	n;
     register int	i;
     INT32 *ip B32;
 
     *to = *from;
-    swaps(&to->sequenceNumber,n);
-    swaps(&to->device_state,n);
+    swaps(&to->sequenceNumber);
+    swaps(&to->device_state);
     ip = &to->valuator0;
     for (i=0; i<6; i++)
 	{
-        swapl((ip+i),n);	/* macro - braces are required	    */
+        swapl((ip+i));	/* macro - braces are required	    */
 	}
     }
 
@@ -605,12 +604,10 @@ SEventFocus (from, to)
     deviceFocus	*from;
     deviceFocus	*to;
 {
-    register char	n;
-
     *to = *from;
-    swaps(&to->sequenceNumber,n);
-    swapl(&to->time, n);
-    swapl(&to->window, n);
+    swaps(&to->sequenceNumber);
+    swapl(&to->time);
+    swapl(&to->window);
     }
 
 void
@@ -619,16 +616,15 @@ SDeviceStateNotifyEvent (from, to)
     deviceStateNotify	*to;
 {
     register int	i;
-    register char	n;
     INT32 *ip B32;
 
     *to = *from;
-    swaps(&to->sequenceNumber,n);
-    swapl(&to->time, n);
+    swaps(&to->sequenceNumber);
+    swapl(&to->time);
     ip = &to->valuator0;
     for (i=0; i<3; i++)
 	{
-        swapl((ip+i),n);	/* macro - braces are required	    */
+        swapl((ip+i));	/* macro - braces are required	    */
 	}
     }
 
@@ -637,10 +633,8 @@ SDeviceKeyStateNotifyEvent (from, to)
     deviceKeyStateNotify	*from;
     deviceKeyStateNotify	*to;
 {
-    register char	n;
-
     *to = *from;
-    swaps(&to->sequenceNumber,n);
+    swaps(&to->sequenceNumber);
     }
 
 void
@@ -648,10 +642,8 @@ SDeviceButtonStateNotifyEvent (from, to)
     deviceButtonStateNotify	*from;
     deviceButtonStateNotify	*to;
 {
-    register char	n;
-
     *to = *from;
-    swaps(&to->sequenceNumber,n);
+    swaps(&to->sequenceNumber);
     }
 
 void
@@ -659,11 +651,9 @@ SChangeDeviceNotifyEvent (from, to)
     changeDeviceNotify	*from;
     changeDeviceNotify	*to;
 {
-    register char	n;
-
     *to = *from;
-    swaps(&to->sequenceNumber,n);
-    swapl(&to->time, n);
+    swaps(&to->sequenceNumber);
+    swapl(&to->time);
     }
 
 void
@@ -671,11 +661,9 @@ SDeviceMappingNotifyEvent (from, to)
     deviceMappingNotify	*from;
     deviceMappingNotify	*to;
 {
-    register char	n;
-
     *to = *from;
-    swaps(&to->sequenceNumber,n);
-    swapl(&to->time, n);
+    swaps(&to->sequenceNumber);
+    swapl(&to->time);
     }
 
 /************************************************************************
diff --git a/nx-X11/programs/Xserver/Xi/getbmap.c b/nx-X11/programs/Xserver/Xi/getbmap.c
index ac2b69749..e571bc7dd 100644
--- a/nx-X11/programs/Xserver/Xi/getbmap.c
+++ b/nx-X11/programs/Xserver/Xi/getbmap.c
@@ -80,10 +80,8 @@ int
 SProcXGetDeviceButtonMapping(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xGetDeviceButtonMappingReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     return(ProcXGetDeviceButtonMapping(client));
     }
 
@@ -146,9 +144,7 @@ SRepXGetDeviceButtonMapping (client, size, rep)
     int		size;
     xGetDeviceButtonMappingReply	*rep;
     {
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
+    swaps(&rep->sequenceNumber);
+    swapl(&rep->length);
     WriteToClient(client, size, (char *)rep);
     }
diff --git a/nx-X11/programs/Xserver/Xi/getdctl.c b/nx-X11/programs/Xserver/Xi/getdctl.c
index 1161e5aef..2af8db5ea 100644
--- a/nx-X11/programs/Xserver/Xi/getdctl.c
+++ b/nx-X11/programs/Xserver/Xi/getdctl.c
@@ -81,12 +81,10 @@ int
 SProcXGetDeviceControl(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xGetDeviceControlReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xGetDeviceControlReq);
-    swaps(&stuff->control, n);
+    swaps(&stuff->control);
     return(ProcXGetDeviceControl(client));
     }
 
@@ -178,7 +176,6 @@ CopySwapDeviceResolution (client, v, buf, length)
     char 		*buf;
     int			length;
     {
-    register char 	n;
     AxisInfoPtr	a;
     xDeviceResolutionState *r;
     int i, *iptr;
@@ -197,13 +194,13 @@ CopySwapDeviceResolution (client, v, buf, length)
 	*iptr++ = a->max_resolution;
     if (client->swapped)
 	{
-	swaps (&r->control,n);
-	swaps (&r->length,n);
-	swapl (&r->num_valuators,n);
+	swaps (&r->control);
+	swaps (&r->length);
+	swapl (&r->num_valuators);
 	iptr = (int *) buf;
 	for (i=0; i < (3 * v->numAxes); i++,iptr++)
 	    {
-	    swapl (iptr,n);
+	    swapl (iptr);
 	    }
 	}
     }
@@ -221,10 +218,8 @@ SRepXGetDeviceControl (client, size, rep)
     int		size;
     xGetDeviceControlReply	*rep;
     {
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
+    swaps(&rep->sequenceNumber);
+    swapl(&rep->length);
     WriteToClient(client, size, (char *)rep);
     }
 
diff --git a/nx-X11/programs/Xserver/Xi/getfctl.c b/nx-X11/programs/Xserver/Xi/getfctl.c
index bc92784d3..d5fd88b0a 100644
--- a/nx-X11/programs/Xserver/Xi/getfctl.c
+++ b/nx-X11/programs/Xserver/Xi/getfctl.c
@@ -81,10 +81,8 @@ int
 SProcXGetFeedbackControl(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xGetFeedbackControlReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     return(ProcXGetFeedbackControl(client));
     }
 
@@ -207,7 +205,6 @@ CopySwapKbdFeedback (client, k, buf)
     char 		**buf;
     {
     int	i;
-    register char 	n;
     xKbdFeedbackState	*k2;
 
     k2 = (xKbdFeedbackState *) *buf;
@@ -224,11 +221,11 @@ CopySwapKbdFeedback (client, k, buf)
 	k2->auto_repeats[i] = k->ctrl.autoRepeats[i];
     if (client->swapped)
 	{
-	swaps(&k2->length,n);
-	swaps(&k2->pitch,n);
-	swaps(&k2->duration,n);
-	swapl(&k2->led_mask,n);
-	swapl(&k2->led_values,n);
+	swaps(&k2->length);
+	swaps(&k2->pitch);
+	swaps(&k2->duration);
+	swapl(&k2->led_mask);
+	swapl(&k2->led_values);
 	}
     *buf += sizeof (xKbdFeedbackState);
     }
@@ -245,7 +242,6 @@ CopySwapPtrFeedback (client, p, buf)
     PtrFeedbackPtr 	p;
     char 		**buf;
     {
-    register char 	n;
     xPtrFeedbackState	*p2;
 
     p2 = (xPtrFeedbackState *) *buf;
@@ -257,10 +253,10 @@ CopySwapPtrFeedback (client, p, buf)
     p2->threshold = p->ctrl.threshold;
     if (client->swapped)
 	{
-	swaps(&p2->length,n);
-	swaps(&p2->accelNum,n);
-	swaps(&p2->accelDenom,n);
-	swaps(&p2->threshold,n);
+	swaps(&p2->length);
+	swaps(&p2->accelNum);
+	swaps(&p2->accelDenom);
+	swaps(&p2->threshold);
 	}
     *buf += sizeof (xPtrFeedbackState);
     }
@@ -277,7 +273,6 @@ CopySwapIntegerFeedback (client, i, buf)
     IntegerFeedbackPtr 	i;
     char 		**buf;
     {
-    register char 		n;
     xIntegerFeedbackState	*i2;
 
     i2 = (xIntegerFeedbackState *) *buf;
@@ -289,10 +284,10 @@ CopySwapIntegerFeedback (client, i, buf)
     i2->max_value = i->ctrl.max_value;
     if (client->swapped)
 	{
-	swaps(&i2->length,n);
-	swapl(&i2->resolution,n);
-	swapl(&i2->min_value,n);
-	swapl(&i2->max_value,n);
+	swaps(&i2->length);
+	swapl(&i2->resolution);
+	swapl(&i2->min_value);
+	swapl(&i2->max_value);
 	}
     *buf += sizeof (xIntegerFeedbackState);
     }
@@ -310,7 +305,6 @@ CopySwapStringFeedback (client, s, buf)
     char 		**buf;
     {
     int i;
-    register char 		n;
     xStringFeedbackState	*s2;
     KeySym			*kptr;
 
@@ -327,13 +321,13 @@ CopySwapStringFeedback (client, s, buf)
 	*kptr++ = *(s->ctrl.symbols_supported+i);
     if (client->swapped)
 	{
-	swaps(&s2->length,n);
-	swaps(&s2->max_symbols,n);
-	swaps(&s2->num_syms_supported,n);
+	swaps(&s2->length);
+	swaps(&s2->max_symbols);
+	swaps(&s2->num_syms_supported);
         kptr = (KeySym *) (*buf);
 	for (i=0; i<s->ctrl.num_symbols_supported; i++,kptr++)
 	    {
-	    swapl(kptr,n);
+	    swapl(kptr);
 	    }
 	}
     *buf += (s->ctrl.num_symbols_supported * sizeof (KeySym));
@@ -351,7 +345,6 @@ CopySwapLedFeedback (client, l, buf)
     LedFeedbackPtr 	l;
     char 		**buf;
     {
-    register char 	n;
     xLedFeedbackState	*l2;
 
     l2 = (xLedFeedbackState *) *buf;
@@ -362,9 +355,9 @@ CopySwapLedFeedback (client, l, buf)
     l2->led_mask = l->ctrl.led_mask;
     if (client->swapped)
 	{
-	swaps(&l2->length,n);
-	swapl(&l2->led_values,n);
-	swapl(&l2->led_mask,n);
+	swaps(&l2->length);
+	swapl(&l2->led_values);
+	swapl(&l2->led_mask);
 	}
     *buf += sizeof (xLedFeedbackState);
     }
@@ -381,7 +374,6 @@ CopySwapBellFeedback (client, b, buf)
     BellFeedbackPtr 	b;
     char 		**buf;
     {
-    register char 	n;
     xBellFeedbackState	*b2;
 
     b2 = (xBellFeedbackState *) *buf;
@@ -393,9 +385,9 @@ CopySwapBellFeedback (client, b, buf)
     b2->duration = b->ctrl.duration;
     if (client->swapped)
 	{
-	swaps(&b2->length,n);
-	swaps(&b2->pitch,n);
-	swaps(&b2->duration,n);
+	swaps(&b2->length);
+	swaps(&b2->pitch);
+	swaps(&b2->duration);
 	}
     *buf += sizeof (xBellFeedbackState);
     }
@@ -413,10 +405,8 @@ SRepXGetFeedbackControl (client, size, rep)
     int		size;
     xGetFeedbackControlReply	*rep;
     {
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
-    swaps(&rep->num_feedbacks, n);
+    swaps(&rep->sequenceNumber);
+    swapl(&rep->length);
+    swaps(&rep->num_feedbacks);
     WriteToClient(client, size, (char *)rep);
     }
diff --git a/nx-X11/programs/Xserver/Xi/getfocus.c b/nx-X11/programs/Xserver/Xi/getfocus.c
index 61a98f1bf..6e2136d65 100644
--- a/nx-X11/programs/Xserver/Xi/getfocus.c
+++ b/nx-X11/programs/Xserver/Xi/getfocus.c
@@ -81,10 +81,8 @@ int
 SProcXGetDeviceFocus(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xGetDeviceFocusReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     return(ProcXGetDeviceFocus(client));
     }
 
@@ -147,11 +145,9 @@ SRepXGetDeviceFocus (client, size, rep)
     int		size;
     xGetDeviceFocusReply	*rep;
     {
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
-    swapl(&rep->focus, n);
-    swapl(&rep->time, n);
+    swaps(&rep->sequenceNumber);
+    swapl(&rep->length);
+    swapl(&rep->focus);
+    swapl(&rep->time);
     WriteToClient(client, size, (char *)rep);
     }
diff --git a/nx-X11/programs/Xserver/Xi/getkmap.c b/nx-X11/programs/Xserver/Xi/getkmap.c
index fe8fd9b22..29d4eb677 100644
--- a/nx-X11/programs/Xserver/Xi/getkmap.c
+++ b/nx-X11/programs/Xserver/Xi/getkmap.c
@@ -82,10 +82,8 @@ int
 SProcXGetDeviceKeyMapping(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xGetDeviceKeyMappingReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     return(ProcXGetDeviceKeyMapping(client));
     }
 
@@ -169,10 +167,8 @@ SRepXGetDeviceKeyMapping (client, size, rep)
     int		size;
     xGetDeviceKeyMappingReply	*rep;
     {
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
+    swaps(&rep->sequenceNumber);
+    swapl(&rep->length);
     WriteToClient(client, size, (char *)rep);
     }
 
diff --git a/nx-X11/programs/Xserver/Xi/getmmap.c b/nx-X11/programs/Xserver/Xi/getmmap.c
index 203799103..773a65614 100644
--- a/nx-X11/programs/Xserver/Xi/getmmap.c
+++ b/nx-X11/programs/Xserver/Xi/getmmap.c
@@ -81,10 +81,8 @@ int
 SProcXGetDeviceModifierMapping(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xGetDeviceModifierMappingReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     return(ProcXGetDeviceModifierMapping(client));
     }
 
@@ -150,9 +148,7 @@ SRepXGetDeviceModifierMapping (client, size, rep)
     int		size;
     xGetDeviceModifierMappingReply	*rep;
     {
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
+    swaps(&rep->sequenceNumber);
+    swapl(&rep->length);
     WriteToClient(client, size, (char *)rep);
     }
diff --git a/nx-X11/programs/Xserver/Xi/getprop.c b/nx-X11/programs/Xserver/Xi/getprop.c
index 42403b0e5..824fae921 100644
--- a/nx-X11/programs/Xserver/Xi/getprop.c
+++ b/nx-X11/programs/Xserver/Xi/getprop.c
@@ -85,12 +85,10 @@ int
 SProcXGetDeviceDontPropagateList(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xGetDeviceDontPropagateListReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xGetDeviceDontPropagateListReq);
-    swapl(&stuff->window, n);
+    swapl(&stuff->window);
     return(ProcXGetDeviceDontPropagateList(client));
     }
 
@@ -206,10 +204,8 @@ SRepXGetDeviceDontPropagateList (client, size, rep)
     int		size;
     xGetDeviceDontPropagateListReply	*rep;
     {
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
-    swaps(&rep->count, n);
+    swaps(&rep->sequenceNumber);
+    swapl(&rep->length);
+    swaps(&rep->count);
     WriteToClient(client, size, (char *)rep);
     }
diff --git a/nx-X11/programs/Xserver/Xi/getselev.c b/nx-X11/programs/Xserver/Xi/getselev.c
index 8abea78d4..4fafef982 100644
--- a/nx-X11/programs/Xserver/Xi/getselev.c
+++ b/nx-X11/programs/Xserver/Xi/getselev.c
@@ -83,12 +83,10 @@ int
 SProcXGetSelectedExtensionEvents(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xGetSelectedExtensionEventsReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xGetSelectedExtensionEventsReq);
-    swapl(&stuff->window, n);
+    swapl(&stuff->window);
     return(ProcXGetSelectedExtensionEvents(client));
     }
 
@@ -186,11 +184,9 @@ SRepXGetSelectedExtensionEvents (client, size, rep)
     int		size;
     xGetSelectedExtensionEventsReply	*rep;
     {
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
-    swaps(&rep->this_client_count, n);
-    swaps(&rep->all_clients_count, n);
+    swaps(&rep->sequenceNumber);
+    swapl(&rep->length);
+    swaps(&rep->this_client_count);
+    swaps(&rep->all_clients_count);
     WriteToClient(client, size, (char *)rep);
     }
diff --git a/nx-X11/programs/Xserver/Xi/getvers.c b/nx-X11/programs/Xserver/Xi/getvers.c
index 7743e797f..34f4b0948 100644
--- a/nx-X11/programs/Xserver/Xi/getvers.c
+++ b/nx-X11/programs/Xserver/Xi/getvers.c
@@ -82,12 +82,10 @@ int
 SProcXGetExtensionVersion(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xGetExtensionVersionReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xGetExtensionVersionReq);
-    swaps(&stuff->nbytes, n);
+    swaps(&stuff->nbytes);
     return(ProcXGetExtensionVersion(client));
     }
 
@@ -148,11 +146,9 @@ SRepXGetExtensionVersion (client, size, rep)
     int		size;
     xGetExtensionVersionReply	*rep;
     {
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
-    swaps(&rep->major_version, n);
-    swaps(&rep->minor_version, n);
+    swaps(&rep->sequenceNumber);
+    swapl(&rep->length);
+    swaps(&rep->major_version);
+    swaps(&rep->minor_version);
     WriteToClient(client, size, (char *)rep);
     }
diff --git a/nx-X11/programs/Xserver/Xi/grabdev.c b/nx-X11/programs/Xserver/Xi/grabdev.c
index 865263688..bd085a660 100644
--- a/nx-X11/programs/Xserver/Xi/grabdev.c
+++ b/nx-X11/programs/Xserver/Xi/grabdev.c
@@ -86,14 +86,12 @@ int
 SProcXGrabDevice(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xGrabDeviceReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xGrabDeviceReq);
-    swapl(&stuff->grabWindow, n);
-    swapl(&stuff->time, n);
-    swaps(&stuff->event_count, n);
+    swapl(&stuff->grabWindow);
+    swapl(&stuff->time);
+    swaps(&stuff->event_count);
 
     if (stuff->length != (sizeof(xGrabDeviceReq) >> 2) + stuff->event_count)
        return BadLength;
@@ -221,9 +219,7 @@ SRepXGrabDevice (client, size, rep)
     int		size;
     xGrabDeviceReply	*rep;
     {
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
+    swaps(&rep->sequenceNumber);
+    swapl(&rep->length);
     WriteToClient(client, size, (char *)rep);
     }
diff --git a/nx-X11/programs/Xserver/Xi/grabdevb.c b/nx-X11/programs/Xserver/Xi/grabdevb.c
index 9a20345be..c74c65fc4 100644
--- a/nx-X11/programs/Xserver/Xi/grabdevb.c
+++ b/nx-X11/programs/Xserver/Xi/grabdevb.c
@@ -83,14 +83,12 @@ int
 SProcXGrabDeviceButton(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xGrabDeviceButtonReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xGrabDeviceButtonReq);
-    swapl(&stuff->grabWindow, n);
-    swaps(&stuff->modifiers, n);
-    swaps(&stuff->event_count, n);
+    swapl(&stuff->grabWindow);
+    swaps(&stuff->modifiers);
+    swaps(&stuff->event_count);
     REQUEST_FIXED_SIZE(xGrabDeviceButtonReq,
                       stuff->event_count * sizeof(CARD32));
     SwapLongs((CARD32 *) (&stuff[1]), stuff->event_count);
diff --git a/nx-X11/programs/Xserver/Xi/grabdevk.c b/nx-X11/programs/Xserver/Xi/grabdevk.c
index 73b8690b9..1dff73f40 100644
--- a/nx-X11/programs/Xserver/Xi/grabdevk.c
+++ b/nx-X11/programs/Xserver/Xi/grabdevk.c
@@ -83,14 +83,12 @@ int
 SProcXGrabDeviceKey(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xGrabDeviceKeyReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xGrabDeviceKeyReq);
-    swapl(&stuff->grabWindow, n);
-    swaps(&stuff->modifiers, n);
-    swaps(&stuff->event_count, n);
+    swapl(&stuff->grabWindow);
+    swaps(&stuff->modifiers);
+    swaps(&stuff->event_count);
     REQUEST_FIXED_SIZE(xGrabDeviceKeyReq, stuff->event_count * sizeof(CARD32));
     SwapLongs((CARD32 *) (&stuff[1]), stuff->event_count);
     return(ProcXGrabDeviceKey(client));
diff --git a/nx-X11/programs/Xserver/Xi/gtmotion.c b/nx-X11/programs/Xserver/Xi/gtmotion.c
index ec26ae407..9f1ce2fc0 100644
--- a/nx-X11/programs/Xserver/Xi/gtmotion.c
+++ b/nx-X11/programs/Xserver/Xi/gtmotion.c
@@ -81,13 +81,11 @@ int
 SProcXGetDeviceMotionEvents(client)
 register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xGetDeviceMotionEventsReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xGetDeviceMotionEventsReq);
-    swapl(&stuff->start, n);
-    swapl(&stuff->stop, n);
+    swapl(&stuff->start);
+    swapl(&stuff->stop);
     return(ProcXGetDeviceMotionEvents(client));
     }
 
@@ -175,12 +173,10 @@ ProcXGetDeviceMotionEvents(client)
         {
 	if (client->swapped)
 	    {
-    	    register 	char n;
-
 	    bufptr = coords;
 	    for (i=0; i<nEvents * (axes+1); i++)
 		{
-    		swapl(bufptr, n);
+		swapl(bufptr);
 		bufptr++;
 		}
 	    }
@@ -204,10 +200,8 @@ SRepXGetDeviceMotionEvents (client, size, rep)
     int		size;
     xGetDeviceMotionEventsReply	*rep;
     {
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
-    swapl(&rep->nEvents, n);
+    swaps(&rep->sequenceNumber);
+    swapl(&rep->length);
+    swapl(&rep->nEvents);
     WriteToClient(client, size, (char *)rep);
     }
diff --git a/nx-X11/programs/Xserver/Xi/listdev.c b/nx-X11/programs/Xserver/Xi/listdev.c
index 7f3b49e89..ad11652b9 100644
--- a/nx-X11/programs/Xserver/Xi/listdev.c
+++ b/nx-X11/programs/Xserver/Xi/listdev.c
@@ -83,10 +83,8 @@ int
 SProcXListInputDevices(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xListInputDevicesReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     return(ProcXListInputDevices(client));
     }
 
@@ -254,7 +252,6 @@ CopySwapDevice (client, d, num_classes, buf)
     int			num_classes;
     char 		**buf;
     {
-    register char 	n;
     xDeviceInfoPtr dev;
 
     dev = (xDeviceInfoPtr) *buf;
@@ -270,7 +267,7 @@ CopySwapDevice (client, d, num_classes, buf)
 	dev->use = IsXExtensionDevice;
     if (client->swapped)
 	{
-	swapl(&dev->type, n);	/* macro - braces are required */
+	swapl(&dev->type);	/* macro - braces are required */
 	}
     *buf += sizeof (xDeviceInfo);
     }
@@ -287,7 +284,6 @@ CopySwapKeyClass (client, k, buf)
     KeyClassPtr 	k;
     char 		**buf;
     {
-    register char 	n;
     xKeyInfoPtr 	k2;
 
     k2 = (xKeyInfoPtr) *buf;
@@ -298,7 +294,7 @@ CopySwapKeyClass (client, k, buf)
     k2->num_keys = k2->max_keycode - k2->min_keycode + 1;
     if (client->swapped)
 	{
-	swaps(&k2->num_keys,n);
+	swaps(&k2->num_keys);
 	}
     *buf += sizeof (xKeyInfo);
     }
@@ -315,7 +311,6 @@ CopySwapButtonClass (client, b, buf)
     ButtonClassPtr 	b;
     char 		**buf;
     {
-    register char 	n;
     xButtonInfoPtr 	b2;
 
     b2 = (xButtonInfoPtr) *buf;
@@ -324,7 +319,7 @@ CopySwapButtonClass (client, b, buf)
     b2->num_buttons = b->numButtons;
     if (client->swapped)
 	{
-	swaps(&b2->num_buttons,n);	/* macro - braces are required */
+	swaps(&b2->num_buttons);	/* macro - braces are required */
 	}
     *buf += sizeof (xButtonInfo);
     }
@@ -348,7 +343,6 @@ CopySwapValuatorClass (client, v, buf)
     char 		**buf;
 {
     int			i, j, axes, t_axes;
-    register char 	n;
     xValuatorInfoPtr 	v2;
     AxisInfo 		*a;
     xAxisInfoPtr 	a2;
@@ -365,7 +359,7 @@ CopySwapValuatorClass (client, v, buf)
 	v2->motion_buffer_size  = v->numMotionEvents;
 	if (client->swapped)
 	    {
-	    swapl(&v2->motion_buffer_size,n);
+	    swapl(&v2->motion_buffer_size);
 	    }
 	*buf += sizeof (xValuatorInfo);
 	a = v->axes + (VPC * i);
@@ -375,9 +369,9 @@ CopySwapValuatorClass (client, v, buf)
 	    a2->max_value = a->max_value;
 	    a2->resolution = a->resolution;
 	    if (client->swapped) {
-		swapl(&a2->min_value,n);
-		swapl(&a2->max_value,n);
-		swapl(&a2->resolution,n);
+		swapl(&a2->min_value);
+		swapl(&a2->max_value);
+		swapl(&a2->resolution);
 	    }
 	    a2++;
 	    a++;
@@ -400,9 +394,7 @@ SRepXListInputDevices (client, size, rep)
     int		size;
     xListInputDevicesReply	*rep;
     {
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
+    swaps(&rep->sequenceNumber);
+    swapl(&rep->length);
     WriteToClient(client, size, (char *)rep);
     }
diff --git a/nx-X11/programs/Xserver/Xi/opendev.c b/nx-X11/programs/Xserver/Xi/opendev.c
index 054dae159..73eba526c 100644
--- a/nx-X11/programs/Xserver/Xi/opendev.c
+++ b/nx-X11/programs/Xserver/Xi/opendev.c
@@ -85,10 +85,8 @@ int
 SProcXOpenDevice(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xOpenDeviceReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     return(ProcXOpenDevice(client));
     }
 
@@ -198,9 +196,7 @@ SRepXOpenDevice (client, size, rep)
     int		size;
     xOpenDeviceReply	*rep;
     {
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
+    swaps(&rep->sequenceNumber);
+    swapl(&rep->length);
     WriteToClient(client, size, (char *)rep);
     }
diff --git a/nx-X11/programs/Xserver/Xi/queryst.c b/nx-X11/programs/Xserver/Xi/queryst.c
index a590aa0e1..237c263dc 100644
--- a/nx-X11/programs/Xserver/Xi/queryst.c
+++ b/nx-X11/programs/Xserver/Xi/queryst.c
@@ -63,10 +63,8 @@ int
 SProcXQueryDeviceState(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xQueryDeviceStateReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     return(ProcXQueryDeviceState(client));
     }
 
@@ -80,7 +78,6 @@ int
 ProcXQueryDeviceState(client)
     register ClientPtr client;
     {
-    register char 		n;
     int 			i;
     int 			num_classes = 0;
     int 			total_length = 0;
@@ -179,7 +176,7 @@ ProcXQueryDeviceState(client)
 	    *((int *) buf) = *values++;
 	    if (client->swapped)
 		{
-		swapl ((int *) buf, n);/* macro - braces needed */
+		swapl ((int *) buf);/* macro - braces needed */
 		}
 	    buf += sizeof(int);
 	    }
@@ -207,9 +204,7 @@ SRepXQueryDeviceState (client, size, rep)
     int		size;
     xQueryDeviceStateReply	*rep;
     {
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
+    swaps(&rep->sequenceNumber);
+    swapl(&rep->length);
     WriteToClient(client, size, (char *)rep);
     }
diff --git a/nx-X11/programs/Xserver/Xi/selectev.c b/nx-X11/programs/Xserver/Xi/selectev.c
index de29fcf59..1a1000f61 100644
--- a/nx-X11/programs/Xserver/Xi/selectev.c
+++ b/nx-X11/programs/Xserver/Xi/selectev.c
@@ -87,13 +87,11 @@ int
 SProcXSelectExtensionEvent (client)
 register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xSelectExtensionEventReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xSelectExtensionEventReq);
-    swapl(&stuff->window, n);
-    swaps(&stuff->count, n);
+    swapl(&stuff->window);
+    swaps(&stuff->count);
     REQUEST_FIXED_SIZE(xSelectExtensionEventReq,
                       stuff->count * sizeof(CARD32));
     SwapLongs((CARD32 *) (&stuff[1]), stuff->count);
diff --git a/nx-X11/programs/Xserver/Xi/sendexev.c b/nx-X11/programs/Xserver/Xi/sendexev.c
index 9decfadab..64191001f 100644
--- a/nx-X11/programs/Xserver/Xi/sendexev.c
+++ b/nx-X11/programs/Xserver/Xi/sendexev.c
@@ -86,7 +86,6 @@ int
 SProcXSendExtensionEvent(client)
     register ClientPtr client;
     {
-    register char n;
     CARD32 *p;
     register int i;
     xEvent eventT;
@@ -94,10 +93,10 @@ SProcXSendExtensionEvent(client)
     EventSwapPtr proc;
 
     REQUEST(xSendExtensionEventReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xSendExtensionEventReq);
-    swapl(&stuff->destination, n);
-    swaps(&stuff->count, n);
+    swapl(&stuff->destination);
+    swaps(&stuff->count);
 
     if (stuff->length != (sizeof(xSendExtensionEventReq) >> 2) + stuff->count +
        (stuff->num_events * (sizeof(xEvent) >> 2)))
@@ -154,6 +153,8 @@ ProcXSendExtensionEvent (client)
 	return Success;
 	}
 
+    // FIXME: ret is not initialized and should not be returned...
+
     if (stuff->num_events == 0)
         return ret;
 
diff --git a/nx-X11/programs/Xserver/Xi/setbmap.c b/nx-X11/programs/Xserver/Xi/setbmap.c
index 74b8e3c05..2919f48f1 100644
--- a/nx-X11/programs/Xserver/Xi/setbmap.c
+++ b/nx-X11/programs/Xserver/Xi/setbmap.c
@@ -84,10 +84,8 @@ int
 SProcXSetDeviceButtonMapping(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xSetDeviceButtonMappingReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     return(ProcXSetDeviceButtonMapping(client));
     }
 
@@ -162,9 +160,7 @@ SRepXSetDeviceButtonMapping (client, size, rep)
     int		size;
     xSetDeviceButtonMappingReply	*rep;
     {
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
+    swaps(&rep->sequenceNumber);
+    swapl(&rep->length);
     WriteToClient(client, size, (char *)rep);
     }
diff --git a/nx-X11/programs/Xserver/Xi/setdval.c b/nx-X11/programs/Xserver/Xi/setdval.c
index 04f55d4fc..c4613dd37 100644
--- a/nx-X11/programs/Xserver/Xi/setdval.c
+++ b/nx-X11/programs/Xserver/Xi/setdval.c
@@ -81,10 +81,8 @@ int
 SProcXSetDeviceValuators(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xSetDeviceValuatorsReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     return(ProcXSetDeviceValuators(client));
     }
 
@@ -166,9 +164,7 @@ SRepXSetDeviceValuators (client, size, rep)
     int		size;
     xSetDeviceValuatorsReply	*rep;
     {
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
+    swaps(&rep->sequenceNumber);
+    swapl(&rep->length);
     WriteToClient(client, size, (char *)rep);
     }
diff --git a/nx-X11/programs/Xserver/Xi/setfocus.c b/nx-X11/programs/Xserver/Xi/setfocus.c
index b9a495612..180fb835e 100644
--- a/nx-X11/programs/Xserver/Xi/setfocus.c
+++ b/nx-X11/programs/Xserver/Xi/setfocus.c
@@ -84,13 +84,11 @@ int
 SProcXSetDeviceFocus(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xSetDeviceFocusReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xSetDeviceFocusReq);
-    swapl(&stuff->focus, n);
-    swapl(&stuff->time, n);
+    swapl(&stuff->focus);
+    swapl(&stuff->time);
     return(ProcXSetDeviceFocus(client));
     }
 
diff --git a/nx-X11/programs/Xserver/Xi/setmmap.c b/nx-X11/programs/Xserver/Xi/setmmap.c
index 9fd8e7244..c2e7beb4a 100644
--- a/nx-X11/programs/Xserver/Xi/setmmap.c
+++ b/nx-X11/programs/Xserver/Xi/setmmap.c
@@ -82,10 +82,8 @@ int
 SProcXSetDeviceModifierMapping(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xSetDeviceModifierMappingReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     return(ProcXSetDeviceModifierMapping(client));
     }
 
@@ -155,10 +153,8 @@ SRepXSetDeviceModifierMapping (client, size, rep)
     int		size;
     xSetDeviceModifierMappingReply	*rep;
     {
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
+    swaps(&rep->sequenceNumber);
+    swapl(&rep->length);
     WriteToClient(client, size, (char *)rep);
     }
 
diff --git a/nx-X11/programs/Xserver/Xi/setmode.c b/nx-X11/programs/Xserver/Xi/setmode.c
index 17c46515d..4314d6465 100644
--- a/nx-X11/programs/Xserver/Xi/setmode.c
+++ b/nx-X11/programs/Xserver/Xi/setmode.c
@@ -81,10 +81,8 @@ int
 SProcXSetDeviceMode(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xSetDeviceModeReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     return(ProcXSetDeviceMode(client));
     }
 
@@ -150,9 +148,7 @@ SRepXSetDeviceMode (client, size, rep)
     int		size;
     xSetDeviceModeReply	*rep;
     {
-    register char n;
-
-    swaps(&rep->sequenceNumber, n);
-    swapl(&rep->length, n);
+    swaps(&rep->sequenceNumber);
+    swapl(&rep->length);
     WriteToClient(client, size, (char *)rep);
     }
diff --git a/nx-X11/programs/Xserver/Xi/ungrdev.c b/nx-X11/programs/Xserver/Xi/ungrdev.c
index b318fa044..a0611d53b 100644
--- a/nx-X11/programs/Xserver/Xi/ungrdev.c
+++ b/nx-X11/programs/Xserver/Xi/ungrdev.c
@@ -80,12 +80,10 @@ int
 SProcXUngrabDevice(client)
 register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xUngrabDeviceReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xUngrabDeviceReq);
-    swapl(&stuff->time, n);
+    swapl(&stuff->time);
     return(ProcXUngrabDevice(client));
     }
 
diff --git a/nx-X11/programs/Xserver/Xi/ungrdevb.c b/nx-X11/programs/Xserver/Xi/ungrdevb.c
index a76f9692c..dd770064d 100644
--- a/nx-X11/programs/Xserver/Xi/ungrdevb.c
+++ b/nx-X11/programs/Xserver/Xi/ungrdevb.c
@@ -86,13 +86,11 @@ int
 SProcXUngrabDeviceButton(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xUngrabDeviceButtonReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xUngrabDeviceButtonReq);
-    swapl(&stuff->grabWindow, n);
-    swaps(&stuff->modifiers, n);
+    swapl(&stuff->grabWindow);
+    swaps(&stuff->modifiers);
     return(ProcXUngrabDeviceButton(client));
     }
 
diff --git a/nx-X11/programs/Xserver/Xi/ungrdevk.c b/nx-X11/programs/Xserver/Xi/ungrdevk.c
index 928b602f1..fcb470eaa 100644
--- a/nx-X11/programs/Xserver/Xi/ungrdevk.c
+++ b/nx-X11/programs/Xserver/Xi/ungrdevk.c
@@ -86,13 +86,11 @@ int
 SProcXUngrabDeviceKey(client)
     register ClientPtr client;
     {
-    register char n;
-
     REQUEST(xUngrabDeviceKeyReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xUngrabDeviceKeyReq);
-    swapl(&stuff->grabWindow, n);
-    swaps(&stuff->modifiers, n);
+    swapl(&stuff->grabWindow);
+    swaps(&stuff->modifiers);
     return(ProcXUngrabDeviceKey(client));
     }
 
diff --git a/nx-X11/programs/Xserver/composite/compext.c b/nx-X11/programs/Xserver/composite/compext.c
index dbde88625..7c629fc54 100644
--- a/nx-X11/programs/Xserver/composite/compext.c
+++ b/nx-X11/programs/Xserver/composite/compext.c
@@ -113,7 +113,6 @@ ProcCompositeQueryVersion (ClientPtr client)
         .sequenceNumber = client->sequence,
         .length = 0
     };
-    register int n;
 
     REQUEST(xCompositeQueryVersionReq);
 
@@ -128,10 +127,10 @@ ProcCompositeQueryVersion (ClientPtr client)
     pCompositeClient->major_version = rep.majorVersion;
     pCompositeClient->minor_version = rep.minorVersion;
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-    	swapl(&rep.length, n);
-	swapl(&rep.majorVersion, n);
-	swapl(&rep.minorVersion, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swapl(&rep.majorVersion);
+	swapl(&rep.minorVersion);
     }
     WriteToClient(client, sizeof(xCompositeQueryVersionReply), (char *)&rep);
     return Success;
@@ -352,7 +351,6 @@ ProcCompositeGetOverlayWindow(ClientPtr client)
     CompScreenPtr cs;
     CompOverlayClientPtr pOc;
     int rc;
-    int n = 0;
 
     REQUEST_SIZE_MATCH(xCompositeGetOverlayWindowReq);
     /* Unsupported by current architecture and porting is too much effort. */
@@ -403,9 +401,9 @@ ProcCompositeGetOverlayWindow(ClientPtr client)
     };
 
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.overlayWin, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.overlayWin);
     }
     WriteToClient(client, sz_xCompositeGetOverlayWindowReply, (char *)&rep);
 
@@ -470,111 +468,102 @@ ProcCompositeDispatch (ClientPtr client)
 static int
 SProcCompositeQueryVersion (ClientPtr client)
 {
-    int n;
     REQUEST(xCompositeQueryVersionReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xCompositeQueryVersionReq);
-    swapl(&stuff->majorVersion, n);
-    swapl(&stuff->minorVersion, n);
+    swapl(&stuff->majorVersion);
+    swapl(&stuff->minorVersion);
     return (*ProcCompositeVector[stuff->compositeReqType]) (client);
 }
 
 static int
 SProcCompositeRedirectWindow (ClientPtr client)
 {
-    int n;
     REQUEST(xCompositeRedirectWindowReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xCompositeRedirectWindowReq);
-    swapl (&stuff->window, n);
+    swapl (&stuff->window);
     return (*ProcCompositeVector[stuff->compositeReqType]) (client);
 }
 
 static int
 SProcCompositeRedirectSubwindows (ClientPtr client)
 {
-    int n;
     REQUEST(xCompositeRedirectSubwindowsReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xCompositeRedirectSubwindowsReq);
-    swapl (&stuff->window, n);
+    swapl (&stuff->window);
     return (*ProcCompositeVector[stuff->compositeReqType]) (client);
 }
 
 static int
 SProcCompositeUnredirectWindow (ClientPtr client)
 {
-    int n;
     REQUEST(xCompositeUnredirectWindowReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xCompositeUnredirectWindowReq);
-    swapl (&stuff->window, n);
+    swapl (&stuff->window);
     return (*ProcCompositeVector[stuff->compositeReqType]) (client);
 }
 
 static int
 SProcCompositeUnredirectSubwindows (ClientPtr client)
 {
-    int n;
     REQUEST(xCompositeUnredirectSubwindowsReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xCompositeUnredirectSubwindowsReq);
-    swapl (&stuff->window, n);
+    swapl (&stuff->window);
     return (*ProcCompositeVector[stuff->compositeReqType]) (client);
 }
 
 static int
 SProcCompositeCreateRegionFromBorderClip (ClientPtr client)
 {
-    int n;
     REQUEST(xCompositeCreateRegionFromBorderClipReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xCompositeCreateRegionFromBorderClipReq);
-    swapl (&stuff->region, n);
-    swapl (&stuff->window, n);
+    swapl (&stuff->region);
+    swapl (&stuff->window);
     return (*ProcCompositeVector[stuff->compositeReqType]) (client);
 }
 
 static int
 SProcCompositeNameWindowPixmap (ClientPtr client)
 {
-    int n;
     REQUEST(xCompositeNameWindowPixmapReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xCompositeNameWindowPixmapReq);
-    swapl (&stuff->window, n);
-    swapl (&stuff->pixmap, n);
+    swapl (&stuff->window);
+    swapl (&stuff->pixmap);
     return (*ProcCompositeVector[stuff->compositeReqType]) (client);
 }
 
 static int
 SProcCompositeGetOverlayWindow(ClientPtr client)
 {
-    int n = 0;
     REQUEST(xCompositeGetOverlayWindowReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xCompositeGetOverlayWindowReq);
-    swapl(&stuff->window, n);
+    swapl(&stuff->window);
     return (*ProcCompositeVector[stuff->compositeReqType]) (client);
 }
 
 static int
 SProcCompositeReleaseOverlayWindow(ClientPtr client)
 {
-    int n = 0;
     REQUEST(xCompositeReleaseOverlayWindowReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xCompositeReleaseOverlayWindowReq);
-    swapl(&stuff->window, n);
+    swapl(&stuff->window);
     return (*ProcCompositeVector[stuff->compositeReqType]) (client);
 }
 
@@ -903,7 +892,6 @@ PanoramiXCompositeGetOverlayWindow(ClientPtr client)
     int rc;
     PanoramiXRes *win, *overlayWin = NULL;
     int i;
-    int n = 0;
 
     REQUEST_SIZE_MATCH(xCompositeGetOverlayWindowReq);
 
@@ -986,9 +974,9 @@ PanoramiXCompositeGetOverlayWindow(ClientPtr client)
     };
 
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.overlayWin, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.overlayWin);
     }
     WriteToClient(client, sz_xCompositeGetOverlayWindowReply, &rep);
 
diff --git a/nx-X11/programs/Xserver/damageext/damageext.c b/nx-X11/programs/Xserver/damageext/damageext.c
index 88858f621..b2ee82657 100755
--- a/nx-X11/programs/Xserver/damageext/damageext.c
+++ b/nx-X11/programs/Xserver/damageext/damageext.c
@@ -137,7 +137,6 @@ ProcDamageQueryVersion(ClientPtr client)
 {
     DamageClientPtr pDamageClient = GetDamageClient (client);
     xDamageQueryVersionReply rep;
-    register int n;
     REQUEST(xDamageQueryVersionReq);
 
     REQUEST_SIZE_MATCH(xDamageQueryVersionReq);
@@ -158,10 +157,10 @@ ProcDamageQueryVersion(ClientPtr client)
     pDamageClient->major_version = rep.majorVersion;
     pDamageClient->minor_version = rep.minorVersion;
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-    	swapl(&rep.length, n);
-	swapl(&rep.majorVersion, n);
-	swapl(&rep.minorVersion, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swapl(&rep.majorVersion);
+	swapl(&rep.minorVersion);
     }
     WriteToClient(client, sizeof(xDamageQueryVersionReply), (char *)&rep);
     return(client->noClientException);
@@ -309,52 +308,48 @@ ProcDamageDispatch (ClientPtr client)
 static int
 SProcDamageQueryVersion(ClientPtr client)
 {
-    register int n;
     REQUEST(xDamageQueryVersionReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xDamageQueryVersionReq);
-    swapl(&stuff->majorVersion, n);
-    swapl(&stuff->minorVersion, n);
+    swapl(&stuff->majorVersion);
+    swapl(&stuff->minorVersion);
     return (*ProcDamageVector[stuff->damageReqType]) (client);
 }
 
 static int
 SProcDamageCreate (ClientPtr client)
 {
-    register int n;
     REQUEST(xDamageCreateReq);
     
-    swaps (&stuff->length, n);
+    swaps (&stuff->length);
     REQUEST_SIZE_MATCH(xDamageCreateReq);
-    swapl (&stuff->damage, n);
-    swapl (&stuff->drawable, n);
+    swapl (&stuff->damage);
+    swapl (&stuff->drawable);
     return (*ProcDamageVector[stuff->damageReqType]) (client);
 }
 
 static int
 SProcDamageDestroy (ClientPtr client)
 {
-    register int n;
     REQUEST(xDamageDestroyReq);
     
-    swaps (&stuff->length, n);
+    swaps (&stuff->length);
     REQUEST_SIZE_MATCH(xDamageDestroyReq);
-    swapl (&stuff->damage, n);
+    swapl (&stuff->damage);
     return (*ProcDamageVector[stuff->damageReqType]) (client);
 }
 
 static int
 SProcDamageSubtract (ClientPtr client)
 {
-    register int n;
     REQUEST(xDamageSubtractReq);
     
-    swaps (&stuff->length, n);
+    swaps (&stuff->length);
     REQUEST_SIZE_MATCH(xDamageSubtractReq);
-    swapl (&stuff->damage, n);
-    swapl (&stuff->repair, n);
-    swapl (&stuff->parts, n);
+    swapl (&stuff->damage);
+    swapl (&stuff->repair);
+    swapl (&stuff->parts);
     return (*ProcDamageVector[stuff->damageReqType]) (client);
 }
 
diff --git a/nx-X11/programs/Xserver/dbe/dbe.c b/nx-X11/programs/Xserver/dbe/dbe.c
index 5687f3d56..0525546a0 100644
--- a/nx-X11/programs/Xserver/dbe/dbe.c
+++ b/nx-X11/programs/Xserver/dbe/dbe.c
@@ -362,8 +362,6 @@ ProcDbeGetVersion(client)
 {
     /* REQUEST(xDbeGetVersionReq); */
     xDbeGetVersionReply	rep;
-    register int	n;
-
 
     REQUEST_SIZE_MATCH(xDbeGetVersionReq);
 
@@ -375,7 +373,7 @@ ProcDbeGetVersion(client)
 
     if (client->swapped)
     {
-        swaps(&rep.sequenceNumber, n);
+        swaps(&rep.sequenceNumber);
     }
 
     WriteToClient(client, sizeof(xDbeGetVersionReply), (char *)&rep);
@@ -898,7 +896,7 @@ ProcDbeGetVisualInfo(client)
     xDbeGetVisualInfoReply	rep;
     Drawable			*drawables;
     DrawablePtr			*pDrawables = NULL;
-    register int		i, j, n;
+    register int		i, j;
     register int		count;  /* number of visual infos in reply */
     register int		length; /* length of reply */
     ScreenPtr			pScreen;
@@ -984,9 +982,9 @@ ProcDbeGetVisualInfo(client)
 
     if (client->swapped)
     {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.m, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.m);
     }
 
     /* Send off reply. */
@@ -1003,7 +1001,7 @@ ProcDbeGetVisualInfo(client)
 
         if (client->swapped)
         {
-            swapl(&data32, n);
+            swapl(&data32);
         }
 
         WriteToClient(client, sizeof(CARD32), (char *)&data32);
@@ -1024,7 +1022,7 @@ ProcDbeGetVisualInfo(client)
 
             if (client->swapped)
             {
-                swapl(&visInfo.visualID, n);
+                swapl(&visInfo.visualID);
 
                 /* We do not need to swap depth and perfLevel since they are
                  * already 1 byte quantities.
@@ -1075,8 +1073,6 @@ ProcDbeGetBackBufferAttributes(client)
     REQUEST(xDbeGetBackBufferAttributesReq);
     xDbeGetBackBufferAttributesReply	rep;
     DbeWindowPrivPtr			pDbeWindowPriv;
-    int					n;
-
 
     REQUEST_SIZE_MATCH(xDbeGetBackBufferAttributesReq);
 
@@ -1096,9 +1092,9 @@ ProcDbeGetBackBufferAttributes(client)
     
     if (client->swapped)
     {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.attributes, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.attributes);
     }
 
     WriteToClient(client, sizeof(xDbeGetBackBufferAttributesReply),
@@ -1179,10 +1175,8 @@ SProcDbeGetVersion(client)
     ClientPtr client;
 {
     REQUEST(xDbeGetVersionReq);
-    register int	n;
-
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     return(ProcDbeGetVersion(client));
 
 } /* SProcDbeGetVersion() */
@@ -1216,13 +1210,12 @@ SProcDbeAllocateBackBufferName(client)
     ClientPtr client;
 {
     REQUEST(xDbeAllocateBackBufferNameReq);
-    register int	n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xDbeAllocateBackBufferNameReq);
 
-    swapl(&stuff->window, n);
-    swapl(&stuff->buffer, n);
+    swapl(&stuff->window);
+    swapl(&stuff->buffer);
     /* stuff->swapAction is a byte.  We do not need to swap this field. */
 
     return(ProcDbeAllocateBackBufferName(client));
@@ -1252,13 +1245,11 @@ SProcDbeDeallocateBackBufferName(client)
     ClientPtr client;
 {
     REQUEST (xDbeDeallocateBackBufferNameReq);
-    register int	n;
 
-
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xDbeDeallocateBackBufferNameReq);
 
-    swapl(&stuff->buffer, n);
+    swapl(&stuff->buffer);
 
     return(ProcDbeDeallocateBackBufferName(client));
 
@@ -1291,14 +1282,14 @@ SProcDbeSwapBuffers(client)
     ClientPtr client;
 {
     REQUEST(xDbeSwapBuffersReq);
-    unsigned int	i, n;
+    unsigned int	i;
     xDbeSwapInfo	*pSwapInfo;
 
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xDbeSwapBuffersReq);
 
-    swapl(&stuff->n, n);
+    swapl(&stuff->n);
     if (stuff->n > UINT32_MAX / sizeof(DbeSwapInfoRec))
         return BadAlloc;
     REQUEST_FIXED_SIZE(xDbeSwapBuffersReq, stuff->n * sizeof(xDbeSwapInfo));
@@ -1313,7 +1304,7 @@ SProcDbeSwapBuffers(client)
          */
         for (i = 0; i < stuff->n; i++)
         {
-            swapl(&pSwapInfo->window, n);
+            swapl(&pSwapInfo->window);
         }
     }
 
@@ -1343,9 +1334,8 @@ SProcDbeBeginIdiom(client)
     ClientPtr client;
 {
     REQUEST(xDbeBeginIdiomReq);
-    register int	n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     return(ProcDbeBeginIdiom(client));
 
 } /* SProcDbeBeginIdiom() */
@@ -1373,13 +1363,11 @@ SProcDbeGetVisualInfo(client)
     ClientPtr client;
 {
     REQUEST(xDbeGetVisualInfoReq);
-    register int	n;
-
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xDbeGetVisualInfoReq);
 
-    swapl(&stuff->n, n);
+    swapl(&stuff->n);
     SwapRestL(stuff);
 
     return(ProcDbeGetVisualInfo(client));
@@ -1408,12 +1396,11 @@ SProcDbeGetBackBufferAttributes(client)
     ClientPtr client;
 {
     REQUEST (xDbeGetBackBufferAttributesReq);
-    register int	n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xDbeGetBackBufferAttributesReq);
 
-    swapl(&stuff->buffer, n);
+    swapl(&stuff->buffer);
 
     return(ProcDbeGetBackBufferAttributes(client));
 
diff --git a/nx-X11/programs/Xserver/dix/dispatch.c b/nx-X11/programs/Xserver/dix/dispatch.c
index aac3284a7..f799ce289 100644
--- a/nx-X11/programs/Xserver/dix/dispatch.c
+++ b/nx-X11/programs/Xserver/dix/dispatch.c
@@ -3808,7 +3808,7 @@ ProcInitialConnection(register ClientPtr client)
 		     ((prefix->nbytesAuthString + (unsigned)3) >> 2);
     if (client->swapped)
     {
-	swaps(&stuff->length, whichbyte);
+	swaps(&stuff->length);
     }
     ResetCurrentRequest(client);
     return (client->noClientException);
diff --git a/nx-X11/programs/Xserver/dix/swaprep.c b/nx-X11/programs/Xserver/dix/swaprep.c
index 31c823b3a..e5c722f31 100644
--- a/nx-X11/programs/Xserver/dix/swaprep.c
+++ b/nx-X11/programs/Xserver/dix/swaprep.c
@@ -78,14 +78,13 @@ void
 Swap32Write(ClientPtr pClient, int size, register CARD32 *pbuf)
 {
     register int i;
-    register char n;
 
     size >>= 2;
     for(i = 0; i < size; i++)
     /* brackets are mandatory here, because "swapl" macro expands
        to several statements */
     {   
-	swapl(&pbuf[i], n);
+	swapl(&pbuf[i]);
     }
     (void)WriteToClient(pClient, size << 2, (char *) pbuf);
 }
@@ -191,9 +190,7 @@ CopySwap16Write(ClientPtr pClient, int size, short *pbuf)
 void
 SGenericReply(ClientPtr pClient, int size, xGenericReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
+    swaps(&pRep->sequenceNumber);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
@@ -202,67 +199,57 @@ void
 SGetWindowAttributesReply(ClientPtr pClient, int size,
                           xGetWindowAttributesReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->length, n);
-    swapl(&pRep->visualID, n);
-    swaps(&pRep->class, n);
-    swapl(&pRep->backingBitPlanes, n);
-    swapl(&pRep->backingPixel, n);
-    swapl(&pRep->colormap, n);
-    swapl(&pRep->allEventMasks, n);
-    swapl(&pRep->yourEventMask, n);
-    swaps(&pRep->doNotPropagateMask, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->length);
+    swapl(&pRep->visualID);
+    swaps(&pRep->class);
+    swapl(&pRep->backingBitPlanes);
+    swapl(&pRep->backingPixel);
+    swapl(&pRep->colormap);
+    swapl(&pRep->allEventMasks);
+    swapl(&pRep->yourEventMask);
+    swaps(&pRep->doNotPropagateMask);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
 void
 SGetGeometryReply(ClientPtr pClient, int size, xGetGeometryReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->root, n);
-    swaps(&pRep->x, n);
-    swaps(&pRep->y, n);
-    swaps(&pRep->width, n);
-    swaps(&pRep->height, n);
-    swaps(&pRep->borderWidth, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->root);
+    swaps(&pRep->x);
+    swaps(&pRep->y);
+    swaps(&pRep->width);
+    swaps(&pRep->height);
+    swaps(&pRep->borderWidth);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
 void
 SQueryTreeReply(ClientPtr pClient, int size, xQueryTreeReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->length, n);
-    swapl(&pRep->root, n);
-    swapl(&pRep->parent, n);
-    swaps(&pRep->nChildren, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->length);
+    swapl(&pRep->root);
+    swapl(&pRep->parent);
+    swaps(&pRep->nChildren);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
 void
 SInternAtomReply(ClientPtr pClient, int size, xInternAtomReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->atom, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->atom);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
 void
 SGetAtomNameReply(ClientPtr pClient, int size, xGetAtomNameReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->length, n);
-    swaps(&pRep->nameLength, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->length);
+    swaps(&pRep->nameLength);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
@@ -270,24 +257,20 @@ SGetAtomNameReply(ClientPtr pClient, int size, xGetAtomNameReply *pRep)
 void
 SGetPropertyReply(ClientPtr pClient, int size, xGetPropertyReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->length, n);
-    swapl(&pRep->propertyType, n);
-    swapl(&pRep->bytesAfter, n);
-    swapl(&pRep->nItems, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->length);
+    swapl(&pRep->propertyType);
+    swapl(&pRep->bytesAfter);
+    swapl(&pRep->nItems);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
 void
 SListPropertiesReply(ClientPtr pClient, int size, xListPropertiesReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->length, n);
-    swaps(&pRep->nProperties, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->length);
+    swaps(&pRep->nProperties);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
@@ -295,10 +278,8 @@ void
 SGetSelectionOwnerReply(ClientPtr pClient, int size,
                         xGetSelectionOwnerReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->owner, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->owner);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
@@ -306,27 +287,23 @@ SGetSelectionOwnerReply(ClientPtr pClient, int size,
 void
 SQueryPointerReply(ClientPtr pClient, int size, xQueryPointerReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->root, n);
-    swapl(&pRep->child, n);
-    swaps(&pRep->rootX, n);
-    swaps(&pRep->rootY, n);
-    swaps(&pRep->winX, n);
-    swaps(&pRep->winY, n);
-    swaps(&pRep->mask, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->root);
+    swapl(&pRep->child);
+    swaps(&pRep->rootX);
+    swaps(&pRep->rootY);
+    swaps(&pRep->winX);
+    swaps(&pRep->winY);
+    swaps(&pRep->mask);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
 void
 SwapTimecoord(xTimecoord* pCoord)
 {
-    register char n;
-
-    swapl(&pCoord->time, n);
-    swaps(&pCoord->x, n);
-    swaps(&pCoord->y, n);
+    swapl(&pCoord->time);
+    swaps(&pCoord->x);
+    swaps(&pCoord->y);
 }
 
 void
@@ -348,33 +325,27 @@ SwapTimeCoordWrite(ClientPtr pClient, int size, xTimecoord *pRep)
 void
 SGetMotionEventsReply(ClientPtr pClient, int size, xGetMotionEventsReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->length, n);
-    swapl(&pRep->nEvents, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->length);
+    swapl(&pRep->nEvents);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
 void
 STranslateCoordsReply(ClientPtr pClient, int size, xTranslateCoordsReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->child, n);
-    swaps(&pRep->dstX, n);
-    swaps(&pRep->dstY, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->child);
+    swaps(&pRep->dstX);
+    swaps(&pRep->dstY);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
 void
 SGetInputFocusReply(ClientPtr pClient, int size, xGetInputFocusReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->focus, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->focus);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
@@ -382,10 +353,8 @@ SGetInputFocusReply(ClientPtr pClient, int size, xGetInputFocusReply *pRep)
 void
 SQueryKeymapReply(ClientPtr pClient, int size, xQueryKeymapReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->length, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->length);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
@@ -393,30 +362,26 @@ static
 void
 SwapCharInfo(xCharInfo *pInfo)
 {
-    register char n;
-
-    swaps(&pInfo->leftSideBearing, n);
-    swaps(&pInfo->rightSideBearing, n);
-    swaps(&pInfo->characterWidth, n);
-    swaps(&pInfo->ascent, n);
-    swaps(&pInfo->descent, n);
-    swaps(&pInfo->attributes, n);
+    swaps(&pInfo->leftSideBearing);
+    swaps(&pInfo->rightSideBearing);
+    swaps(&pInfo->characterWidth);
+    swaps(&pInfo->ascent);
+    swaps(&pInfo->descent);
+    swaps(&pInfo->attributes);
 }
 
 static void
 SwapFontInfo(xQueryFontReply *pr)
 {
-    register char		n;
-
-    swaps(&pr->minCharOrByte2, n);
-    swaps(&pr->maxCharOrByte2, n);
-    swaps(&pr->defaultChar, n);
-    swaps(&pr->nFontProps, n);
-    swaps(&pr->fontAscent, n);
-    swaps(&pr->fontDescent, n);
+    swaps(&pr->minCharOrByte2);
+    swaps(&pr->maxCharOrByte2);
+    swaps(&pr->defaultChar);
+    swaps(&pr->nFontProps);
+    swaps(&pr->fontAscent);
+    swaps(&pr->fontDescent);
     SwapCharInfo( &pr->minBounds);
     SwapCharInfo( &pr->maxBounds);
-    swapl(&pr->nCharInfos, n);
+    swapl(&pr->nCharInfos);
 }
 
 static
@@ -427,10 +392,9 @@ SwapFont(xQueryFontReply *pr, Bool hasGlyphs)
     xCharInfo *	pxci;
     unsigned	nchars, nprops;
     char	*pby;
-    register char n;
 
-    swaps(&pr->sequenceNumber, n);
-    swapl(&pr->length, n);
+    swaps(&pr->sequenceNumber);
+    swapl(&pr->length);
     nchars = pr->nCharInfos;
     nprops = pr->nFontProps;
     SwapFontInfo(pr);
@@ -439,9 +403,9 @@ SwapFont(xQueryFontReply *pr, Bool hasGlyphs)
      * they are always 2 4 byte values */
     for(i = 0; i < nprops; i++)
     {
-	swapl(pby, n);
+	swapl((int *)pby);
 	pby += 4;
-	swapl(pby, n);
+	swapl((int *)pby);
 	pby += 4;
     }
     if (hasGlyphs)
@@ -462,27 +426,23 @@ SQueryFontReply(ClientPtr pClient, int size, xQueryFontReply *pRep)
 void
 SQueryTextExtentsReply(ClientPtr pClient, int size, xQueryTextExtentsReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swaps(&pRep->fontAscent, n);
-    swaps(&pRep->fontDescent, n);
-    swaps(&pRep->overallAscent, n);
-    swaps(&pRep->overallDescent, n);
-    swapl(&pRep->overallWidth, n);
-    swapl(&pRep->overallLeft, n);
-    swapl(&pRep->overallRight, n);
+    swaps(&pRep->sequenceNumber);
+    swaps(&pRep->fontAscent);
+    swaps(&pRep->fontDescent);
+    swaps(&pRep->overallAscent);
+    swaps(&pRep->overallDescent);
+    swapl(&pRep->overallWidth);
+    swapl(&pRep->overallLeft);
+    swapl(&pRep->overallRight);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
 void
 SListFontsReply(ClientPtr pClient, int size, xListFontsReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->length, n);
-    swaps(&pRep->nFonts, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->length);
+    swaps(&pRep->nFonts);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
@@ -497,22 +457,18 @@ SListFontsWithInfoReply(ClientPtr pClient, int size,
 void
 SGetFontPathReply(ClientPtr pClient, int size, xGetFontPathReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->length, n);
-    swaps(&pRep->nPaths, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->length);
+    swaps(&pRep->nPaths);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
 void
 SGetImageReply(ClientPtr pClient, int size, xGetImageReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->length, n);
-    swapl(&pRep->visual, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->length);
+    swapl(&pRep->visual);
     (void)WriteToClient(pClient, size, (char *) pRep);
     /* Fortunately, image doesn't need swapping */
 }
@@ -521,11 +477,9 @@ void
 SListInstalledColormapsReply(ClientPtr pClient, int size,
                              xListInstalledColormapsReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->length, n);
-    swaps(&pRep->nColormaps, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->length);
+    swaps(&pRep->nColormaps);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
@@ -535,41 +489,35 @@ SAllocColorReply(pClient, size, pRep)
     int			size;
     xAllocColorReply	*pRep;
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swaps(&pRep->red, n);
-    swaps(&pRep->green, n);
-    swaps(&pRep->blue, n);
-    swapl(&pRep->pixel, n);
+    swaps(&pRep->sequenceNumber);
+    swaps(&pRep->red);
+    swaps(&pRep->green);
+    swaps(&pRep->blue);
+    swapl(&pRep->pixel);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
 void
 SAllocNamedColorReply(ClientPtr pClient, int size, xAllocNamedColorReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->pixel, n);
-    swaps(&pRep->exactRed, n);
-    swaps(&pRep->exactGreen, n);
-    swaps(&pRep->exactBlue, n);
-    swaps(&pRep->screenRed, n);
-    swaps(&pRep->screenGreen, n);
-    swaps(&pRep->screenBlue, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->pixel);
+    swaps(&pRep->exactRed);
+    swaps(&pRep->exactGreen);
+    swaps(&pRep->exactBlue);
+    swaps(&pRep->screenRed);
+    swaps(&pRep->screenGreen);
+    swaps(&pRep->screenBlue);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
 void
 SAllocColorCellsReply(ClientPtr pClient, int size, xAllocColorCellsReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->length, n);
-    swaps(&pRep->nPixels, n);
-    swaps(&pRep->nMasks, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->length);
+    swaps(&pRep->nPixels);
+    swaps(&pRep->nMasks);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
@@ -577,25 +525,21 @@ SAllocColorCellsReply(ClientPtr pClient, int size, xAllocColorCellsReply *pRep)
 void
 SAllocColorPlanesReply(ClientPtr pClient, int size, xAllocColorPlanesReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->length, n);
-    swaps(&pRep->nPixels, n);
-    swapl(&pRep->redMask, n);
-    swapl(&pRep->greenMask, n);
-    swapl(&pRep->blueMask, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->length);
+    swaps(&pRep->nPixels);
+    swapl(&pRep->redMask);
+    swapl(&pRep->greenMask);
+    swapl(&pRep->blueMask);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
 void
 SwapRGB(xrgb *prgb)
 {
-    register char n;
-
-    swaps(&prgb->red, n);
-    swaps(&prgb->green, n);
-    swaps(&prgb->blue, n);
+    swaps(&prgb->red);
+    swaps(&prgb->green);
+    swaps(&prgb->blue);
 }
 
 void
@@ -617,47 +561,39 @@ SQColorsExtend(ClientPtr pClient, int size, xrgb *prgb)
 void
 SQueryColorsReply(ClientPtr pClient, int size, xQueryColorsReply* pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->length, n);
-    swaps(&pRep->nColors, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->length);
+    swaps(&pRep->nColors);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
 void
 SLookupColorReply(ClientPtr pClient, int size, xLookupColorReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swaps(&pRep->exactRed, n);
-    swaps(&pRep->exactGreen, n);
-    swaps(&pRep->exactBlue, n);
-    swaps(&pRep->screenRed, n);
-    swaps(&pRep->screenGreen, n);
-    swaps(&pRep->screenBlue, n);
+    swaps(&pRep->sequenceNumber);
+    swaps(&pRep->exactRed);
+    swaps(&pRep->exactGreen);
+    swaps(&pRep->exactBlue);
+    swaps(&pRep->screenRed);
+    swaps(&pRep->screenGreen);
+    swaps(&pRep->screenBlue);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
 void
 SQueryBestSizeReply(ClientPtr pClient, int size, xQueryBestSizeReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swaps(&pRep->width, n);
-    swaps(&pRep->height, n);
+    swaps(&pRep->sequenceNumber);
+    swaps(&pRep->width);
+    swaps(&pRep->height);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
 void
 SListExtensionsReply(ClientPtr pClient, int size, xListExtensionsReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->length, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->length);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
@@ -665,10 +601,8 @@ void
 SGetKeyboardMappingReply(ClientPtr pClient, int size,
                          xGetKeyboardMappingReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->length, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->length);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
@@ -676,10 +610,8 @@ void
 SGetPointerMappingReply(ClientPtr pClient, int size,
                         xGetPointerMappingReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->length, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->length);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
@@ -687,46 +619,38 @@ void
 SGetModifierMappingReply(ClientPtr pClient, int size,
                          xGetModifierMappingReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->length, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->length);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
 void
 SGetKeyboardControlReply(ClientPtr pClient, int size, xGetKeyboardControlReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->length, n);
-    swapl(&pRep->ledMask, n);
-    swaps(&pRep->bellPitch, n);
-    swaps(&pRep->bellDuration, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->length);
+    swapl(&pRep->ledMask);
+    swaps(&pRep->bellPitch);
+    swaps(&pRep->bellDuration);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
 void
 SGetPointerControlReply(ClientPtr pClient, int size, xGetPointerControlReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swaps(&pRep->accelNumerator, n);
-    swaps(&pRep->accelDenominator, n);
-    swaps(&pRep->threshold, n);
+    swaps(&pRep->sequenceNumber);
+    swaps(&pRep->accelNumerator);
+    swaps(&pRep->accelDenominator);
+    swaps(&pRep->threshold);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
 void
 SGetScreenSaverReply(ClientPtr pClient, int size, xGetScreenSaverReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swaps(&pRep->timeout, n);
-    swaps(&pRep->interval, n);
+    swaps(&pRep->sequenceNumber);
+    swaps(&pRep->timeout);
+    swaps(&pRep->interval);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
@@ -738,8 +662,7 @@ SLHostsExtend(ClientPtr pClient, int size, char *buf)
     while (bufT < endbuf) {
 	xHostEntry *host = (xHostEntry *) bufT;
 	int len = host->length;
-        register char n;
-	swaps (&host->length, n);
+	swaps (&host->length);
 	bufT += sizeof (xHostEntry) + (((len + 3) >> 2) << 2);
 	}
     (void)WriteToClient (pClient, size, buf);
@@ -748,11 +671,9 @@ SLHostsExtend(ClientPtr pClient, int size, char *buf)
 void
 SListHostsReply(ClientPtr pClient, int size, xListHostsReply *pRep)
 {
-    register char n;
-
-    swaps(&pRep->sequenceNumber, n);
-    swapl(&pRep->length, n);
-    swaps(&pRep->nHosts, n);
+    swaps(&pRep->sequenceNumber);
+    swapl(&pRep->length);
+    swaps(&pRep->nHosts);
     (void)WriteToClient(pClient, size, (char *) pRep);
 }
 
diff --git a/nx-X11/programs/Xserver/dix/swapreq.c b/nx-X11/programs/Xserver/dix/swapreq.c
index 35a7e7527..e5ac71710 100644
--- a/nx-X11/programs/Xserver/dix/swapreq.c
+++ b/nx-X11/programs/Xserver/dix/swapreq.c
@@ -68,23 +68,21 @@ SOFTWARE.
 void
 SwapLongs (register CARD32 *list, register unsigned long count)
 {
-	register char n;
-
 	while (count >= 8) {
-	    swapl(list+0, n);
-	    swapl(list+1, n);
-	    swapl(list+2, n);
-	    swapl(list+3, n);
-	    swapl(list+4, n);
-	    swapl(list+5, n);
-	    swapl(list+6, n);
-	    swapl(list+7, n);
+	    swapl(list+0);
+	    swapl(list+1);
+	    swapl(list+2);
+	    swapl(list+3);
+	    swapl(list+4);
+	    swapl(list+5);
+	    swapl(list+6);
+	    swapl(list+7);
 	    list += 8;
 	    count -= 8;
 	}
 	if (count != 0) {
 	    do {
-		swapl(list, n);
+		swapl(list);
 		list++;
 	    } while (--count != 0);
 	}
@@ -95,31 +93,29 @@ SwapLongs (register CARD32 *list, register unsigned long count)
 void
 SwapShorts (register short *list, register unsigned long count)
 {
-	register char n;
-
 	while (count >= 16) {
-	    swaps(list+0, n);
-	    swaps(list+1, n);
-	    swaps(list+2, n);
-	    swaps(list+3, n);
-	    swaps(list+4, n);
-	    swaps(list+5, n);
-	    swaps(list+6, n);
-	    swaps(list+7, n);
-	    swaps(list+8, n);
-	    swaps(list+9, n);
-	    swaps(list+10, n);
-	    swaps(list+11, n);
-	    swaps(list+12, n);
-	    swaps(list+13, n);
-	    swaps(list+14, n);
-	    swaps(list+15, n);
+	    swaps(list+0);
+	    swaps(list+1);
+	    swaps(list+2);
+	    swaps(list+3);
+	    swaps(list+4);
+	    swaps(list+5);
+	    swaps(list+6);
+	    swaps(list+7);
+	    swaps(list+8);
+	    swaps(list+9);
+	    swaps(list+10);
+	    swaps(list+11);
+	    swaps(list+12);
+	    swaps(list+13);
+	    swaps(list+14);
+	    swaps(list+15);
 	    list += 16;
 	    count -= 16;
 	}
 	if (count != 0) {
 	    do {
-		swaps(list, n);
+		swaps(list);
 		list++;
 	    } while (--count != 0);
 	}
@@ -130,10 +126,8 @@ SwapShorts (register short *list, register unsigned long count)
 int
 SProcSimpleReq(register ClientPtr client)
 {
-    register char n;
-
     REQUEST(xReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     return(*ProcVector[stuff->reqType])(client);
 }
 
@@ -143,33 +137,29 @@ SProcSimpleReq(register ClientPtr client)
 int
 SProcResourceReq(register ClientPtr client)
 {
-    register char n;
-
     REQUEST(xResourceReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xResourceReq); /* not EXACT */
-    swapl(&stuff->id, n);
+    swapl(&stuff->id);
     return(*ProcVector[stuff->reqType])(client);
 }
 
 int
 SProcCreateWindow(register ClientPtr client)
 {
-    register char n;
-
     REQUEST(xCreateWindowReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xCreateWindowReq);
-    swapl(&stuff->wid, n);
-    swapl(&stuff->parent, n);
-    swaps(&stuff->x, n);
-    swaps(&stuff->y, n);
-    swaps(&stuff->width, n);
-    swaps(&stuff->height, n);
-    swaps(&stuff->borderWidth, n);
-    swaps(&stuff->class, n);
-    swapl(&stuff->visual, n);
-    swapl(&stuff->mask, n);
+    swapl(&stuff->wid);
+    swapl(&stuff->parent);
+    swaps(&stuff->x);
+    swaps(&stuff->y);
+    swaps(&stuff->width);
+    swaps(&stuff->height);
+    swaps(&stuff->borderWidth);
+    swaps(&stuff->class);
+    swapl(&stuff->visual);
+    swapl(&stuff->mask);
     SwapRestL(stuff);
     return((* ProcVector[X_CreateWindow])(client));
 }
@@ -177,13 +167,11 @@ SProcCreateWindow(register ClientPtr client)
 int
 SProcChangeWindowAttributes(register ClientPtr client)
 {
-    register char n;
-
     REQUEST(xChangeWindowAttributesReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xChangeWindowAttributesReq);
-    swapl(&stuff->window, n);
-    swapl(&stuff->valueMask, n);
+    swapl(&stuff->window);
+    swapl(&stuff->valueMask);
     SwapRestL(stuff);
     return((* ProcVector[X_ChangeWindowAttributes])(client));
 }
@@ -191,26 +179,24 @@ SProcChangeWindowAttributes(register ClientPtr client)
 int
 SProcReparentWindow(register ClientPtr client)
 {
-    register char n;
     REQUEST(xReparentWindowReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xReparentWindowReq);
-    swapl(&stuff->window, n);
-    swapl(&stuff->parent, n);
-    swaps(&stuff->x, n);
-    swaps(&stuff->y, n);
+    swapl(&stuff->window);
+    swapl(&stuff->parent);
+    swaps(&stuff->x);
+    swaps(&stuff->y);
     return((* ProcVector[X_ReparentWindow])(client));
 }
 
 int
 SProcConfigureWindow(register ClientPtr client)
 {
-    register char n;
     REQUEST(xConfigureWindowReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xConfigureWindowReq);
-    swapl(&stuff->window, n);
-    swaps(&stuff->mask, n);
+    swapl(&stuff->window);
+    swaps(&stuff->mask);
     SwapRestL(stuff);
     return((* ProcVector[X_ConfigureWindow])(client));
 
@@ -220,25 +206,23 @@ SProcConfigureWindow(register ClientPtr client)
 int
 SProcInternAtom(register ClientPtr client)
 {
-    register char n;
     REQUEST(xInternAtomReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xInternAtomReq);
-    swaps(&stuff->nbytes, n);
+    swaps(&stuff->nbytes);
     return((* ProcVector[X_InternAtom])(client));
 }
 
 int
 SProcChangeProperty(register ClientPtr client)
 {
-    register char n;
     REQUEST(xChangePropertyReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xChangePropertyReq);
-    swapl(&stuff->window, n);
-    swapl(&stuff->property, n);
-    swapl(&stuff->type, n);
-    swapl(&stuff->nUnits, n);
+    swapl(&stuff->window);
+    swapl(&stuff->property);
+    swapl(&stuff->type);
+    swapl(&stuff->nUnits);
     switch ( stuff->format ) {
         case 8 :
 	    break;
@@ -255,12 +239,11 @@ SProcChangeProperty(register ClientPtr client)
 int 
 SProcDeleteProperty(register ClientPtr client)
 {
-    register char n;
     REQUEST(xDeletePropertyReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xDeletePropertyReq);
-    swapl(&stuff->window, n);
-    swapl(&stuff->property, n);
+    swapl(&stuff->window);
+    swapl(&stuff->property);
     return((* ProcVector[X_DeleteProperty])(client));
               
 }
@@ -268,57 +251,53 @@ SProcDeleteProperty(register ClientPtr client)
 int 
 SProcGetProperty(register ClientPtr client)
 {
-    register char n;
     REQUEST(xGetPropertyReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xGetPropertyReq);
-    swapl(&stuff->window, n);
-    swapl(&stuff->property, n);
-    swapl(&stuff->type, n);
-    swapl(&stuff->longOffset, n);
-    swapl(&stuff->longLength, n);
+    swapl(&stuff->window);
+    swapl(&stuff->property);
+    swapl(&stuff->type);
+    swapl(&stuff->longOffset);
+    swapl(&stuff->longLength);
     return((* ProcVector[X_GetProperty])(client));
 }
 
 int
 SProcSetSelectionOwner(register ClientPtr client)
 {
-    register char n;
     REQUEST(xSetSelectionOwnerReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xSetSelectionOwnerReq);
-    swapl(&stuff->window, n);
-    swapl(&stuff->selection, n);
-    swapl(&stuff->time, n);
+    swapl(&stuff->window);
+    swapl(&stuff->selection);
+    swapl(&stuff->time);
     return((* ProcVector[X_SetSelectionOwner])(client));
 }
 
 int
 SProcConvertSelection(register ClientPtr client)
 {
-    register char n;
     REQUEST(xConvertSelectionReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xConvertSelectionReq);
-    swapl(&stuff->requestor, n);
-    swapl(&stuff->selection, n);
-    swapl(&stuff->target, n);
-    swapl(&stuff->property, n);
-    swapl(&stuff->time, n);
+    swapl(&stuff->requestor);
+    swapl(&stuff->selection);
+    swapl(&stuff->target);
+    swapl(&stuff->property);
+    swapl(&stuff->time);
     return((* ProcVector[X_ConvertSelection])(client));
 }
 
 int
 SProcSendEvent(register ClientPtr client)
 {
-    register char n;
     xEvent eventT;
     EventSwapPtr proc;
     REQUEST(xSendEventReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xSendEventReq);
-    swapl(&stuff->destination, n);
-    swapl(&stuff->eventMask, n);
+    swapl(&stuff->destination);
+    swapl(&stuff->eventMask);
 
     /* Swap event */
     proc = EventSwapVector[stuff->event.u.u.type & 0177];
@@ -333,223 +312,206 @@ SProcSendEvent(register ClientPtr client)
 int
 SProcGrabPointer(register ClientPtr client)
 {
-    register char n;
     REQUEST(xGrabPointerReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xGrabPointerReq);
-    swapl(&stuff->grabWindow, n);
-    swaps(&stuff->eventMask, n);
-    swapl(&stuff->confineTo, n);
-    swapl(&stuff->cursor, n);
-    swapl(&stuff->time, n);
+    swapl(&stuff->grabWindow);
+    swaps(&stuff->eventMask);
+    swapl(&stuff->confineTo);
+    swapl(&stuff->cursor);
+    swapl(&stuff->time);
     return((* ProcVector[X_GrabPointer])(client));
 }
 
 int
 SProcGrabButton(register ClientPtr client)
 {
-    register char n;
     REQUEST(xGrabButtonReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xGrabButtonReq);
-    swapl(&stuff->grabWindow, n);
-    swaps(&stuff->eventMask, n);
-    swapl(&stuff->confineTo, n);
-    swapl(&stuff->cursor, n);
-    swaps(&stuff->modifiers, n);
+    swapl(&stuff->grabWindow);
+    swaps(&stuff->eventMask);
+    swapl(&stuff->confineTo);
+    swapl(&stuff->cursor);
+    swaps(&stuff->modifiers);
     return((* ProcVector[X_GrabButton])(client));
 }
 
 int
 SProcUngrabButton(register ClientPtr client)
 {
-    register char n;
     REQUEST(xUngrabButtonReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xUngrabButtonReq);
-    swapl(&stuff->grabWindow, n);
-    swaps(&stuff->modifiers, n);
+    swapl(&stuff->grabWindow);
+    swaps(&stuff->modifiers);
     return((* ProcVector[X_UngrabButton])(client));
 }
 
 int
 SProcChangeActivePointerGrab(register ClientPtr client)
 {
-    register char n;
     REQUEST(xChangeActivePointerGrabReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xChangeActivePointerGrabReq);
-    swapl(&stuff->cursor, n);
-    swapl(&stuff->time, n);
-    swaps(&stuff->eventMask, n);
+    swapl(&stuff->cursor);
+    swapl(&stuff->time);
+    swaps(&stuff->eventMask);
     return((* ProcVector[X_ChangeActivePointerGrab])(client));
 }
 
 int
 SProcGrabKeyboard(register ClientPtr client)
 {
-    register char n;
     REQUEST(xGrabKeyboardReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xGrabKeyboardReq);
-    swapl(&stuff->grabWindow, n);
-    swapl(&stuff->time, n);
+    swapl(&stuff->grabWindow);
+    swapl(&stuff->time);
     return((* ProcVector[X_GrabKeyboard])(client));
 }
 
 int
 SProcGrabKey(register ClientPtr client)
 {
-    register char n;
     REQUEST(xGrabKeyReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xGrabKeyReq);
-    swapl(&stuff->grabWindow, n);
-    swaps(&stuff->modifiers, n);
+    swapl(&stuff->grabWindow);
+    swaps(&stuff->modifiers);
     return((* ProcVector[X_GrabKey])(client));
 }
 
 int
 SProcUngrabKey(register ClientPtr client)
 {
-    register char n;
     REQUEST(xUngrabKeyReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xUngrabKeyReq);
-    swapl(&stuff->grabWindow, n);
-    swaps(&stuff->modifiers, n);
+    swapl(&stuff->grabWindow);
+    swaps(&stuff->modifiers);
     return((* ProcVector[X_UngrabKey])(client));
 }
 
 int
 SProcGetMotionEvents(register ClientPtr client)
 {
-    register char n;
     REQUEST(xGetMotionEventsReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xGetMotionEventsReq);
-    swapl(&stuff->window, n);
-    swapl(&stuff->start, n);
-    swapl(&stuff->stop, n);
+    swapl(&stuff->window);
+    swapl(&stuff->start);
+    swapl(&stuff->stop);
     return((* ProcVector[X_GetMotionEvents])(client));
 }
 
 int
 SProcTranslateCoords(register ClientPtr client)
 {
-    register char n;
     REQUEST(xTranslateCoordsReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xTranslateCoordsReq);
-    swapl(&stuff->srcWid, n);
-    swapl(&stuff->dstWid, n);
-    swaps(&stuff->srcX, n);
-    swaps(&stuff->srcY, n);
+    swapl(&stuff->srcWid);
+    swapl(&stuff->dstWid);
+    swaps(&stuff->srcX);
+    swaps(&stuff->srcY);
     return((* ProcVector[X_TranslateCoords])(client));
 }
 
 int
 SProcWarpPointer(register ClientPtr client)
 {
-    register char n;
     REQUEST(xWarpPointerReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xWarpPointerReq);
-    swapl(&stuff->srcWid, n);
-    swapl(&stuff->dstWid, n);
-    swaps(&stuff->srcX, n);
-    swaps(&stuff->srcY, n);
-    swaps(&stuff->srcWidth, n);
-    swaps(&stuff->srcHeight, n);
-    swaps(&stuff->dstX, n);
-    swaps(&stuff->dstY, n);
+    swapl(&stuff->srcWid);
+    swapl(&stuff->dstWid);
+    swaps(&stuff->srcX);
+    swaps(&stuff->srcY);
+    swaps(&stuff->srcWidth);
+    swaps(&stuff->srcHeight);
+    swaps(&stuff->dstX);
+    swaps(&stuff->dstY);
     return((* ProcVector[X_WarpPointer])(client));
 }
 
 int
 SProcSetInputFocus(register ClientPtr client)
 {
-    register char n;
     REQUEST(xSetInputFocusReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xSetInputFocusReq);
-    swapl(&stuff->focus, n);
-    swapl(&stuff->time, n);
+    swapl(&stuff->focus);
+    swapl(&stuff->time);
     return((* ProcVector[X_SetInputFocus])(client));
 }
 
 int
 SProcOpenFont(register ClientPtr client)
 {
-    register char n;
     REQUEST(xOpenFontReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xOpenFontReq);
-    swapl(&stuff->fid, n);
-    swaps(&stuff->nbytes, n);
+    swapl(&stuff->fid);
+    swaps(&stuff->nbytes);
     return((* ProcVector[X_OpenFont])(client));
 }
 
 int
 SProcListFonts(register ClientPtr client)
 {
-    register char n;
     REQUEST(xListFontsReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xListFontsReq);
-    swaps(&stuff->maxNames, n);
-    swaps(&stuff->nbytes, n);
+    swaps(&stuff->maxNames);
+    swaps(&stuff->nbytes);
     return((* ProcVector[X_ListFonts])(client));
 }
 
 int
 SProcListFontsWithInfo(register ClientPtr client)
 {
-    register char n;
     REQUEST(xListFontsWithInfoReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xListFontsWithInfoReq);
-    swaps(&stuff->maxNames, n);
-    swaps(&stuff->nbytes, n);
+    swaps(&stuff->maxNames);
+    swaps(&stuff->nbytes);
     return((* ProcVector[X_ListFontsWithInfo])(client));
 }
 
 int
 SProcSetFontPath(register ClientPtr client)
 {
-    register char n;
     REQUEST(xSetFontPathReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xSetFontPathReq);
-    swaps(&stuff->nFonts, n);
+    swaps(&stuff->nFonts);
     return((* ProcVector[X_SetFontPath])(client));
 }
 
 int
 SProcCreatePixmap(register ClientPtr client)
 {
-    register char n;
     REQUEST(xCreatePixmapReq);
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xCreatePixmapReq);
-    swapl(&stuff->pid, n);
-    swapl(&stuff->drawable, n);
-    swaps(&stuff->width, n);
-    swaps(&stuff->height, n);
+    swapl(&stuff->pid);
+    swapl(&stuff->drawable);
+    swaps(&stuff->width);
+    swaps(&stuff->height);
     return((* ProcVector[X_CreatePixmap])(client));
 }
 
 int
 SProcCreateGC(register ClientPtr client)
 {
-    register char n;
     REQUEST(xCreateGCReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xCreateGCReq);
-    swapl(&stuff->gc, n);
-    swapl(&stuff->drawable, n);
-    swapl(&stuff->mask, n);
+    swapl(&stuff->gc);
+    swapl(&stuff->drawable);
+    swapl(&stuff->mask);
     SwapRestL(stuff);
     return((* ProcVector[X_CreateGC])(client));
 }
@@ -557,12 +519,11 @@ SProcCreateGC(register ClientPtr client)
 int
 SProcChangeGC(register ClientPtr client)
 {
-    register char n;
     REQUEST(xChangeGCReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xChangeGCReq);
-    swapl(&stuff->gc, n);
-    swapl(&stuff->mask, n);
+    swapl(&stuff->gc);
+    swapl(&stuff->mask);
     SwapRestL(stuff);
     return((* ProcVector[X_ChangeGC])(client));
 }
@@ -570,26 +531,24 @@ SProcChangeGC(register ClientPtr client)
 int
 SProcCopyGC(register ClientPtr client)
 {
-    register char n;
     REQUEST(xCopyGCReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xCopyGCReq);
-    swapl(&stuff->srcGC, n);
-    swapl(&stuff->dstGC, n);
-    swapl(&stuff->mask, n);
+    swapl(&stuff->srcGC);
+    swapl(&stuff->dstGC);
+    swapl(&stuff->mask);
     return((* ProcVector[X_CopyGC])(client));
 }
 
 int
 SProcSetDashes(register ClientPtr client)
 {
-    register char n;
     REQUEST(xSetDashesReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xSetDashesReq);
-    swapl(&stuff->gc, n);
-    swaps(&stuff->dashOffset, n);
-    swaps(&stuff->nDashes, n);
+    swapl(&stuff->gc);
+    swaps(&stuff->dashOffset);
+    swaps(&stuff->nDashes);
     return((* ProcVector[X_SetDashes])(client));
 
 }
@@ -597,13 +556,12 @@ SProcSetDashes(register ClientPtr client)
 int
 SProcSetClipRectangles(register ClientPtr client)
 {
-    register char n;
     REQUEST(xSetClipRectanglesReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xSetClipRectanglesReq);
-    swapl(&stuff->gc, n);
-    swaps(&stuff->xOrigin, n);
-    swaps(&stuff->yOrigin, n);
+    swapl(&stuff->gc);
+    swaps(&stuff->xOrigin);
+    swaps(&stuff->yOrigin);
     SwapRestS(stuff);
     return((* ProcVector[X_SetClipRectangles])(client));
 }
@@ -611,54 +569,51 @@ SProcSetClipRectangles(register ClientPtr client)
 int
 SProcClearToBackground(register ClientPtr client)
 {
-    register char n;
     REQUEST(xClearAreaReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xClearAreaReq);
-    swapl(&stuff->window, n);
-    swaps(&stuff->x, n);
-    swaps(&stuff->y, n);
-    swaps(&stuff->width, n);
-    swaps(&stuff->height, n);
+    swapl(&stuff->window);
+    swaps(&stuff->x);
+    swaps(&stuff->y);
+    swaps(&stuff->width);
+    swaps(&stuff->height);
     return((* ProcVector[X_ClearArea])(client));
 }
 
 int
 SProcCopyArea(register ClientPtr client)
 {
-    register char n;
     REQUEST(xCopyAreaReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xCopyAreaReq);
-    swapl(&stuff->srcDrawable, n);
-    swapl(&stuff->dstDrawable, n);
-    swapl(&stuff->gc, n);
-    swaps(&stuff->srcX, n);
-    swaps(&stuff->srcY, n);
-    swaps(&stuff->dstX, n);
-    swaps(&stuff->dstY, n);
-    swaps(&stuff->width, n);
-    swaps(&stuff->height, n);
+    swapl(&stuff->srcDrawable);
+    swapl(&stuff->dstDrawable);
+    swapl(&stuff->gc);
+    swaps(&stuff->srcX);
+    swaps(&stuff->srcY);
+    swaps(&stuff->dstX);
+    swaps(&stuff->dstY);
+    swaps(&stuff->width);
+    swaps(&stuff->height);
     return((* ProcVector[X_CopyArea])(client));
 }
 
 int
 SProcCopyPlane(register ClientPtr client)
 {
-    register char n;
     REQUEST(xCopyPlaneReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xCopyPlaneReq);
-    swapl(&stuff->srcDrawable, n);
-    swapl(&stuff->dstDrawable, n);
-    swapl(&stuff->gc, n);
-    swaps(&stuff->srcX, n);
-    swaps(&stuff->srcY, n);
-    swaps(&stuff->dstX, n);
-    swaps(&stuff->dstY, n);
-    swaps(&stuff->width, n);
-    swaps(&stuff->height, n);
-    swapl(&stuff->bitPlane, n);
+    swapl(&stuff->srcDrawable);
+    swapl(&stuff->dstDrawable);
+    swapl(&stuff->gc);
+    swaps(&stuff->srcX);
+    swaps(&stuff->srcY);
+    swaps(&stuff->dstX);
+    swaps(&stuff->dstY);
+    swaps(&stuff->width);
+    swaps(&stuff->height);
+    swapl(&stuff->bitPlane);
     return((* ProcVector[X_CopyPlane])(client));
 }
 
@@ -667,13 +622,11 @@ SProcCopyPlane(register ClientPtr client)
 int
 SProcPoly(register ClientPtr client)
 {
-    register char n;
-
     REQUEST(xPolyPointReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xPolyPointReq);
-    swapl(&stuff->drawable, n);
-    swapl(&stuff->gc, n);
+    swapl(&stuff->drawable);
+    swapl(&stuff->gc);
     SwapRestS(stuff);
     return((* ProcVector[stuff->reqType])(client));
 }
@@ -684,13 +637,11 @@ SProcPoly(register ClientPtr client)
 int
 SProcFillPoly(register ClientPtr client)
 {
-    register char n;
-
     REQUEST(xFillPolyReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xFillPolyReq);
-    swapl(&stuff->drawable, n);
-    swapl(&stuff->gc, n);
+    swapl(&stuff->drawable);
+    swapl(&stuff->gc);
     SwapRestS(stuff);
     return((* ProcVector[X_FillPoly])(client));
 }
@@ -698,16 +649,15 @@ SProcFillPoly(register ClientPtr client)
 int
 SProcPutImage(register ClientPtr client)
 {
-    register char n;
     REQUEST(xPutImageReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xPutImageReq);
-    swapl(&stuff->drawable, n);
-    swapl(&stuff->gc, n);
-    swaps(&stuff->width, n);
-    swaps(&stuff->height, n);
-    swaps(&stuff->dstX, n);
-    swaps(&stuff->dstY, n);
+    swapl(&stuff->drawable);
+    swapl(&stuff->gc);
+    swaps(&stuff->width);
+    swaps(&stuff->height);
+    swaps(&stuff->dstX);
+    swaps(&stuff->dstY);
     /* Image should already be swapped */
     return((* ProcVector[X_PutImage])(client));
 
@@ -716,16 +666,15 @@ SProcPutImage(register ClientPtr client)
 int
 SProcGetImage(register ClientPtr client)
 {
-    register char n;
     REQUEST(xGetImageReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xGetImageReq);
-    swapl(&stuff->drawable, n);
-    swaps(&stuff->x, n);
-    swaps(&stuff->y, n);
-    swaps(&stuff->width, n);
-    swaps(&stuff->height, n);
-    swapl(&stuff->planeMask, n);
+    swapl(&stuff->drawable);
+    swaps(&stuff->x);
+    swaps(&stuff->y);
+    swaps(&stuff->width);
+    swaps(&stuff->height);
+    swapl(&stuff->planeMask);
     return((* ProcVector[X_GetImage])(client));
 }
 
@@ -734,14 +683,13 @@ SProcGetImage(register ClientPtr client)
 int
 SProcPolyText(register ClientPtr client)
 {
-    register char n;
     REQUEST(xPolyTextReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xPolyTextReq);
-    swapl(&stuff->drawable, n);
-    swapl(&stuff->gc, n);
-    swaps(&stuff->x, n);
-    swaps(&stuff->y, n);
+    swapl(&stuff->drawable);
+    swapl(&stuff->gc);
+    swaps(&stuff->x);
+    swaps(&stuff->y);
     return((* ProcVector[stuff->reqType])(client));
 }
 
@@ -750,27 +698,25 @@ SProcPolyText(register ClientPtr client)
 int
 SProcImageText(register ClientPtr client)
 {
-    register char n;
     REQUEST(xImageTextReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xImageTextReq);
-    swapl(&stuff->drawable, n);
-    swapl(&stuff->gc, n);
-    swaps(&stuff->x, n);
-    swaps(&stuff->y, n);
+    swapl(&stuff->drawable);
+    swapl(&stuff->gc);
+    swaps(&stuff->x);
+    swaps(&stuff->y);
     return((* ProcVector[stuff->reqType])(client));
 }
 
 int
 SProcCreateColormap(register ClientPtr client)
 {
-    register char n;
     REQUEST(xCreateColormapReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xCreateColormapReq);
-    swapl(&stuff->mid, n);
-    swapl(&stuff->window, n);
-    swapl(&stuff->visual, n);
+    swapl(&stuff->mid);
+    swapl(&stuff->window);
+    swapl(&stuff->visual);
     return((* ProcVector[X_CreateColormap])(client));
 }
 
@@ -778,12 +724,11 @@ SProcCreateColormap(register ClientPtr client)
 int
 SProcCopyColormapAndFree(register ClientPtr client)
 {
-    register char n;
     REQUEST(xCopyColormapAndFreeReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xCopyColormapAndFreeReq);
-    swapl(&stuff->mid, n);
-    swapl(&stuff->srcCmap, n);
+    swapl(&stuff->mid);
+    swapl(&stuff->srcCmap);
     return((* ProcVector[X_CopyColormapAndFree])(client));
 
 }
@@ -791,67 +736,61 @@ SProcCopyColormapAndFree(register ClientPtr client)
 int
 SProcAllocColor(register ClientPtr client)
 {
-    register char n;
     REQUEST(xAllocColorReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xAllocColorReq);
-    swapl(&stuff->cmap, n);
-    swaps(&stuff->red, n);
-    swaps(&stuff->green, n);
-    swaps(&stuff->blue, n);
+    swapl(&stuff->cmap);
+    swaps(&stuff->red);
+    swaps(&stuff->green);
+    swaps(&stuff->blue);
     return((* ProcVector[X_AllocColor])(client));
 }
 
 int
 SProcAllocNamedColor(register ClientPtr client)
 {
-    register char n;
-
     REQUEST(xAllocNamedColorReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xAllocNamedColorReq);
-    swapl(&stuff->cmap, n);
-    swaps(&stuff->nbytes, n);
+    swapl(&stuff->cmap);
+    swaps(&stuff->nbytes);
     return((* ProcVector[X_AllocNamedColor])(client));
 }
 
 int
 SProcAllocColorCells(register ClientPtr client)
 {
-    register char n;
     REQUEST(xAllocColorCellsReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xAllocColorCellsReq);
-    swapl(&stuff->cmap, n);
-    swaps(&stuff->colors, n);
-    swaps(&stuff->planes, n);
+    swapl(&stuff->cmap);
+    swaps(&stuff->colors);
+    swaps(&stuff->planes);
     return((* ProcVector[X_AllocColorCells])(client));
 }
 
 int
 SProcAllocColorPlanes(register ClientPtr client)
 {
-    register char n;
     REQUEST(xAllocColorPlanesReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xAllocColorPlanesReq);
-    swapl(&stuff->cmap, n);
-    swaps(&stuff->colors, n);
-    swaps(&stuff->red, n);
-    swaps(&stuff->green, n);
-    swaps(&stuff->blue, n);
+    swapl(&stuff->cmap);
+    swaps(&stuff->colors);
+    swaps(&stuff->red);
+    swaps(&stuff->green);
+    swaps(&stuff->blue);
     return((* ProcVector[X_AllocColorPlanes])(client));
 }
 
 int
 SProcFreeColors(register ClientPtr client)
 {
-    register char n;
     REQUEST(xFreeColorsReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xFreeColorsReq);
-    swapl(&stuff->cmap, n);
-    swapl(&stuff->planeMask, n);
+    swapl(&stuff->cmap);
+    swapl(&stuff->planeMask);
     SwapRestL(stuff);
     return((* ProcVector[X_FreeColors])(client));
 
@@ -860,25 +799,22 @@ SProcFreeColors(register ClientPtr client)
 void
 SwapColorItem(xColorItem *pItem)
 {
-    register char n;
-
-    swapl(&pItem->pixel, n);
-    swaps(&pItem->red, n);
-    swaps(&pItem->green, n);
-    swaps(&pItem->blue, n);
+    swapl(&pItem->pixel);
+    swaps(&pItem->red);
+    swaps(&pItem->green);
+    swaps(&pItem->blue);
 }
 
 int
 SProcStoreColors(register ClientPtr client)
 {
-    register char n;
     long count;
     xColorItem 	*pItem;
 
     REQUEST(xStoreColorsReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xStoreColorsReq);
-    swapl(&stuff->cmap, n);
+    swapl(&stuff->cmap);
     pItem = (xColorItem *) &stuff[1];
     for(count = LengthRestB(stuff)/sizeof(xColorItem); --count >= 0; )
 	SwapColorItem(pItem++);
@@ -888,24 +824,22 @@ SProcStoreColors(register ClientPtr client)
 int
 SProcStoreNamedColor (register ClientPtr client)
 {
-    register char n;
     REQUEST(xStoreNamedColorReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xStoreNamedColorReq);
-    swapl(&stuff->cmap, n);
-    swapl(&stuff->pixel, n);
-    swaps(&stuff->nbytes, n);
+    swapl(&stuff->cmap);
+    swapl(&stuff->pixel);
+    swaps(&stuff->nbytes);
     return((* ProcVector[X_StoreNamedColor])(client));
 }
 
 int
 SProcQueryColors (register ClientPtr client)
 {
-    register char n;
     REQUEST(xQueryColorsReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xQueryColorsReq);
-    swapl(&stuff->cmap, n);
+    swapl(&stuff->cmap);
     SwapRestL(stuff);
     return((* ProcVector[X_QueryColors])(client));
 } 
@@ -913,54 +847,51 @@ SProcQueryColors (register ClientPtr client)
 int
 SProcLookupColor (register ClientPtr client)
 {
-    register char n;
     REQUEST(xLookupColorReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xLookupColorReq);
-    swapl(&stuff->cmap, n);
-    swaps(&stuff->nbytes, n);
+    swapl(&stuff->cmap);
+    swaps(&stuff->nbytes);
     return((* ProcVector[X_LookupColor])(client));
 }
 
 int
 SProcCreateCursor (register ClientPtr client)
 {
-    register char n;
     REQUEST(xCreateCursorReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xCreateCursorReq);
-    swapl(&stuff->cid, n);
-    swapl(&stuff->source, n);
-    swapl(&stuff->mask, n);
-    swaps(&stuff->foreRed, n);
-    swaps(&stuff->foreGreen, n);
-    swaps(&stuff->foreBlue, n);
-    swaps(&stuff->backRed, n);
-    swaps(&stuff->backGreen, n);
-    swaps(&stuff->backBlue, n);
-    swaps(&stuff->x, n);
-    swaps(&stuff->y, n);
+    swapl(&stuff->cid);
+    swapl(&stuff->source);
+    swapl(&stuff->mask);
+    swaps(&stuff->foreRed);
+    swaps(&stuff->foreGreen);
+    swaps(&stuff->foreBlue);
+    swaps(&stuff->backRed);
+    swaps(&stuff->backGreen);
+    swaps(&stuff->backBlue);
+    swaps(&stuff->x);
+    swaps(&stuff->y);
     return((* ProcVector[X_CreateCursor])(client));
 }
 
 int
 SProcCreateGlyphCursor (register ClientPtr client)
 {
-    register char n;
     REQUEST(xCreateGlyphCursorReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xCreateGlyphCursorReq);
-    swapl(&stuff->cid, n);
-    swapl(&stuff->source, n);
-    swapl(&stuff->mask, n);
-    swaps(&stuff->sourceChar, n);
-    swaps(&stuff->maskChar, n);
-    swaps(&stuff->foreRed, n);
-    swaps(&stuff->foreGreen, n);
-    swaps(&stuff->foreBlue, n);
-    swaps(&stuff->backRed, n);
-    swaps(&stuff->backGreen, n);
-    swaps(&stuff->backBlue, n);
+    swapl(&stuff->cid);
+    swapl(&stuff->source);
+    swapl(&stuff->mask);
+    swaps(&stuff->sourceChar);
+    swaps(&stuff->maskChar);
+    swaps(&stuff->foreRed);
+    swaps(&stuff->foreGreen);
+    swaps(&stuff->foreBlue);
+    swaps(&stuff->backRed);
+    swaps(&stuff->backGreen);
+    swaps(&stuff->backBlue);
     return((* ProcVector[X_CreateGlyphCursor])(client));
 }
 
@@ -968,30 +899,28 @@ SProcCreateGlyphCursor (register ClientPtr client)
 int
 SProcRecolorCursor (register ClientPtr client)
 {
-    register char n;
     REQUEST(xRecolorCursorReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xRecolorCursorReq);
-    swapl(&stuff->cursor, n);
-    swaps(&stuff->foreRed, n);
-    swaps(&stuff->foreGreen, n);
-    swaps(&stuff->foreBlue, n);
-    swaps(&stuff->backRed, n);
-    swaps(&stuff->backGreen, n);
-    swaps(&stuff->backBlue, n);
+    swapl(&stuff->cursor);
+    swaps(&stuff->foreRed);
+    swaps(&stuff->foreGreen);
+    swaps(&stuff->foreBlue);
+    swaps(&stuff->backRed);
+    swaps(&stuff->backGreen);
+    swaps(&stuff->backBlue);
     return((* ProcVector[X_RecolorCursor])(client));
 }
 
 int
 SProcQueryBestSize (register ClientPtr client)
 {
-    register char n;
     REQUEST(xQueryBestSizeReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xQueryBestSizeReq);
-    swapl(&stuff->drawable, n);
-    swaps(&stuff->width, n);
-    swaps(&stuff->height, n);
+    swapl(&stuff->drawable);
+    swaps(&stuff->width);
+    swaps(&stuff->height);
     return((* ProcVector[X_QueryBestSize])(client));
 
 }
@@ -999,20 +928,18 @@ SProcQueryBestSize (register ClientPtr client)
 int
 SProcQueryExtension (register ClientPtr client)
 {
-    register char n;
     REQUEST(xQueryExtensionReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xQueryExtensionReq);
-    swaps(&stuff->nbytes, n);
+    swaps(&stuff->nbytes);
     return((* ProcVector[X_QueryExtension])(client));
 }
 
 int
 SProcChangeKeyboardMapping (register ClientPtr client)
 {
-    register char n;
     REQUEST(xChangeKeyboardMappingReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xChangeKeyboardMappingReq);
     SwapRestL(stuff);
     return((* ProcVector[X_ChangeKeyboardMapping])(client));
@@ -1022,11 +949,10 @@ SProcChangeKeyboardMapping (register ClientPtr client)
 int
 SProcChangeKeyboardControl (register ClientPtr client)
 {
-    register char n;
     REQUEST(xChangeKeyboardControlReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xChangeKeyboardControlReq);
-    swapl(&stuff->mask, n);
+    swapl(&stuff->mask);
     SwapRestL(stuff);
     return((* ProcVector[X_ChangeKeyboardControl])(client));
 }
@@ -1034,13 +960,12 @@ SProcChangeKeyboardControl (register ClientPtr client)
 int
 SProcChangePointerControl (register ClientPtr client)
 {
-    register char n;
     REQUEST(xChangePointerControlReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xChangePointerControlReq);
-    swaps(&stuff->accelNum, n);
-    swaps(&stuff->accelDenum, n);
-    swaps(&stuff->threshold, n);
+    swaps(&stuff->accelNum);
+    swaps(&stuff->accelDenum);
+    swaps(&stuff->threshold);
     return((* ProcVector[X_ChangePointerControl])(client));
 }
 
@@ -1048,37 +973,33 @@ SProcChangePointerControl (register ClientPtr client)
 int
 SProcSetScreenSaver (register ClientPtr client)
 {
-    register char n;
     REQUEST(xSetScreenSaverReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xSetScreenSaverReq);
-    swaps(&stuff->timeout, n);
-    swaps(&stuff->interval, n);
+    swaps(&stuff->timeout);
+    swaps(&stuff->interval);
     return((* ProcVector[X_SetScreenSaver])(client));
 }
 
 int
 SProcChangeHosts (register ClientPtr client)
 {
-    register char n;
-
     REQUEST(xChangeHostsReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xChangeHostsReq);
-    swaps(&stuff->hostLength, n);
+    swaps(&stuff->hostLength);
     return((* ProcVector[X_ChangeHosts])(client));
 
 }
 
 int SProcRotateProperties (register ClientPtr client)
 {
-    register char n;
     REQUEST(xRotatePropertiesReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xRotatePropertiesReq);
-    swapl(&stuff->window, n);
-    swaps(&stuff->nAtoms, n);
-    swaps(&stuff->nPositions, n);
+    swapl(&stuff->window);
+    swaps(&stuff->nAtoms);
+    swaps(&stuff->nPositions);
     SwapRestL(stuff);
     return ((* ProcVector[X_RotateProperties])(client));
 }
@@ -1086,19 +1007,16 @@ int SProcRotateProperties (register ClientPtr client)
 int
 SProcNoOperation(register ClientPtr client)
 {
-    register char n;
     REQUEST(xReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     return ((* ProcVector[X_NoOperation])(client));
 }
 
 void
 SwapConnClientPrefix(xConnClientPrefix *pCCP)
 {
-    register char n;
-
-    swaps(&pCCP->majorVersion, n);
-    swaps(&pCCP->minorVersion, n);
-    swaps(&pCCP->nbytesAuthProto, n);
-    swaps(&pCCP->nbytesAuthString, n);
+    swaps(&pCCP->majorVersion);
+    swaps(&pCCP->minorVersion);
+    swaps(&pCCP->nbytesAuthProto);
+    swaps(&pCCP->nbytesAuthString);
 }
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXrender.c b/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
index d14b47866..9aaef3d87 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
@@ -131,7 +131,6 @@ ProcRenderQueryVersion (ClientPtr client)
 {
     RenderClientPtr pRenderClient = GetRenderClient (client);
     xRenderQueryVersionReply rep;
-    register int n;
     REQUEST(xRenderQueryVersionReq);
 
     REQUEST_SIZE_MATCH(xRenderQueryVersionReq);
@@ -146,10 +145,10 @@ ProcRenderQueryVersion (ClientPtr client)
     rep.majorVersion = nxagentRenderVersionMajor;
     rep.minorVersion = nxagentRenderVersionMinor;
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-    	swapl(&rep.length, n);
-	swapl(&rep.majorVersion, n);
-	swapl(&rep.minorVersion, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swapl(&rep.majorVersion);
+	swapl(&rep.minorVersion);
     }
     WriteToClient(client, sizeof(xRenderQueryVersionReply), (char *)&rep);
     return (client->noClientException);
@@ -176,7 +175,6 @@ ProcRenderQueryPictFormats (ClientPtr client)
     int				    nvisual;
     int				    rlength;
     int				    s;
-    int				    n;
     int				    numScreens;
     int				    numSubpixel;
 
@@ -266,16 +264,16 @@ ProcRenderQueryPictFormats (ClientPtr client)
 		    pictForm->colormap = None;
 		if (client->swapped)
 		{
-		    swapl (&pictForm->id, n);
-		    swaps (&pictForm->direct.red, n);
-		    swaps (&pictForm->direct.redMask, n);
-		    swaps (&pictForm->direct.green, n);
-		    swaps (&pictForm->direct.greenMask, n);
-		    swaps (&pictForm->direct.blue, n);
-		    swaps (&pictForm->direct.blueMask, n);
-		    swaps (&pictForm->direct.alpha, n);
-		    swaps (&pictForm->direct.alphaMask, n);
-		    swapl (&pictForm->colormap, n);
+		    swapl (&pictForm->id);
+		    swaps (&pictForm->direct.red);
+		    swaps (&pictForm->direct.redMask);
+		    swaps (&pictForm->direct.green);
+		    swaps (&pictForm->direct.greenMask);
+		    swaps (&pictForm->direct.blue);
+		    swaps (&pictForm->direct.blueMask);
+		    swaps (&pictForm->direct.alpha);
+		    swaps (&pictForm->direct.alphaMask);
+		    swapl (&pictForm->colormap);
 		}
 		pictForm++;
 	    }
@@ -305,8 +303,8 @@ ProcRenderQueryPictFormats (ClientPtr client)
 		    pictVisual->format = pFormat->id;
 		    if (client->swapped)
 		    {
-			swapl (&pictVisual->visual, n);
-			swapl (&pictVisual->format, n);
+			swapl (&pictVisual->visual);
+			swapl (&pictVisual->format);
 		    }
 		    pictVisual++;
 		    nvisual++;
@@ -316,7 +314,7 @@ ProcRenderQueryPictFormats (ClientPtr client)
 	    pictDepth->nPictVisuals = nvisual;
 	    if (client->swapped)
 	    {
-		swaps (&pictDepth->nPictVisuals, n);
+		swaps (&pictDepth->nPictVisuals);
 	    }
 	    ndepth++;
 	    pictDepth = (xPictDepth *) pictVisual;
@@ -329,8 +327,8 @@ ProcRenderQueryPictFormats (ClientPtr client)
 	    pictScreen->fallback = 0;
 	if (client->swapped)
 	{
-	    swapl (&pictScreen->nDepth, n);
-	    swapl (&pictScreen->fallback, n);
+	    swapl (&pictScreen->nDepth);
+	    swapl (&pictScreen->fallback);
 	}
 	pictScreen = (xPictScreen *) pictDepth;
     }
@@ -346,20 +344,20 @@ ProcRenderQueryPictFormats (ClientPtr client)
 	    *pictSubpixel = SubPixelUnknown;
 	if (client->swapped)
 	{
-	    swapl (pictSubpixel, n);
+	    swapl (pictSubpixel);
 	}
 	++pictSubpixel;
     }
     
     if (client->swapped)
     {
-	swaps (&reply->sequenceNumber, n);
-	swapl (&reply->length, n);
-	swapl (&reply->numFormats, n);
-	swapl (&reply->numScreens, n);
-	swapl (&reply->numDepths, n);
-	swapl (&reply->numVisuals, n);
-	swapl (&reply->numSubpixel, n);
+	swaps (&reply->sequenceNumber);
+	swapl (&reply->length);
+	swapl (&reply->numFormats);
+	swapl (&reply->numScreens);
+	swapl (&reply->numDepths);
+	swapl (&reply->numVisuals);
+	swapl (&reply->numSubpixel);
     }
     WriteToClient(client, rlength, (char *) reply);
     free (reply);
diff --git a/nx-X11/programs/Xserver/include/misc.h b/nx-X11/programs/Xserver/include/misc.h
index d2cadace2..ac19ecc3b 100644
--- a/nx-X11/programs/Xserver/include/misc.h
+++ b/nx-X11/programs/Xserver/include/misc.h
@@ -277,32 +277,107 @@ version_compare(uint32_t a_major, uint32_t a_minor,
 #define SwapRestL(stuff) \
     SwapLongs((CARD32 *)(stuff + 1), LengthRestL(stuff))
 
+#if defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+void __attribute__ ((error("wrong sized variable passed to swap")))
+wrong_size(void);
+#else
+static inline void
+wrong_size(void)
+{
+}
+#endif
+
+#if !(defined(__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)))
+static inline int
+__builtin_constant_p(int x)
+{
+    return 0;
+}
+#endif
+
+/* byte swap a 64-bit value */
+static inline void
+swap_uint64(uint64_t *x)
+{
+    char n;
+
+    n = ((char *) x)[0];
+    ((char *) x)[0] = ((char *) x)[7];
+    ((char *) x)[7] = n;
+
+    n = ((char *) x)[1];
+    ((char *) x)[1] = ((char *) x)[6];
+    ((char *) x)[6] = n;
+
+    n = ((char *) x)[2];
+    ((char *) x)[2] = ((char *) x)[5];
+    ((char *) x)[5] = n;
+
+    n = ((char *) x)[3];
+    ((char *) x)[3] = ((char *) x)[4];
+    ((char *) x)[4] = n;
+}
+
+#define swapll(x) do { \
+	if (sizeof(*(x)) != 8) \
+	    wrong_size(); \
+                swap_uint64((uint64_t *)(x));   \
+    } while (0)
+
 /* byte swap a 32-bit value */
-#define swapl(x, n) { \
-		 n = ((char *) (x))[0];\
-		 ((char *) (x))[0] = ((char *) (x))[3];\
-		 ((char *) (x))[3] = n;\
-		 n = ((char *) (x))[1];\
-		 ((char *) (x))[1] = ((char *) (x))[2];\
-		 ((char *) (x))[2] = n; }
-
-/* byte swap a short */
-#define swaps(x, n) { \
-		 n = ((char *) (x))[0];\
-		 ((char *) (x))[0] = ((char *) (x))[1];\
-		 ((char *) (x))[1] = n; }
+static inline void
+swap_uint32(uint32_t * x)
+{
+    char n = ((char *) x)[0];
+
+    ((char *) x)[0] = ((char *) x)[3];
+    ((char *) x)[3] = n;
+    n = ((char *) x)[1];
+    ((char *) x)[1] = ((char *) x)[2];
+    ((char *) x)[2] = n;
+}
+
+#define swapl(x) do { \
+	if (sizeof(*(x)) != 4) \
+	    wrong_size(); \
+	if (__builtin_constant_p((uintptr_t)(x) & 3) && ((uintptr_t)(x) & 3) == 0) \
+	    *(x) = lswapl(*(x)); \
+	else \
+	    swap_uint32((uint32_t *)(x)); \
+    } while (0)
+
+/* byte swap a 16-bit value */
+static inline void
+swap_uint16(uint16_t * x)
+{
+    char n = ((char *) x)[0];
+
+    ((char *) x)[0] = ((char *) x)[1];
+    ((char *) x)[1] = n;
+}
+
+#define swaps(x) do { \
+	if (sizeof(*(x)) != 2) \
+	    wrong_size(); \
+	if (__builtin_constant_p((uintptr_t)(x) & 1) && ((uintptr_t)(x) & 1) == 0) \
+	    *(x) = lswaps(*(x)); \
+	else \
+	    swap_uint16((uint16_t *)(x)); \
+    } while (0)
 
 /* copy 32-bit value from src to dst byteswapping on the way */
-#define cpswapl(src, dst) { \
-                 ((char *)&(dst))[0] = ((char *) &(src))[3];\
-                 ((char *)&(dst))[1] = ((char *) &(src))[2];\
-                 ((char *)&(dst))[2] = ((char *) &(src))[1];\
-                 ((char *)&(dst))[3] = ((char *) &(src))[0]; }
+#define cpswapl(src, dst) do { \
+	if (sizeof((src)) != 4 || sizeof((dst)) != 4) \
+	    wrong_size(); \
+	(dst) = lswapl((src)); \
+    } while (0)
 
 /* copy short from src to dst byteswapping on the way */
-#define cpswaps(src, dst) { \
-		 ((char *) &(dst))[0] = ((char *) &(src))[1];\
-		 ((char *) &(dst))[1] = ((char *) &(src))[0]; }
+#define cpswaps(src, dst) do { \
+	if (sizeof((src)) != 2 || sizeof((dst)) != 2) \
+	    wrong_size(); \
+	(dst) = lswaps((src)); \
+    } while (0)
 
 extern void SwapLongs(
     CARD32 *list,
diff --git a/nx-X11/programs/Xserver/os/connection.c b/nx-X11/programs/Xserver/os/connection.c
index 15321458e..fd9741389 100644
--- a/nx-X11/programs/Xserver/os/connection.c
+++ b/nx-X11/programs/Xserver/os/connection.c
@@ -933,9 +933,9 @@ ErrorConnMax(XtransConnInfo trans_conn)
 	if (((*(char *) &whichbyte) && (byteOrder == 'B')) ||
 	    (!(*(char *) &whichbyte) && (byteOrder == 'l')))
 	{
-	    swaps(&csp.majorVersion, whichbyte);
-	    swaps(&csp.minorVersion, whichbyte);
-	    swaps(&csp.length, whichbyte);
+	    swaps(&csp.majorVersion);
+	    swaps(&csp.minorVersion);
+	    swaps(&csp.length);
 	}
 	iov[0].iov_len = sz_xConnSetupPrefix;
 	iov[0].iov_base = (char *) &csp;
diff --git a/nx-X11/programs/Xserver/os/io.c b/nx-X11/programs/Xserver/os/io.c
index d0862ddd4..234ce8b58 100644
--- a/nx-X11/programs/Xserver/os/io.c
+++ b/nx-X11/programs/Xserver/os/io.c
@@ -591,8 +591,7 @@ ResetCurrentRequest(ClientPtr client)
 	    ((xBigReq *)oci->bufptr)->length = client->req_len;
 	    if (client->swapped)
 	    {
-		char n;
-		swapl(&((xBigReq *)oci->bufptr)->length, n);
+		swapl(&((xBigReq *)oci->bufptr)->length);
 	    }
 	}
 #endif
@@ -948,11 +947,10 @@ WriteToClient (ClientPtr who, int count, char *buf)
         { /* start of new reply */
 	    CARD32 replylen;
 	    unsigned long bytesleft;
-	    char n;
 
 	    replylen = ((xGenericReply *)buf)->length;
 	    if (who->swapped)
-		swapl(&replylen, n);
+		swapl(&replylen);
 	    bytesleft = (replylen * 4) + SIZEOF(xReply) - count - padBytes;
 	    replyinfo.startOfReply = TRUE;
 	    replyinfo.bytesRemaining = who->replyBytesRemaining = bytesleft;
diff --git a/nx-X11/programs/Xserver/randr/rrcrtc.c b/nx-X11/programs/Xserver/randr/rrcrtc.c
index 4c9b805c2..072046e14 100644
--- a/nx-X11/programs/Xserver/randr/rrcrtc.c
+++ b/nx-X11/programs/Xserver/randr/rrcrtc.c
@@ -997,7 +997,6 @@ ProcRRGetCrtcInfo(ClientPtr client)
     int i, j, k;
     int width, height;
     BoxRec panned_area;
-    int n;
 
     REQUEST_SIZE_MATCH(xRRGetCrtcInfoReq);
     VERIFY_RR_CRTC(stuff->crtc, crtc, DixReadAccess);
@@ -1060,7 +1059,7 @@ ProcRRGetCrtcInfo(ClientPtr client)
     for (i = 0; i < crtc->numOutputs; i++) {
         outputs[i] = crtc->outputs[i]->id;
         if (client->swapped)
-            swapl(&outputs[i], n);
+            swapl(&outputs[i]);
     }
     k = 0;
     for (i = 0; i < pScrPriv->numOutputs; i++)
@@ -1068,23 +1067,23 @@ ProcRRGetCrtcInfo(ClientPtr client)
             if (pScrPriv->outputs[i]->crtcs[j] == crtc) {
                 possible[k] = pScrPriv->outputs[i]->id;
                 if (client->swapped)
-                    swapl(&possible[k], n);
+                    swapl(&possible[k]);
                 k++;
             }
 
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.timestamp, n);
-        swaps(&rep.x, n);
-        swaps(&rep.y, n);
-        swaps(&rep.width, n);
-        swaps(&rep.height, n);
-        swapl(&rep.mode, n);
-        swaps(&rep.rotation, n);
-        swaps(&rep.rotations, n);
-        swaps(&rep.nOutput, n);
-        swaps(&rep.nPossibleOutput, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.timestamp);
+        swaps(&rep.x);
+        swaps(&rep.y);
+        swaps(&rep.width);
+        swaps(&rep.height);
+        swapl(&rep.mode);
+        swaps(&rep.rotation);
+        swaps(&rep.rotations);
+        swaps(&rep.nOutput);
+        swaps(&rep.nPossibleOutput);
     }
     WriteToClient(client, sizeof(xRRGetCrtcInfoReply), (char *) &rep);
     if (extraLen) {
@@ -1115,7 +1114,6 @@ ProcRRSetCrtcConfig(ClientPtr client)
 #endif
      i, j;
     CARD8 status;
-    int n;
 
     REQUEST_AT_LEAST_SIZE(xRRSetCrtcConfigReq);
     numOutputs = (stuff->length - bytes_to_int32(SIZEOF(xRRSetCrtcConfigReq)));
@@ -1314,9 +1312,9 @@ ProcRRSetCrtcConfig(ClientPtr client)
         .newTimestamp = pScrPriv->lastSetTime.milliseconds
     };
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.newTimestamp, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.newTimestamp);
     }
     WriteToClient(client, sizeof(xRRSetCrtcConfigReply), (char *) &rep);
 
@@ -1334,7 +1332,6 @@ ProcRRGetPanning(ClientPtr client)
     BoxRec total;
     BoxRec tracking;
     INT16 border[4];
-    int n;
 
     REQUEST_SIZE_MATCH(xRRGetPanningReq);
     VERIFY_RR_CRTC(stuff->crtc, crtc, DixReadAccess);
@@ -1372,21 +1369,21 @@ ProcRRGetPanning(ClientPtr client)
     }
 
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.timestamp, n);
-        swaps(&rep.left, n);
-        swaps(&rep.top, n);
-        swaps(&rep.width, n);
-        swaps(&rep.height, n);
-        swaps(&rep.track_left, n);
-        swaps(&rep.track_top, n);
-        swaps(&rep.track_width, n);
-        swaps(&rep.track_height, n);
-        swaps(&rep.border_left, n);
-        swaps(&rep.border_top, n);
-        swaps(&rep.border_right, n);
-        swaps(&rep.border_bottom, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.timestamp);
+        swaps(&rep.left);
+        swaps(&rep.top);
+        swaps(&rep.width);
+        swaps(&rep.height);
+        swaps(&rep.track_left);
+        swaps(&rep.track_top);
+        swaps(&rep.track_width);
+        swaps(&rep.track_height);
+        swaps(&rep.border_left);
+        swaps(&rep.border_top);
+        swaps(&rep.border_right);
+        swaps(&rep.border_bottom);
     }
     WriteToClient(client, sizeof(xRRGetPanningReply), (char *) &rep);
     return Success;
@@ -1405,7 +1402,6 @@ ProcRRSetPanning(ClientPtr client)
     BoxRec tracking;
     INT16 border[4];
     CARD8 status;
-    int n;
 
     REQUEST_SIZE_MATCH(xRRSetPanningReq);
     VERIFY_RR_CRTC(stuff->crtc, crtc, DixReadAccess);
@@ -1456,9 +1452,9 @@ ProcRRSetPanning(ClientPtr client)
         .newTimestamp = pScrPriv->lastSetTime.milliseconds
     };
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.newTimestamp, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.newTimestamp);
     }
     WriteToClient(client, sizeof(xRRSetPanningReply), (char *) &rep);
     return Success;
@@ -1470,7 +1466,6 @@ ProcRRGetCrtcGammaSize(ClientPtr client)
     REQUEST(xRRGetCrtcGammaSizeReq);
     xRRGetCrtcGammaSizeReply reply;
     RRCrtcPtr crtc;
-    int n;
 
     REQUEST_SIZE_MATCH(xRRGetCrtcGammaSizeReq);
     VERIFY_RR_CRTC(stuff->crtc, crtc, DixReadAccess);
@@ -1486,9 +1481,9 @@ ProcRRGetCrtcGammaSize(ClientPtr client)
         .size = crtc->gammaSize
     };
     if (client->swapped) {
-        swaps(&reply.sequenceNumber, n);
-        swapl(&reply.length, n);
-        swaps(&reply.size, n);
+        swaps(&reply.sequenceNumber);
+        swapl(&reply.length);
+        swaps(&reply.size);
     }
     WriteToClient(client, sizeof(xRRGetCrtcGammaSizeReply), (char *) &reply);
     return Success;
@@ -1502,7 +1497,6 @@ ProcRRGetCrtcGamma(ClientPtr client)
     RRCrtcPtr crtc;
     unsigned long len;
     char *extra = NULL;
-    int n;
 
     REQUEST_SIZE_MATCH(xRRGetCrtcGammaReq);
     VERIFY_RR_CRTC(stuff->crtc, crtc, DixReadAccess);
@@ -1526,9 +1520,9 @@ ProcRRGetCrtcGamma(ClientPtr client)
         .size = crtc->gammaSize
     };
     if (client->swapped) {
-        swaps(&reply.sequenceNumber, n);
-        swapl(&reply.length, n);
-        swaps(&reply.size, n);
+        swaps(&reply.sequenceNumber);
+        swapl(&reply.length);
+        swaps(&reply.size);
     }
     WriteToClient(client, sizeof(xRRGetCrtcGammaReply), (char *) &reply);
     if (crtc->gammaSize) {
@@ -1620,7 +1614,6 @@ transform_filter_encode(ClientPtr client, char *output,
                         CARD16 *nparamsFilter, RRTransformPtr transform)
 {
     int nbytes, nparams;
-    int n;
 
     if (transform->filter == NULL) {
         *nbytesFilter = 0;
@@ -1636,8 +1629,8 @@ transform_filter_encode(ClientPtr client, char *output,
         output[nbytes++] = 0;
     memcpy(output + nbytes, transform->params, nparams * sizeof(xFixed));
     if (client->swapped) {
-        swaps(nbytesFilter, n);
-        swaps(nparamsFilter, n);
+        swaps(nbytesFilter);
+        swaps(nparamsFilter);
         SwapLongs((CARD32 *) (output + nbytes), nparams);
     }
     nbytes += nparams * sizeof(xFixed);
@@ -1662,7 +1655,6 @@ ProcRRGetCrtcTransform(ClientPtr client)
     int nextra;
     RRTransformPtr current, pending;
     char *extra;
-    int n;
 
     REQUEST_SIZE_MATCH(xRRGetCrtcTransformReq);
     VERIFY_RR_CRTC(stuff->crtc, crtc, DixReadAccess);
@@ -1695,8 +1687,8 @@ ProcRRGetCrtcTransform(ClientPtr client)
                                      &reply->currentNparamsFilter, current);
 
     if (client->swapped) {
-        swaps(&reply->sequenceNumber, n);
-        swapl(&reply->length, n);
+        swaps(&reply->sequenceNumber);
+        swapl(&reply->length);
     }
     WriteToClient(client, sizeof(xRRGetCrtcTransformReply) + nextra,
                   (char *) reply);
diff --git a/nx-X11/programs/Xserver/randr/rrdispatch.c b/nx-X11/programs/Xserver/randr/rrdispatch.c
index 50f2011c6..eae774636 100644
--- a/nx-X11/programs/Xserver/randr/rrdispatch.c
+++ b/nx-X11/programs/Xserver/randr/rrdispatch.c
@@ -35,8 +35,6 @@ RRClientKnowsRates(ClientPtr pClient)
 static int
 ProcRRQueryVersion(ClientPtr client)
 {
-    int n;
-
     xRRQueryVersionReply rep = {
         .type = X_Reply,
         .sequenceNumber = client->sequence,
@@ -61,10 +59,10 @@ ProcRRQueryVersion(ClientPtr client)
     }
 
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.majorVersion, n);
-        swapl(&rep.minorVersion, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.majorVersion);
+        swapl(&rep.minorVersion);
     }
 #ifndef NXAGENT_SERVER
     WriteToClient(client, sizeof(xRRQueryVersionReply), &rep);
diff --git a/nx-X11/programs/Xserver/randr/rrmode.c b/nx-X11/programs/Xserver/randr/rrmode.c
index c4718c1b4..c3e60c0bd 100644
--- a/nx-X11/programs/Xserver/randr/rrmode.c
+++ b/nx-X11/programs/Xserver/randr/rrmode.c
@@ -344,7 +344,6 @@ ProcRRCreateMode(ClientPtr client)
     char *name;
     int error, rc;
     RRModePtr mode;
-    int n;
 
     REQUEST_AT_LEAST_SIZE(xRRCreateModeReq);
 #ifndef NXAGENT_SERVER
@@ -377,9 +376,9 @@ ProcRRCreateMode(ClientPtr client)
         .mode = mode->mode.id
     };
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.mode, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.mode);
     }
     WriteToClient(client, sizeof(xRRCreateModeReply), (char *) &rep);
     /* Drop out reference to this mode */
diff --git a/nx-X11/programs/Xserver/randr/rrmonitor.c b/nx-X11/programs/Xserver/randr/rrmonitor.c
index 42e0de64a..d648625c1 100644
--- a/nx-X11/programs/Xserver/randr/rrmonitor.c
+++ b/nx-X11/programs/Xserver/randr/rrmonitor.c
@@ -629,7 +629,7 @@ ProcRRGetMonitors(ClientPtr client)
     RRMonitorPtr monitors;
     int nmonitors;
     int noutputs;
-    int m, n;
+    int m;
     Bool get_active;
 
     REQUEST_SIZE_MATCH(xRRGetMonitorsReq);
@@ -661,11 +661,11 @@ ProcRRGetMonitors(ClientPtr client)
     rep.noutputs = noutputs;
 
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.timestamp, n);
-        swapl(&rep.nmonitors, n);
-        swapl(&rep.noutputs, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.timestamp);
+        swapl(&rep.nmonitors);
+        swapl(&rep.noutputs);
     }
     WriteToClient(client, sizeof(xRRGetMonitorsReply), (char *) &rep);
 
@@ -686,14 +686,14 @@ ProcRRGetMonitors(ClientPtr client)
             .heightInMillimeters = monitor->geometry.mmHeight,
         };
         if (client->swapped) {
-            swapl(&info.name, n);
-            swaps(&info.noutput, n);
-            swaps(&info.x, n);
-            swaps(&info.y, n);
-            swaps(&info.width, n);
-            swaps(&info.height, n);
-            swapl(&info.widthInMillimeters, n);
-            swapl(&info.heightInMillimeters, n);
+            swapl(&info.name);
+            swaps(&info.noutput);
+            swaps(&info.x);
+            swaps(&info.y);
+            swaps(&info.width);
+            swaps(&info.height);
+            swapl(&info.widthInMillimeters);
+            swapl(&info.heightInMillimeters);
         }
 
         WriteToClient(client, sizeof(xRRMonitorInfo), (char *) &info);
diff --git a/nx-X11/programs/Xserver/randr/rroutput.c b/nx-X11/programs/Xserver/randr/rroutput.c
index 4a3d32a12..c245de874 100644
--- a/nx-X11/programs/Xserver/randr/rroutput.c
+++ b/nx-X11/programs/Xserver/randr/rroutput.c
@@ -463,7 +463,6 @@ ProcRRGetOutputInfo(ClientPtr client)
     RROutput *clones;
     char *name;
     int i;
-    int n;
 
     REQUEST_SIZE_MATCH(xRRGetOutputInfoReq);
     VERIFY_RR_OUTPUT(stuff->output, output, DixReadAccess);
@@ -509,7 +508,7 @@ ProcRRGetOutputInfo(ClientPtr client)
     for (i = 0; i < output->numCrtcs; i++) {
         crtcs[i] = output->crtcs[i]->id;
         if (client->swapped)
-            swapl(&crtcs[i], n);
+            swapl(&crtcs[i]);
     }
     for (i = 0; i < output->numModes + output->numUserModes; i++) {
         if (i < output->numModes)
@@ -517,26 +516,26 @@ ProcRRGetOutputInfo(ClientPtr client)
         else
             modes[i] = output->userModes[i - output->numModes]->mode.id;
         if (client->swapped)
-            swapl(&modes[i], n);
+            swapl(&modes[i]);
     }
     for (i = 0; i < output->numClones; i++) {
         clones[i] = output->clones[i]->id;
         if (client->swapped)
-            swapl(&clones[i], n);
+            swapl(&clones[i]);
     }
     memcpy(name, output->name, output->nameLength);
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.timestamp, n);
-        swapl(&rep.crtc, n);
-        swapl(&rep.mmWidth, n);
-        swapl(&rep.mmHeight, n);
-        swaps(&rep.nCrtcs, n);
-        swaps(&rep.nModes, n);
-        swaps(&rep.nPreferred, n);
-        swaps(&rep.nClones, n);
-        swaps(&rep.nameLength, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.timestamp);
+        swapl(&rep.crtc);
+        swapl(&rep.mmWidth);
+        swapl(&rep.mmHeight);
+        swaps(&rep.nCrtcs);
+        swaps(&rep.nModes);
+        swaps(&rep.nPreferred);
+        swaps(&rep.nClones);
+        swaps(&rep.nameLength);
     }
     WriteToClient(client, sizeof(xRRGetOutputInfoReply), (char *) &rep);
     if (extraLen) {
@@ -639,7 +638,6 @@ ProcRRGetOutputPrimary(ClientPtr client)
     xRRGetOutputPrimaryReply rep;
     RROutputPtr primary = NULL;
     int rc;
-    int n;
 
     REQUEST_SIZE_MATCH(xRRGetOutputPrimaryReq);
 
@@ -663,8 +661,8 @@ ProcRRGetOutputPrimary(ClientPtr client)
         .output = primary ? primary->id : None
     };
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.output, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.output);
     }
 
     WriteToClient(client, sizeof(xRRGetOutputPrimaryReply), (char *) &rep);
diff --git a/nx-X11/programs/Xserver/randr/rrproperty.c b/nx-X11/programs/Xserver/randr/rrproperty.c
index cf13ca23e..334fd4720 100644
--- a/nx-X11/programs/Xserver/randr/rrproperty.c
+++ b/nx-X11/programs/Xserver/randr/rrproperty.c
@@ -405,7 +405,6 @@ ProcRRListOutputProperties(ClientPtr client)
     int numProps = 0;
     RROutputPtr output;
     RRPropertyPtr prop;
-    int n;
 
     REQUEST_SIZE_MATCH(xRRListOutputPropertiesReq);
 
@@ -428,9 +427,9 @@ ProcRRListOutputProperties(ClientPtr client)
         .nAtoms = numProps
     };
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swaps(&rep.nAtoms, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swaps(&rep.nAtoms);
     }
     WriteToClient(client, sizeof(xRRListOutputPropertiesReply), (char *) &rep);
 
@@ -455,7 +454,6 @@ ProcRRQueryOutputProperty(ClientPtr client)
     RROutputPtr output;
     RRPropertyPtr prop;
     char *extra = NULL;
-    int n;
 
     REQUEST_SIZE_MATCH(xRRQueryOutputPropertyReq);
 
@@ -484,8 +482,8 @@ ProcRRQueryOutputProperty(ClientPtr client)
         .immutable = prop->immutable
     };
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
     }
     WriteToClient(client, sizeof(xRRQueryOutputPropertyReply), (char *) &rep);
     if (prop->num_valid) {
@@ -609,7 +607,6 @@ ProcRRGetOutputProperty(ClientPtr client)
     RROutputPtr output;
     xRRGetOutputPropertyReply reply;
     char *extra = NULL;
-    int m;
 
     REQUEST_SIZE_MATCH(xRRGetOutputPropertyReq);
     if (stuff->delete)
@@ -645,11 +642,11 @@ ProcRRGetOutputProperty(ClientPtr client)
         reply.propertyType = None;
         reply.format = 0;
         if (client->swapped) {
-            swaps(&reply.sequenceNumber, m);
-            swapl(&reply.length, m);
-            swapl(&reply.propertyType, m);
-            swapl(&reply.bytesAfter, m);
-            swapl(&reply.nItems, m);
+            swaps(&reply.sequenceNumber);
+            swapl(&reply.length);
+            swapl(&reply.propertyType);
+            swapl(&reply.bytesAfter);
+            swapl(&reply.nItems);
         }
         WriteToClient(client, sizeof(xRRGetOutputPropertyReply),
                       (char *) &reply);
@@ -674,11 +671,11 @@ ProcRRGetOutputProperty(ClientPtr client)
         reply.nItems = 0;
         reply.propertyType = prop_value->type;
         if (client->swapped) {
-            swaps(&reply.sequenceNumber, n);
-            swapl(&reply.length, n);
-            swapl(&reply.propertyType, n);
-            swapl(&reply.bytesAfter, n);
-            swapl(&reply.nItems, n);
+            swaps(&reply.sequenceNumber);
+            swapl(&reply.length);
+            swapl(&reply.propertyType);
+            swapl(&reply.bytesAfter);
+            swapl(&reply.nItems);
         }
         WriteToClient(client, sizeof(xRRGetOutputPropertyReply),
                       (char *) &reply);
@@ -728,11 +725,11 @@ ProcRRGetOutputProperty(ClientPtr client)
     }
 
     if (client->swapped) {
-        swaps(&reply.sequenceNumber, n);
-        swapl(&reply.length, n);
-        swapl(&reply.propertyType, n);
-        swapl(&reply.bytesAfter, n);
-        swapl(&reply.nItems, n);
+        swaps(&reply.sequenceNumber);
+        swapl(&reply.length);
+        swapl(&reply.propertyType);
+        swapl(&reply.bytesAfter);
+        swapl(&reply.nItems);
     }
     WriteToClient(client, sizeof(xGenericReply), (char *) &reply);
     if (len) {
diff --git a/nx-X11/programs/Xserver/randr/rrprovider.c b/nx-X11/programs/Xserver/randr/rrprovider.c
index 7d3096482..9ffb404c5 100644
--- a/nx-X11/programs/Xserver/randr/rrprovider.c
+++ b/nx-X11/programs/Xserver/randr/rrprovider.c
@@ -43,7 +43,7 @@ RRProviderInitErrorValue(void)
     if (pScrPriv->provider) {                                   \
         providers[count_providers] = pScrPriv->provider->id;    \
         if (client->swapped)                                    \
-            swapl(&providers[count_providers], n);                 \
+            swapl(&providers[count_providers]);                 \
         count_providers++;                                      \
     }                                                           \
     } while(0)
@@ -64,7 +64,6 @@ ProcRRGetProviders(ClientPtr client)
 #ifndef NXAGENT_SERVER
     ScreenPtr iter;
 #endif
-    int n;
 
     REQUEST_SIZE_MATCH(xRRGetProvidersReq);
 #ifndef NXAGENT_SERVER
@@ -143,10 +142,10 @@ ProcRRGetProviders(ClientPtr client)
     }
 
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.timestamp, n);
-        swaps(&rep.nProviders, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.timestamp);
+        swaps(&rep.nProviders);
     }
     WriteToClient(client, sizeof(xRRGetProvidersReply), (char *) &rep);
     if (extraLen)
@@ -179,7 +178,6 @@ ProcRRGetProviderInfo(ClientPtr client)
 #endif
     RRProvider *providers;
     uint32_t *prov_cap;
-    int n;
 
     REQUEST_SIZE_MATCH(xRRGetProviderInfoReq);
     VERIFY_RR_PROVIDER(stuff->provider, provider, DixReadAccess);
@@ -233,31 +231,31 @@ ProcRRGetProviderInfo(ClientPtr client)
     for (i = 0; i < pScrPriv->numCrtcs; i++) {
         crtcs[i] = pScrPriv->crtcs[i]->id;
         if (client->swapped)
-            swapl(&crtcs[i], n);
+            swapl(&crtcs[i]);
     }
 
     for (i = 0; i < pScrPriv->numOutputs; i++) {
         outputs[i] = pScrPriv->outputs[i]->id;
         if (client->swapped)
-            swapl(&outputs[i], n);
+            swapl(&outputs[i]);
     }
 
     i = 0;
     if (provider->offload_sink) {
         providers[i] = provider->offload_sink->id;
         if (client->swapped)
-            swapl(&providers[i], n);
+            swapl(&providers[i]);
         prov_cap[i] = RR_Capability_SinkOffload;
         if (client->swapped)
-            swapl(&prov_cap[i], n);
+            swapl(&prov_cap[i]);
         i++;
     }
     if (provider->output_source) {
         providers[i] = provider->output_source->id;
         if (client->swapped)
-            swapl(&providers[i], n);
+            swapl(&providers[i]);
         prov_cap[i] = RR_Capability_SourceOutput;
-        swapl(&prov_cap[i], n);
+        swapl(&prov_cap[i]);
         i++;
     }
 #ifndef NXAGENT_SERVER
@@ -284,12 +282,12 @@ ProcRRGetProviderInfo(ClientPtr client)
 #endif
     memcpy(name, provider->name, rep.nameLength);
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.capabilities, n);
-        swaps(&rep.nCrtcs, n);
-        swaps(&rep.nOutputs, n);
-        swaps(&rep.nameLength, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.capabilities);
+        swaps(&rep.nCrtcs);
+        swaps(&rep.nOutputs);
+        swaps(&rep.nameLength);
     }
     WriteToClient(client, sizeof(xRRGetProviderInfoReply), (char *) &rep);
     if (extraLen)
diff --git a/nx-X11/programs/Xserver/randr/rrproviderproperty.c b/nx-X11/programs/Xserver/randr/rrproviderproperty.c
index b7ba8ab53..303719909 100644
--- a/nx-X11/programs/Xserver/randr/rrproviderproperty.c
+++ b/nx-X11/programs/Xserver/randr/rrproviderproperty.c
@@ -401,7 +401,6 @@ ProcRRListProviderProperties(ClientPtr client)
     int numProps = 0;
     RRProviderPtr provider;
     RRPropertyPtr prop;
-    int n;
 
     REQUEST_SIZE_MATCH(xRRListProviderPropertiesReq);
 
@@ -424,9 +423,9 @@ ProcRRListProviderProperties(ClientPtr client)
         .nAtoms = numProps
     };
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swaps(&rep.nAtoms, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swaps(&rep.nAtoms);
     }
     temppAtoms = pAtoms;
     for (prop = provider->properties; prop; prop = prop->next)
@@ -450,7 +449,6 @@ ProcRRQueryProviderProperty(ClientPtr client)
     RRProviderPtr provider;
     RRPropertyPtr prop;
     char *extra = NULL;
-    int n;
 
     REQUEST_SIZE_MATCH(xRRQueryProviderPropertyReq);
 
@@ -478,8 +476,8 @@ ProcRRQueryProviderProperty(ClientPtr client)
         .immutable = prop->immutable
     };
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
     }
     WriteToClient(client, sizeof(xRRQueryProviderPropertyReply), (char *) &rep);
     if (prop->num_valid) {
@@ -637,11 +635,11 @@ ProcRRGetProviderProperty(ClientPtr client)
         reply.propertyType = None;
         reply.format = 0;
         if (client->swapped) {
-            swaps(&reply.sequenceNumber, n);
-            swapl(&reply.length, n);
-            swapl(&reply.propertyType, n);
-            swapl(&reply.bytesAfter, n);
-            swapl(&reply.nItems, n);
+            swaps(&reply.sequenceNumber);
+            swapl(&reply.length);
+            swapl(&reply.propertyType);
+            swapl(&reply.bytesAfter);
+            swapl(&reply.nItems);
         }
         WriteToClient(client, sizeof(xRRGetProviderPropertyReply),
                       (char *) &reply);
@@ -666,11 +664,11 @@ ProcRRGetProviderProperty(ClientPtr client)
         reply.nItems = 0;
         reply.propertyType = prop_value->type;
         if (client->swapped) {
-            swaps(&reply.sequenceNumber, n);
-            swapl(&reply.length, n);
-            swapl(&reply.propertyType, n);
-            swapl(&reply.bytesAfter, n);
-            swapl(&reply.nItems, n);
+            swaps(&reply.sequenceNumber);
+            swapl(&reply.length);
+            swapl(&reply.propertyType);
+            swapl(&reply.bytesAfter);
+            swapl(&reply.nItems);
         }
         WriteToClient(client, sizeof(xRRGetProviderPropertyReply),
                       (char *) &reply);
@@ -720,11 +718,11 @@ ProcRRGetProviderProperty(ClientPtr client)
     }
 
     if (client->swapped) {
-        swaps(&reply.sequenceNumber, n);
-        swapl(&reply.length, n);
-        swapl(&reply.propertyType, n);
-        swapl(&reply.bytesAfter, n);
-        swapl(&reply.nItems, n);
+        swaps(&reply.sequenceNumber);
+        swapl(&reply.length);
+        swapl(&reply.propertyType);
+        swapl(&reply.bytesAfter);
+        swapl(&reply.nItems);
     }
     WriteToClient(client, sizeof(xGenericReply), (char *) &reply);
     if (len) {
diff --git a/nx-X11/programs/Xserver/randr/rrscreen.c b/nx-X11/programs/Xserver/randr/rrscreen.c
index 017ff0143..81ae5b741 100644
--- a/nx-X11/programs/Xserver/randr/rrscreen.c
+++ b/nx-X11/programs/Xserver/randr/rrscreen.c
@@ -212,7 +212,6 @@ ProcRRGetScreenSizeRange(ClientPtr client)
     ScreenPtr pScreen;
     rrScrPrivPtr pScrPriv;
     int rc;
-    int n;
 
     REQUEST_SIZE_MATCH(xRRGetScreenSizeRangeReq);
 #ifndef NXAGENT_SERVER
@@ -248,12 +247,12 @@ ProcRRGetScreenSizeRange(ClientPtr client)
         rep.maxHeight = rep.minHeight = pScreen->height;
     }
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swaps(&rep.minWidth, n);
-        swaps(&rep.minHeight, n);
-        swaps(&rep.maxWidth, n);
-        swaps(&rep.maxHeight, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swaps(&rep.minWidth);
+        swaps(&rep.minHeight);
+        swaps(&rep.maxWidth);
+        swaps(&rep.maxHeight);
     }
     WriteToClient(client, sizeof(xRRGetScreenSizeRangeReply), (char *) &rep);
     return Success;
@@ -340,21 +339,19 @@ ProcRRSetScreenSize(ClientPtr client)
 static inline void
 swap_modeinfos(xRRModeInfo * modeinfos, int i)
 {
-    int n;
-
-    swapl(&modeinfos[i].id, n);
-    swaps(&modeinfos[i].width, n);
-    swaps(&modeinfos[i].height, n);
-    swapl(&modeinfos[i].dotClock, n);
-    swaps(&modeinfos[i].hSyncStart, n);
-    swaps(&modeinfos[i].hSyncEnd, n);
-    swaps(&modeinfos[i].hTotal, n);
-    swaps(&modeinfos[i].hSkew, n);
-    swaps(&modeinfos[i].vSyncStart, n);
-    swaps(&modeinfos[i].vSyncEnd, n);
-    swaps(&modeinfos[i].vTotal, n);
-    swaps(&modeinfos[i].nameLength, n);
-    swapl(&modeinfos[i].modeFlags, n);
+    swapl(&modeinfos[i].id);
+    swaps(&modeinfos[i].width);
+    swaps(&modeinfos[i].height);
+    swapl(&modeinfos[i].dotClock);
+    swaps(&modeinfos[i].hSyncStart);
+    swaps(&modeinfos[i].hSyncEnd);
+    swaps(&modeinfos[i].hTotal);
+    swaps(&modeinfos[i].hSkew);
+    swaps(&modeinfos[i].vSyncStart);
+    swaps(&modeinfos[i].vSyncEnd);
+    swaps(&modeinfos[i].vTotal);
+    swaps(&modeinfos[i].nameLength);
+    swapl(&modeinfos[i].modeFlags);
 }
 
 #define update_arrays(gpuscreen, pScrPriv, primary_crtc, has_primary) do {            \
@@ -366,13 +363,13 @@ swap_modeinfos(xRRModeInfo * modeinfos, int i)
         }\
         crtcs[crtc_count] = pScrPriv->crtcs[j]->id;        \
         if (client->swapped)                               \
-            swapl(&crtcs[crtc_count], n);                     \
+            swapl(&crtcs[crtc_count]);                     \
         crtc_count++;                                      \
     }                                                      \
     for (j = 0; j < pScrPriv->numOutputs; j++) {           \
         outputs[output_count] = pScrPriv->outputs[j]->id;  \
         if (client->swapped)                               \
-            swapl(&outputs[output_count], n);                 \
+            swapl(&outputs[output_count]);                 \
         output_count++;                                    \
     }                                                      \
     {                                                      \
@@ -412,7 +409,6 @@ rrGetMultiScreenResources(ClientPtr client, Bool query, ScreenPtr pScreen)
     xRRModeInfo *modeinfos;
     CARD8 *names;
     int has_primary = 0;
-    int n;
 
     /* we need to iterate all the GPU masters and all their output slaves */
     total_crtcs = 0;
@@ -479,7 +475,7 @@ rrGetMultiScreenResources(ClientPtr client, Bool query, ScreenPtr pScreen)
         primary_crtc = pScrPriv->primaryOutput->crtc;
         crtcs[0] = pScrPriv->primaryOutput->crtc->id;
         if (client->swapped)
-            swapl(&crtcs[0], n);
+            swapl(&crtcs[0]);
         crtc_count = 1;
     }
     update_arrays(pScreen, pScrPriv, primary_crtc, has_primary);
@@ -492,14 +488,14 @@ rrGetMultiScreenResources(ClientPtr client, Bool query, ScreenPtr pScreen)
 
     assert(bytes_to_int32((char *) names - (char *) extra) == rep.length);
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.timestamp, n);
-        swapl(&rep.configTimestamp, n);
-        swaps(&rep.nCrtcs, n);
-        swaps(&rep.nOutputs, n);
-        swaps(&rep.nModes, n);
-        swaps(&rep.nbytesNames, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.timestamp);
+        swapl(&rep.configTimestamp);
+        swaps(&rep.nCrtcs);
+        swaps(&rep.nOutputs);
+        swaps(&rep.nModes);
+        swaps(&rep.nbytesNames);
     }
     WriteToClient(client, sizeof(xRRGetScreenResourcesReply), (char *) &rep);
     if (extraLen) {
@@ -525,7 +521,6 @@ rrGetScreenResources(ClientPtr client, Bool query)
     RROutput *outputs;
     xRRModeInfo *modeinfos;
     CARD8 *names;
-    int n;
 
     REQUEST_SIZE_MATCH(xRRGetScreenResourcesReq);
 
@@ -613,7 +608,7 @@ rrGetScreenResources(ClientPtr client, Bool query)
             has_primary = 1;
             crtcs[0] = pScrPriv->primaryOutput->crtc->id;
             if (client->swapped)
-                swapl(&crtcs[0], n);
+                swapl(&crtcs[0]);
         }
 
         for (i = 0; i < pScrPriv->numCrtcs; i++) {
@@ -624,13 +619,13 @@ rrGetScreenResources(ClientPtr client, Bool query)
             }
             crtcs[i + has_primary] = pScrPriv->crtcs[i]->id;
             if (client->swapped)
-                swapl(&crtcs[i + has_primary], n);
+                swapl(&crtcs[i + has_primary]);
         }
 
         for (i = 0; i < pScrPriv->numOutputs; i++) {
             outputs[i] = pScrPriv->outputs[i]->id;
             if (client->swapped)
-                swapl(&outputs[i], n);
+                swapl(&outputs[i]);
         }
 
         for (i = 0; i < num_modes; i++) {
@@ -638,19 +633,19 @@ rrGetScreenResources(ClientPtr client, Bool query)
 
             modeinfos[i] = mode->mode;
             if (client->swapped) {
-                swapl(&modeinfos[i].id, n);
-                swaps(&modeinfos[i].width, n);
-                swaps(&modeinfos[i].height, n);
-                swapl(&modeinfos[i].dotClock, n);
-                swaps(&modeinfos[i].hSyncStart, n);
-                swaps(&modeinfos[i].hSyncEnd, n);
-                swaps(&modeinfos[i].hTotal, n);
-                swaps(&modeinfos[i].hSkew, n);
-                swaps(&modeinfos[i].vSyncStart, n);
-                swaps(&modeinfos[i].vSyncEnd, n);
-                swaps(&modeinfos[i].vTotal, n);
-                swaps(&modeinfos[i].nameLength, n);
-                swapl(&modeinfos[i].modeFlags, n);
+                swapl(&modeinfos[i].id);
+                swaps(&modeinfos[i].width);
+                swaps(&modeinfos[i].height);
+                swapl(&modeinfos[i].dotClock);
+                swaps(&modeinfos[i].hSyncStart);
+                swaps(&modeinfos[i].hSyncEnd);
+                swaps(&modeinfos[i].hTotal);
+                swaps(&modeinfos[i].hSkew);
+                swaps(&modeinfos[i].vSyncStart);
+                swaps(&modeinfos[i].vSyncEnd);
+                swaps(&modeinfos[i].vTotal);
+                swaps(&modeinfos[i].nameLength);
+                swapl(&modeinfos[i].modeFlags);
             }
             memcpy(names, mode->name, mode->mode.nameLength);
             names += mode->mode.nameLength;
@@ -660,14 +655,14 @@ rrGetScreenResources(ClientPtr client, Bool query)
     }
 
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.timestamp, n);
-        swapl(&rep.configTimestamp, n);
-        swaps(&rep.nCrtcs, n);
-        swaps(&rep.nOutputs, n);
-        swaps(&rep.nModes, n);
-        swaps(&rep.nbytesNames, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.timestamp);
+        swapl(&rep.configTimestamp);
+        swaps(&rep.nCrtcs);
+        swaps(&rep.nOutputs);
+        swaps(&rep.nModes);
+        swaps(&rep.nbytesNames);
     }
     WriteToClient(client, sizeof(xRRGetScreenResourcesReply),
                   (char *) (char *) &rep);
@@ -801,7 +796,6 @@ ProcRRGetScreenInfo(ClientPtr client)
     CARD8 *extra;
     unsigned long extraLen;
     RROutputPtr output;
-    int n;
 
     REQUEST_SIZE_MATCH(xRRGetScreenInfoReq);
 #ifndef NXAGENT_SERVER
@@ -895,22 +889,22 @@ ProcRRGetScreenInfo(ClientPtr client)
             size->widthInMillimeters = pSize->mmWidth;
             size->heightInMillimeters = pSize->mmHeight;
             if (client->swapped) {
-                swaps(&size->widthInPixels, n);
-                swaps(&size->heightInPixels, n);
-                swaps(&size->widthInMillimeters, n);
-                swaps(&size->heightInMillimeters, n);
+                swaps(&size->widthInPixels);
+                swaps(&size->heightInPixels);
+                swaps(&size->widthInMillimeters);
+                swaps(&size->heightInMillimeters);
             }
             size++;
             if (has_rate) {
                 *rates = pSize->nRates;
                 if (client->swapped) {
-                    swaps(rates, n);
+                    swaps(rates);
                 }
                 rates++;
                 for (j = 0; j < pSize->nRates; j++) {
                     *rates = pSize->pRates[j].rate;
                     if (client->swapped) {
-                        swaps(rates, n);
+                        swaps(rates);
                     }
                     rates++;
                 }
@@ -926,15 +920,15 @@ ProcRRGetScreenInfo(ClientPtr client)
         rep.length = bytes_to_int32(extraLen);
     }
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.timestamp, n);
-        swapl(&rep.configTimestamp, n);
-        swaps(&rep.rotation, n);
-        swaps(&rep.nSizes, n);
-        swaps(&rep.sizeID, n);
-        swaps(&rep.rate, n);
-        swaps(&rep.nrateEnts, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.timestamp);
+        swapl(&rep.configTimestamp);
+        swaps(&rep.rotation);
+        swaps(&rep.nSizes);
+        swaps(&rep.sizeID);
+        swaps(&rep.rate);
+        swaps(&rep.nrateEnts);
     }
     WriteToClient(client, sizeof(xRRGetScreenInfoReply), (char *) &rep);
     if (extraLen) {
@@ -965,7 +959,6 @@ ProcRRSetScreenConfig(ClientPtr client)
     RR10DataPtr pData = NULL;
     RRScreenSizePtr pSize;
     int width, height;
-    int n;
 
     UpdateCurrentTime();
 
@@ -1173,11 +1166,11 @@ ProcRRSetScreenConfig(ClientPtr client)
     };
 
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.newTimestamp, n);
-        swapl(&rep.newConfigTimestamp, n);
-        swapl(&rep.root, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.newTimestamp);
+        swapl(&rep.newConfigTimestamp);
+        swapl(&rep.root);
     }
     WriteToClient(client, sizeof(xRRSetScreenConfigReply), (char *) &rep);
 
diff --git a/nx-X11/programs/Xserver/randr/rrsdispatch.c b/nx-X11/programs/Xserver/randr/rrsdispatch.c
index 6ac394344..04ac8526c 100644
--- a/nx-X11/programs/Xserver/randr/rrsdispatch.c
+++ b/nx-X11/programs/Xserver/randr/rrsdispatch.c
@@ -25,162 +25,140 @@
 static int
 SProcRRQueryVersion(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRQueryVersionReq);
 
     REQUEST_SIZE_MATCH(xRRQueryVersionReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->majorVersion, n);
-    swapl(&stuff->minorVersion, n);
+    swaps(&stuff->length);
+    swapl(&stuff->majorVersion);
+    swapl(&stuff->minorVersion);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRGetScreenInfo(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRGetScreenInfoReq);
 
     REQUEST_SIZE_MATCH(xRRGetScreenInfoReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
+    swaps(&stuff->length);
+    swapl(&stuff->window);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRSetScreenConfig(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRSetScreenConfigReq);
 
     if (RRClientKnowsRates(client)) {
         REQUEST_SIZE_MATCH(xRRSetScreenConfigReq);
-        swaps(&stuff->rate, n);
+        swaps(&stuff->rate);
     }
     else {
         REQUEST_SIZE_MATCH(xRR1_0SetScreenConfigReq);
     }
 
-    swaps(&stuff->length, n);
-    swapl(&stuff->drawable, n);
-    swapl(&stuff->timestamp, n);
-    swaps(&stuff->sizeID, n);
-    swaps(&stuff->rotation, n);
+    swaps(&stuff->length);
+    swapl(&stuff->drawable);
+    swapl(&stuff->timestamp);
+    swaps(&stuff->sizeID);
+    swaps(&stuff->rotation);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRSelectInput(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRSelectInputReq);
 
     REQUEST_SIZE_MATCH(xRRSelectInputReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
-    swaps(&stuff->enable, n);
+    swaps(&stuff->length);
+    swapl(&stuff->window);
+    swaps(&stuff->enable);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRGetScreenSizeRange(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRGetScreenSizeRangeReq);
 
     REQUEST_SIZE_MATCH(xRRGetScreenSizeRangeReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
+    swaps(&stuff->length);
+    swapl(&stuff->window);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRSetScreenSize(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRSetScreenSizeReq);
 
     REQUEST_SIZE_MATCH(xRRSetScreenSizeReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
-    swaps(&stuff->width, n);
-    swaps(&stuff->height, n);
-    swapl(&stuff->widthInMillimeters, n);
-    swapl(&stuff->heightInMillimeters, n);
+    swaps(&stuff->length);
+    swapl(&stuff->window);
+    swaps(&stuff->width);
+    swaps(&stuff->height);
+    swapl(&stuff->widthInMillimeters);
+    swapl(&stuff->heightInMillimeters);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRGetScreenResources(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRGetScreenResourcesReq);
 
     REQUEST_SIZE_MATCH(xRRGetScreenResourcesReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
+    swaps(&stuff->length);
+    swapl(&stuff->window);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRGetOutputInfo(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRGetOutputInfoReq);
 
     REQUEST_SIZE_MATCH(xRRGetOutputInfoReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->output, n);
-    swapl(&stuff->configTimestamp, n);
+    swaps(&stuff->length);
+    swapl(&stuff->output);
+    swapl(&stuff->configTimestamp);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRListOutputProperties(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRListOutputPropertiesReq);
 
     REQUEST_SIZE_MATCH(xRRListOutputPropertiesReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->output, n);
+    swaps(&stuff->length);
+    swapl(&stuff->output);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRQueryOutputProperty(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRQueryOutputPropertyReq);
 
     REQUEST_SIZE_MATCH(xRRQueryOutputPropertyReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->output, n);
-    swapl(&stuff->property, n);
+    swaps(&stuff->length);
+    swapl(&stuff->output);
+    swapl(&stuff->property);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRConfigureOutputProperty(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRConfigureOutputPropertyReq);
 
     REQUEST_AT_LEAST_SIZE(xRRConfigureOutputPropertyReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->output, n);
-    swapl(&stuff->property, n);
+    swaps(&stuff->length);
+    swapl(&stuff->output);
+    swapl(&stuff->property);
     SwapRestL(stuff);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
@@ -188,16 +166,14 @@ SProcRRConfigureOutputProperty(ClientPtr client)
 static int
 SProcRRChangeOutputProperty(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRChangeOutputPropertyReq);
 
     REQUEST_AT_LEAST_SIZE(xRRChangeOutputPropertyReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->output, n);
-    swapl(&stuff->property, n);
-    swapl(&stuff->type, n);
-    swapl(&stuff->nUnits, n);
+    swaps(&stuff->length);
+    swapl(&stuff->output);
+    swapl(&stuff->property);
+    swapl(&stuff->type);
+    swapl(&stuff->nUnits);
     switch (stuff->format) {
     case 8:
         break;
@@ -217,134 +193,118 @@ SProcRRChangeOutputProperty(ClientPtr client)
 static int
 SProcRRDeleteOutputProperty(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRDeleteOutputPropertyReq);
 
     REQUEST_SIZE_MATCH(xRRDeleteOutputPropertyReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->output, n);
-    swapl(&stuff->property, n);
+    swaps(&stuff->length);
+    swapl(&stuff->output);
+    swapl(&stuff->property);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRGetOutputProperty(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRGetOutputPropertyReq);
 
     REQUEST_SIZE_MATCH(xRRGetOutputPropertyReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->output, n);
-    swapl(&stuff->property, n);
-    swapl(&stuff->type, n);
-    swapl(&stuff->longOffset, n);
-    swapl(&stuff->longLength, n);
+    swaps(&stuff->length);
+    swapl(&stuff->output);
+    swapl(&stuff->property);
+    swapl(&stuff->type);
+    swapl(&stuff->longOffset);
+    swapl(&stuff->longLength);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRCreateMode(ClientPtr client)
 {
-    int n;
-
     xRRModeInfo *modeinfo;
 
     REQUEST(xRRCreateModeReq);
 
     REQUEST_AT_LEAST_SIZE(xRRCreateModeReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
+    swaps(&stuff->length);
+    swapl(&stuff->window);
 
     modeinfo = &stuff->modeInfo;
-    swapl(&modeinfo->id, n);
-    swaps(&modeinfo->width, n);
-    swaps(&modeinfo->height, n);
-    swapl(&modeinfo->dotClock, n);
-    swaps(&modeinfo->hSyncStart, n);
-    swaps(&modeinfo->hSyncEnd, n);
-    swaps(&modeinfo->hTotal, n);
-    swaps(&modeinfo->vSyncStart, n);
-    swaps(&modeinfo->vSyncEnd, n);
-    swaps(&modeinfo->vTotal, n);
-    swaps(&modeinfo->nameLength, n);
-    swapl(&modeinfo->modeFlags, n);
+    swapl(&modeinfo->id);
+    swaps(&modeinfo->width);
+    swaps(&modeinfo->height);
+    swapl(&modeinfo->dotClock);
+    swaps(&modeinfo->hSyncStart);
+    swaps(&modeinfo->hSyncEnd);
+    swaps(&modeinfo->hTotal);
+    swaps(&modeinfo->vSyncStart);
+    swaps(&modeinfo->vSyncEnd);
+    swaps(&modeinfo->vTotal);
+    swaps(&modeinfo->nameLength);
+    swapl(&modeinfo->modeFlags);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRDestroyMode(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRDestroyModeReq);
 
     REQUEST_SIZE_MATCH(xRRDestroyModeReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->mode, n);
+    swaps(&stuff->length);
+    swapl(&stuff->mode);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRAddOutputMode(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRAddOutputModeReq);
 
     REQUEST_SIZE_MATCH(xRRAddOutputModeReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->output, n);
-    swapl(&stuff->mode, n);
+    swaps(&stuff->length);
+    swapl(&stuff->output);
+    swapl(&stuff->mode);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRDeleteOutputMode(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRDeleteOutputModeReq);
 
     REQUEST_SIZE_MATCH(xRRDeleteOutputModeReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->output, n);
-    swapl(&stuff->mode, n);
+    swaps(&stuff->length);
+    swapl(&stuff->output);
+    swapl(&stuff->mode);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRGetCrtcInfo(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRGetCrtcInfoReq);
 
     REQUEST_SIZE_MATCH(xRRGetCrtcInfoReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->crtc, n);
-    swapl(&stuff->configTimestamp, n);
+    swaps(&stuff->length);
+    swapl(&stuff->crtc);
+    swapl(&stuff->configTimestamp);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRSetCrtcConfig(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRSetCrtcConfigReq);
 
     REQUEST_AT_LEAST_SIZE(xRRSetCrtcConfigReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->crtc, n);
-    swapl(&stuff->timestamp, n);
-    swapl(&stuff->configTimestamp, n);
-    swaps(&stuff->x, n);
-    swaps(&stuff->y, n);
-    swapl(&stuff->mode, n);
-    swaps(&stuff->rotation, n);
+    swaps(&stuff->length);
+    swapl(&stuff->crtc);
+    swapl(&stuff->timestamp);
+    swapl(&stuff->configTimestamp);
+    swaps(&stuff->x);
+    swaps(&stuff->y);
+    swapl(&stuff->mode);
+    swaps(&stuff->rotation);
     SwapRestL(stuff);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
@@ -352,40 +312,34 @@ SProcRRSetCrtcConfig(ClientPtr client)
 static int
 SProcRRGetCrtcGammaSize(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRGetCrtcGammaSizeReq);
 
     REQUEST_SIZE_MATCH(xRRGetCrtcGammaSizeReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->crtc, n);
+    swaps(&stuff->length);
+    swapl(&stuff->crtc);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRGetCrtcGamma(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRGetCrtcGammaReq);
 
     REQUEST_SIZE_MATCH(xRRGetCrtcGammaReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->crtc, n);
+    swaps(&stuff->length);
+    swapl(&stuff->crtc);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRSetCrtcGamma(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRSetCrtcGammaReq);
 
     REQUEST_AT_LEAST_SIZE(xRRSetCrtcGammaReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->crtc, n);
-    swaps(&stuff->size, n);
+    swaps(&stuff->length);
+    swapl(&stuff->crtc);
+    swaps(&stuff->size);
     SwapRestS(stuff);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
@@ -396,16 +350,15 @@ SProcRRSetCrtcTransform(ClientPtr client)
     int nparams;
     char *filter;
     CARD32 *params;
-    int n;
 
     REQUEST(xRRSetCrtcTransformReq);
 
     REQUEST_AT_LEAST_SIZE(xRRSetCrtcTransformReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->crtc, n);
+    swaps(&stuff->length);
+    swapl(&stuff->crtc);
     SwapLongs((CARD32 *) &stuff->transform,
               bytes_to_int32(sizeof(xRenderTransform)));
-    swaps(&stuff->nbytesFilter, n);
+    swaps(&stuff->nbytesFilter);
     filter = (char *) (stuff + 1);
     params = (CARD32 *) (filter + pad_to_int32(stuff->nbytesFilter));
     nparams = ((CARD32 *) stuff + client->req_len) - params;
@@ -419,177 +372,153 @@ SProcRRSetCrtcTransform(ClientPtr client)
 static int
 SProcRRGetCrtcTransform(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRGetCrtcTransformReq);
 
     REQUEST_SIZE_MATCH(xRRGetCrtcTransformReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->crtc, n);
+    swaps(&stuff->length);
+    swapl(&stuff->crtc);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRGetPanning(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRGetPanningReq);
 
     REQUEST_SIZE_MATCH(xRRGetPanningReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->crtc, n);
+    swaps(&stuff->length);
+    swapl(&stuff->crtc);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRSetPanning(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRSetPanningReq);
 
     REQUEST_SIZE_MATCH(xRRSetPanningReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->crtc, n);
-    swapl(&stuff->timestamp, n);
-    swaps(&stuff->left, n);
-    swaps(&stuff->top, n);
-    swaps(&stuff->width, n);
-    swaps(&stuff->height, n);
-    swaps(&stuff->track_left, n);
-    swaps(&stuff->track_top, n);
-    swaps(&stuff->track_width, n);
-    swaps(&stuff->track_height, n);
-    swaps(&stuff->border_left, n);
-    swaps(&stuff->border_top, n);
-    swaps(&stuff->border_right, n);
-    swaps(&stuff->border_bottom, n);
+    swaps(&stuff->length);
+    swapl(&stuff->crtc);
+    swapl(&stuff->timestamp);
+    swaps(&stuff->left);
+    swaps(&stuff->top);
+    swaps(&stuff->width);
+    swaps(&stuff->height);
+    swaps(&stuff->track_left);
+    swaps(&stuff->track_top);
+    swaps(&stuff->track_width);
+    swaps(&stuff->track_height);
+    swaps(&stuff->border_left);
+    swaps(&stuff->border_top);
+    swaps(&stuff->border_right);
+    swaps(&stuff->border_bottom);
     return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRSetOutputPrimary(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRSetOutputPrimaryReq);
 
     REQUEST_SIZE_MATCH(xRRSetOutputPrimaryReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
-    swapl(&stuff->output, n);
+    swaps(&stuff->length);
+    swapl(&stuff->window);
+    swapl(&stuff->output);
     return ProcRandrVector[stuff->randrReqType] (client);
 }
 
 static int
 SProcRRGetOutputPrimary(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRGetOutputPrimaryReq);
 
     REQUEST_SIZE_MATCH(xRRGetOutputPrimaryReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
+    swaps(&stuff->length);
+    swapl(&stuff->window);
     return ProcRandrVector[stuff->randrReqType] (client);
 }
 
 static int
 SProcRRGetProviders(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRGetProvidersReq);
 
     REQUEST_SIZE_MATCH(xRRGetProvidersReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
+    swaps(&stuff->length);
+    swapl(&stuff->window);
     return ProcRandrVector[stuff->randrReqType] (client);
 }
 
 static int
 SProcRRGetProviderInfo(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRGetProviderInfoReq);
 
     REQUEST_SIZE_MATCH(xRRGetProviderInfoReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->provider, n);
-    swapl(&stuff->configTimestamp, n);
+    swaps(&stuff->length);
+    swapl(&stuff->provider);
+    swapl(&stuff->configTimestamp);
     return ProcRandrVector[stuff->randrReqType] (client);
 }
 
 static int
 SProcRRSetProviderOffloadSink(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRSetProviderOffloadSinkReq);
 
     REQUEST_SIZE_MATCH(xRRSetProviderOffloadSinkReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->provider, n);
-    swapl(&stuff->sink_provider, n);
-    swapl(&stuff->configTimestamp, n);
+    swaps(&stuff->length);
+    swapl(&stuff->provider);
+    swapl(&stuff->sink_provider);
+    swapl(&stuff->configTimestamp);
     return ProcRandrVector[stuff->randrReqType] (client);
 }
 
 static int
 SProcRRSetProviderOutputSource(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRSetProviderOutputSourceReq);
 
     REQUEST_SIZE_MATCH(xRRSetProviderOutputSourceReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->provider, n);
-    swapl(&stuff->source_provider, n);
-    swapl(&stuff->configTimestamp, n);
+    swaps(&stuff->length);
+    swapl(&stuff->provider);
+    swapl(&stuff->source_provider);
+    swapl(&stuff->configTimestamp);
     return ProcRandrVector[stuff->randrReqType] (client);
 }
 
 static int
 SProcRRListProviderProperties(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRListProviderPropertiesReq);
 
     REQUEST_SIZE_MATCH(xRRListProviderPropertiesReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->provider, n);
+    swaps(&stuff->length);
+    swapl(&stuff->provider);
     return ProcRandrVector[stuff->randrReqType] (client);
 }
 
 static int
 SProcRRQueryProviderProperty(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRQueryProviderPropertyReq);
 
     REQUEST_SIZE_MATCH(xRRQueryProviderPropertyReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->provider, n);
-    swapl(&stuff->property, n);
+    swaps(&stuff->length);
+    swapl(&stuff->provider);
+    swapl(&stuff->property);
     return ProcRandrVector[stuff->randrReqType] (client);
 }
 
 static int
 SProcRRConfigureProviderProperty(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRConfigureProviderPropertyReq);
 
     REQUEST_AT_LEAST_SIZE(xRRConfigureProviderPropertyReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->provider, n);
-    swapl(&stuff->property, n);
+    swaps(&stuff->length);
+    swapl(&stuff->provider);
+    swapl(&stuff->property);
     /* TODO: no way to specify format? */
     SwapRestL(stuff);
     return ProcRandrVector[stuff->randrReqType] (client);
@@ -598,16 +527,14 @@ SProcRRConfigureProviderProperty(ClientPtr client)
 static int
 SProcRRChangeProviderProperty(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRChangeProviderPropertyReq);
 
     REQUEST_AT_LEAST_SIZE(xRRChangeProviderPropertyReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->provider, n);
-    swapl(&stuff->property, n);
-    swapl(&stuff->type, n);
-    swapl(&stuff->nUnits, n);
+    swaps(&stuff->length);
+    swapl(&stuff->provider);
+    swapl(&stuff->property);
+    swapl(&stuff->type);
+    swapl(&stuff->nUnits);
     switch (stuff->format) {
     case 8:
         break;
@@ -624,63 +551,55 @@ SProcRRChangeProviderProperty(ClientPtr client)
 static int
 SProcRRDeleteProviderProperty(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRDeleteProviderPropertyReq);
 
     REQUEST_SIZE_MATCH(xRRDeleteProviderPropertyReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->provider, n);
-    swapl(&stuff->property, n);
+    swaps(&stuff->length);
+    swapl(&stuff->provider);
+    swapl(&stuff->property);
     return ProcRandrVector[stuff->randrReqType] (client);
 }
 
 static int
 SProcRRGetProviderProperty(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRGetProviderPropertyReq);
 
     REQUEST_SIZE_MATCH(xRRGetProviderPropertyReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->provider, n);
-    swapl(&stuff->property, n);
-    swapl(&stuff->type, n);
-    swapl(&stuff->longOffset, n);
-    swapl(&stuff->longLength, n);
+    swaps(&stuff->length);
+    swapl(&stuff->provider);
+    swapl(&stuff->property);
+    swapl(&stuff->type);
+    swapl(&stuff->longOffset);
+    swapl(&stuff->longLength);
     return ProcRandrVector[stuff->randrReqType] (client);
 }
 
 static int
 SProcRRGetMonitors(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRGetMonitorsReq);
 
     REQUEST_SIZE_MATCH(xRRGetMonitorsReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
+    swaps(&stuff->length);
+    swapl(&stuff->window);
     return ProcRandrVector[stuff->randrReqType] (client);
 }
 
 static int
 SProcRRSetMonitor(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRSetMonitorReq);
 
     REQUEST_AT_LEAST_SIZE(xRRGetMonitorsReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
-    swapl(&stuff->monitor.name, n);
-    swaps(&stuff->monitor.noutput, n);
-    swaps(&stuff->monitor.x, n);
-    swaps(&stuff->monitor.y, n);
-    swaps(&stuff->monitor.width, n);
-    swaps(&stuff->monitor.height, n);
+    swaps(&stuff->length);
+    swapl(&stuff->window);
+    swapl(&stuff->monitor.name);
+    swaps(&stuff->monitor.noutput);
+    swaps(&stuff->monitor.x);
+    swaps(&stuff->monitor.y);
+    swaps(&stuff->monitor.width);
+    swaps(&stuff->monitor.height);
     SwapRestL(stuff);
     return ProcRandrVector[stuff->randrReqType] (client);
 }
@@ -688,14 +607,12 @@ SProcRRSetMonitor(ClientPtr client)
 static int
 SProcRRDeleteMonitor(ClientPtr client)
 {
-    int n;
-
     REQUEST(xRRDeleteMonitorReq);
 
     REQUEST_SIZE_MATCH(xRRDeleteMonitorReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
-    swapl(&stuff->name, n);
+    swaps(&stuff->length);
+    swapl(&stuff->window);
+    swapl(&stuff->name);
     return ProcRandrVector[stuff->randrReqType] (client);
 }
 
diff --git a/nx-X11/programs/Xserver/randr/rrxinerama.c b/nx-X11/programs/Xserver/randr/rrxinerama.c
index 5332ac01b..bd6340296 100644
--- a/nx-X11/programs/Xserver/randr/rrxinerama.c
+++ b/nx-X11/programs/Xserver/randr/rrxinerama.c
@@ -108,8 +108,6 @@ extern Bool noRRXineramaExtension;
 int
 ProcRRXineramaQueryVersion(ClientPtr client)
 {
-    int n;
-
     xPanoramiXQueryVersionReply rep = {
         .type = X_Reply,
         .sequenceNumber = client->sequence,
@@ -120,10 +118,10 @@ ProcRRXineramaQueryVersion(ClientPtr client)
 
     REQUEST_SIZE_MATCH(xPanoramiXQueryVersionReq);
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swaps(&rep.majorVersion, n);
-        swaps(&rep.minorVersion, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swaps(&rep.majorVersion);
+        swaps(&rep.minorVersion);
     }
     WriteToClient(client, sizeof(xPanoramiXQueryVersionReply), (char *) &rep);
     return Success;
@@ -139,7 +137,6 @@ ProcRRXineramaGetState(ClientPtr client)
     ScreenPtr pScreen;
     rrScrPrivPtr pScrPriv;
     Bool active = FALSE;
-    int n;
 
     REQUEST_SIZE_MATCH(xPanoramiXGetStateReq);
 #ifndef NXAGENT_SERVER
@@ -167,9 +164,9 @@ ProcRRXineramaGetState(ClientPtr client)
         .window = stuff->window
     };
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.window, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.window);
     }
     WriteToClient(client, sizeof(xPanoramiXGetStateReply), (char *) &rep);
     return Success;
@@ -194,7 +191,6 @@ ProcRRXineramaGetScreenCount(ClientPtr client)
     WindowPtr pWin;
     xPanoramiXGetScreenCountReply rep;
     register int rc;
-    int n;
 
     REQUEST_SIZE_MATCH(xPanoramiXGetScreenCountReq);
 
@@ -215,9 +211,9 @@ ProcRRXineramaGetScreenCount(ClientPtr client)
         .window = stuff->window
     };
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.window, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.window);
     }
     WriteToClient(client, sizeof(xPanoramiXGetScreenCountReply), (char *) &rep);
     return Success;
@@ -231,7 +227,6 @@ ProcRRXineramaGetScreenSize(ClientPtr client)
     ScreenPtr pScreen;
     xPanoramiXGetScreenSizeReply rep;
     register int rc;
-    int n;
 
     REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
 #ifndef NXAGENT_SERVER
@@ -257,12 +252,12 @@ ProcRRXineramaGetScreenSize(ClientPtr client)
         .screen = stuff->screen
     };
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.width, n);
-        swapl(&rep.height, n);
-        swapl(&rep.window, n);
-        swapl(&rep.screen, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.width);
+        swapl(&rep.height);
+        swapl(&rep.window);
+        swapl(&rep.screen);
     }
     WriteToClient(client, sizeof(xPanoramiXGetScreenSizeReply), (char *) &rep);
     return Success;
@@ -272,7 +267,6 @@ int
 ProcRRXineramaIsActive(ClientPtr client)
 {
     xXineramaIsActiveReply rep;
-    int n;
 
     REQUEST_SIZE_MATCH(xXineramaIsActiveReq);
 
@@ -283,9 +277,9 @@ ProcRRXineramaIsActive(ClientPtr client)
         .state = RRXineramaScreenActive(screenInfo.screens[RR_XINERAMA_SCREEN])
     };
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.state, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.state);
     }
     WriteToClient(client, sizeof(xXineramaIsActiveReply), (char *) &rep);
     return Success;
@@ -312,7 +306,6 @@ ProcRRXineramaQueryScreens(ClientPtr client)
     int m;
     RRMonitorPtr monitors = NULL;
     int nmonitors = 0;
-    int n;
 
     REQUEST_SIZE_MATCH(xXineramaQueryScreensReq);
 
@@ -329,9 +322,9 @@ ProcRRXineramaQueryScreens(ClientPtr client)
         .number = nmonitors
     };
     if (client->swapped) {
-        swaps(&rep.sequenceNumber, n);
-        swapl(&rep.length, n);
-        swapl(&rep.number, n);
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.number);
     }
     WriteToClient(client, sizeof(xXineramaQueryScreensReply), (char *) &rep);
 
@@ -370,10 +363,8 @@ ProcRRXineramaDispatch(ClientPtr client)
 static int
 SProcRRXineramaQueryVersion(ClientPtr client)
 {
-    int n;
-
     REQUEST(xPanoramiXQueryVersionReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xPanoramiXQueryVersionReq);
     return ProcRRXineramaQueryVersion(client);
 }
@@ -381,47 +372,39 @@ SProcRRXineramaQueryVersion(ClientPtr client)
 static int
 SProcRRXineramaGetState(ClientPtr client)
 {
-    int n;
-
     REQUEST(xPanoramiXGetStateReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xPanoramiXGetStateReq);
-    swapl(&stuff->window, n);
+    swapl(&stuff->window);
     return ProcRRXineramaGetState(client);
 }
 
 static int
 SProcRRXineramaGetScreenCount(ClientPtr client)
 {
-    int n;
-
     REQUEST(xPanoramiXGetScreenCountReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xPanoramiXGetScreenCountReq);
-    swapl(&stuff->window, n);
+    swapl(&stuff->window);
     return ProcRRXineramaGetScreenCount(client);
 }
 
 static int
 SProcRRXineramaGetScreenSize(ClientPtr client)
 {
-    int n;
-
     REQUEST(xPanoramiXGetScreenSizeReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
-    swapl(&stuff->window, n);
-    swapl(&stuff->screen, n);
+    swapl(&stuff->window);
+    swapl(&stuff->screen);
     return ProcRRXineramaGetScreenSize(client);
 }
 
 static int
 SProcRRXineramaIsActive(ClientPtr client)
 {
-    int n;
-
     REQUEST(xXineramaIsActiveReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXineramaIsActiveReq);
     return ProcRRXineramaIsActive(client);
 }
@@ -429,10 +412,8 @@ SProcRRXineramaIsActive(ClientPtr client)
 static int
 SProcRRXineramaQueryScreens(ClientPtr client)
 {
-    int n;
-
     REQUEST(xXineramaQueryScreensReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXineramaQueryScreensReq);
     return ProcRRXineramaQueryScreens(client);
 }
diff --git a/nx-X11/programs/Xserver/record/record.c b/nx-X11/programs/Xserver/record/record.c
index 410920d02..9d549bb5c 100644
--- a/nx-X11/programs/Xserver/record/record.c
+++ b/nx-X11/programs/Xserver/record/record.c
@@ -297,7 +297,6 @@ RecordAProtocolElement(RecordContextPtr pContext, ClientPtr pClient,
     CARD32 elemHeaderData[2];
     int numElemHeaders = 0;
     Bool recordingClientSwapped = pContext->pRecordingClient->swapped;
-    int n;
     CARD32 serverTime = 0;
     Bool gotServerTime = FALSE;
     int replylen;
@@ -341,11 +340,11 @@ RecordAProtocolElement(RecordContextPtr pContext, ClientPtr pClient,
 
 	    if (recordingClientSwapped)
 	    {
-		swaps(&pRep->sequenceNumber, n);
-		swapl(&pRep->length, n);
-		swapl(&pRep->idBase, n);
-		swapl(&pRep->serverTime, n);
-		swapl(&pRep->recordedSequenceNumber, n);
+		swaps(&pRep->sequenceNumber);
+		swapl(&pRep->length);
+		swapl(&pRep->idBase);
+		swapl(&pRep->serverTime);
+		swapl(&pRep->recordedSequenceNumber);
 	    }
 	    pContext->numBufBytes = SIZEOF(xRecordEnableContextReply);
 	}
@@ -363,7 +362,7 @@ RecordAProtocolElement(RecordContextPtr pContext, ClientPtr pClient,
 	    else
 		elemHeaderData[numElemHeaders] = GetTimeInMillis();
 	    if (recordingClientSwapped)
-		swapl(&elemHeaderData[numElemHeaders], n);
+		swapl(&elemHeaderData[numElemHeaders]);
 	    numElemHeaders++;
 	}
 
@@ -373,16 +372,16 @@ RecordAProtocolElement(RecordContextPtr pContext, ClientPtr pClient,
 	{
 	    elemHeaderData[numElemHeaders] = pClient->sequence;
 	    if (recordingClientSwapped)
-		swapl(&elemHeaderData[numElemHeaders], n);
+		swapl(&elemHeaderData[numElemHeaders]);
 	    numElemHeaders++;
 	}
 
 	/* adjust reply length */
 
 	replylen = pRep->length;
-	if (recordingClientSwapped) swapl(&replylen, n);
+	if (recordingClientSwapped) swapl(&replylen);
 	replylen += numElemHeaders + (datalen >> 2) + (futurelen >> 2);
-	if (recordingClientSwapped) swapl(&replylen, n);
+	if (recordingClientSwapped) swapl(&replylen);
 	pRep->length = replylen;
     } /* end if not continued reply */
 
@@ -477,7 +476,6 @@ RecordABigRequest(pContext, client, stuff)
     xReq *stuff;
 {
     CARD32 bigLength;
-    char n;
     int bytesLeft;
 
     /* note: client->req_len has been frobbed by ReadRequestFromClient
@@ -494,7 +492,7 @@ RecordABigRequest(pContext, client, stuff)
     /* reinsert the extended length field that was squished out */
     bigLength = client->req_len + (sizeof(bigLength) >> 2);
     if (client->swapped)
-	swapl(&bigLength, n);
+	swapl(&bigLength);
     RecordAProtocolElement(pContext, client, XRecordFromClient,
 		(void *)&bigLength, sizeof(bigLength), /* continuation */ -1);
     bytesLeft -= sizeof(bigLength);
@@ -1998,7 +1996,6 @@ ProcRecordQueryVersion(client)
 {
     /* REQUEST(xRecordQueryVersionReq); */
     xRecordQueryVersionReply 	rep;
-    int 		n;
 
     REQUEST_SIZE_MATCH(xRecordQueryVersionReq);
     rep.type        	= X_Reply;
@@ -2008,9 +2005,9 @@ ProcRecordQueryVersion(client)
     rep.minorVersion  	= SERVER_RECORD_MINOR_VERSION;
     if(client->swapped)
     {
-    	swaps(&rep.sequenceNumber, n);
-	swaps(&rep.majorVersion, n);
-	swaps(&rep.minorVersion, n);
+	swaps(&rep.sequenceNumber);
+	swaps(&rep.majorVersion);
+	swaps(&rep.minorVersion);
     }
     (void)WriteToClient(client, sizeof(xRecordQueryVersionReply),
 			(char *)&rep);
@@ -2320,13 +2317,12 @@ RecordSwapRanges(pRanges, nRanges)
     int nRanges;
 {
     int i;
-    register char n;
     for (i = 0; i < nRanges; i++, pRanges++)
     {
-	swaps(&pRanges->extRequestsMinorFirst, n);
-	swaps(&pRanges->extRequestsMinorLast, n);
-	swaps(&pRanges->extRepliesMinorFirst, n);
-	swaps(&pRanges->extRepliesMinorLast, n);
+	swaps(&pRanges->extRequestsMinorFirst);
+	swaps(&pRanges->extRequestsMinorLast);
+	swaps(&pRanges->extRepliesMinorFirst);
+	swaps(&pRanges->extRepliesMinorLast);
     }
 } /* RecordSwapRanges */
 
@@ -2338,7 +2334,6 @@ ProcRecordGetContext(client)
     RecordContextPtr pContext;
     REQUEST(xRecordGetContextReq);
     xRecordGetContextReply rep;
-    int n;
     RecordClientsAndProtocolPtr pRCAP;
     int nRCAPs = 0;
     GetContextRangeInfoPtr pRangeInfo;
@@ -2437,9 +2432,9 @@ ProcRecordGetContext(client)
     rep.elementHeader = pContext->elemHeaders;
     if(client->swapped)
     {
-    	swaps(&rep.sequenceNumber, n);
-    	swapl(&rep.length, n);
-    	swapl(&rep.nClients, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swapl(&rep.nClients);
     }
     (void)WriteToClient(client, sizeof(xRecordGetContextReply),
 			(char *)&rep);
@@ -2454,13 +2449,13 @@ ProcRecordGetContext(client)
 	rci.nRanges = pri->nRanges;
 	if (client->swapped)
 	{
-	    swapl(&rci.nRanges, n);
+	    swapl(&rci.nRanges);
 	    RecordSwapRanges(pri->pRanges, pri->nRanges);
 	}
 	for (i = 0; i < pRCAP->numClients; i++)
 	{
 	    rci.clientResource = pRCAP->pClientIDs[i];
-	    if (client->swapped) swapl(&rci.clientResource, n);
+	    if (client->swapped) swapl(&rci.clientResource);
 	    WriteToClient(client, sizeof(xRecordClientInfo), (char *)&rci);
 	    WriteToClient(client, sizeof(xRecordRange) * pri->nRanges,
 			  (char *)pri->pRanges);
@@ -2712,12 +2707,11 @@ SProcRecordQueryVersion(client)
     ClientPtr client;
 {
     REQUEST(xRecordQueryVersionReq);
-    register char 	n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xRecordQueryVersionReq);
-    swaps(&stuff->majorVersion, n);
-    swaps(&stuff->minorVersion,n);
+    swaps(&stuff->majorVersion);
+    swaps(&stuff->minorVersion);
     return ProcRecordQueryVersion(client);
 } /* SProcRecordQueryVersion */
 
@@ -2725,19 +2719,18 @@ SProcRecordQueryVersion(client)
 static int
 SwapCreateRegister(xRecordRegisterClientsReq *stuff)
 {
-    register char n;
     int i;
     XID *pClientID;
 
-    swapl(&stuff->context, n);
-    swapl(&stuff->nClients, n);
-    swapl(&stuff->nRanges, n);
+    swapl(&stuff->context);
+    swapl(&stuff->nClients);
+    swapl(&stuff->nRanges);
     pClientID = (XID *)&stuff[1];
     if (stuff->nClients > stuff->length - (sz_xRecordRegisterClientsReq >> 2))
 	return BadLength;
     for (i = 0; i < stuff->nClients; i++, pClientID++)
     {
-	swapl(pClientID, n);
+	swapl(pClientID);
     }
     if (stuff->nRanges > stuff->length - (sz_xRecordRegisterClientsReq >> 2)
 	- stuff->nClients)
@@ -2753,9 +2746,8 @@ SProcRecordCreateContext(client)
 {
     REQUEST(xRecordCreateContextReq);
     int			status;
-    register char 	n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xRecordCreateContextReq);
     if ((status = SwapCreateRegister((void *)stuff)) != Success)
 	return status;
@@ -2769,9 +2761,8 @@ SProcRecordRegisterClients(client)
 {
     REQUEST(xRecordRegisterClientsReq);
     int			status;
-    register char 	n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xRecordRegisterClientsReq);
     if ((status = SwapCreateRegister((void *)stuff)) != Success)
 	return status;
@@ -2784,12 +2775,11 @@ SProcRecordUnregisterClients(client)
     ClientPtr client;
 {
     REQUEST(xRecordUnregisterClientsReq);
-    register char 	n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xRecordUnregisterClientsReq);
-    swapl(&stuff->context, n);
-    swapl(&stuff->nClients, n);
+    swapl(&stuff->context);
+    swapl(&stuff->nClients);
     SwapRestL(stuff);
     return ProcRecordUnregisterClients(client);
 } /* SProcRecordUnregisterClients */
@@ -2800,11 +2790,10 @@ SProcRecordGetContext(client)
     ClientPtr client;
 {
     REQUEST(xRecordGetContextReq);
-    register char 	n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xRecordGetContextReq);
-    swapl(&stuff->context, n);
+    swapl(&stuff->context);
     return ProcRecordGetContext(client);
 } /* SProcRecordGetContext */
 
@@ -2813,11 +2802,10 @@ SProcRecordEnableContext(client)
     ClientPtr client;
 {
     REQUEST(xRecordEnableContextReq);
-    register char 	n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xRecordEnableContextReq);
-    swapl(&stuff->context, n);
+    swapl(&stuff->context);
     return ProcRecordEnableContext(client);
 } /* SProcRecordEnableContext */
 
@@ -2827,11 +2815,10 @@ SProcRecordDisableContext(client)
     ClientPtr client;
 {
     REQUEST(xRecordDisableContextReq);
-    register char 	n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xRecordDisableContextReq);
-    swapl(&stuff->context, n);
+    swapl(&stuff->context);
     return ProcRecordDisableContext(client);
 } /* SProcRecordDisableContext */
 
@@ -2841,11 +2828,10 @@ SProcRecordFreeContext(client)
     ClientPtr client;
 {
     REQUEST(xRecordFreeContextReq);
-    register char 	n;
 
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xRecordFreeContextReq);
-    swapl(&stuff->context, n);
+    swapl(&stuff->context);
     return ProcRecordFreeContext(client);
 } /* SProcRecordFreeContext */
 
diff --git a/nx-X11/programs/Xserver/render/render.c b/nx-X11/programs/Xserver/render/render.c
index c6cb7bce7..b97c63775 100644
--- a/nx-X11/programs/Xserver/render/render.c
+++ b/nx-X11/programs/Xserver/render/render.c
@@ -283,7 +283,7 @@ ProcRenderQueryVersion (ClientPtr client)
 {
     RenderClientPtr pRenderClient = GetRenderClient (client);
     xRenderQueryVersionReply rep;
-    register int n;
+
     REQUEST(xRenderQueryVersionReq);
 
     REQUEST_SIZE_MATCH(xRenderQueryVersionReq);
@@ -298,10 +298,10 @@ ProcRenderQueryVersion (ClientPtr client)
     rep.majorVersion = SERVER_RENDER_MAJOR_VERSION;
     rep.minorVersion = SERVER_RENDER_MINOR_VERSION;
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-    	swapl(&rep.length, n);
-	swapl(&rep.majorVersion, n);
-	swapl(&rep.minorVersion, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swapl(&rep.majorVersion);
+	swapl(&rep.minorVersion);
     }
     WriteToClient(client, sizeof(xRenderQueryVersionReply), (char *)&rep);
     return (client->noClientException);
@@ -456,16 +456,16 @@ ProcRenderQueryPictFormats (ClientPtr client)
 		    pictForm->colormap = None;
 		if (client->swapped)
 		{
-		    swapl (&pictForm->id, n);
-		    swaps (&pictForm->direct.red, n);
-		    swaps (&pictForm->direct.redMask, n);
-		    swaps (&pictForm->direct.green, n);
-		    swaps (&pictForm->direct.greenMask, n);
-		    swaps (&pictForm->direct.blue, n);
-		    swaps (&pictForm->direct.blueMask, n);
-		    swaps (&pictForm->direct.alpha, n);
-		    swaps (&pictForm->direct.alphaMask, n);
-		    swapl (&pictForm->colormap, n);
+		    swapl (&pictForm->id);
+		    swaps (&pictForm->direct.red);
+		    swaps (&pictForm->direct.redMask);
+		    swaps (&pictForm->direct.green);
+		    swaps (&pictForm->direct.greenMask);
+		    swaps (&pictForm->direct.blue);
+		    swaps (&pictForm->direct.blueMask);
+		    swaps (&pictForm->direct.alpha);
+		    swaps (&pictForm->direct.alphaMask);
+		    swapl (&pictForm->colormap);
 		}
 		pictForm++;
 	    }
@@ -495,8 +495,8 @@ ProcRenderQueryPictFormats (ClientPtr client)
 		    pictVisual->format = pFormat->id;
 		    if (client->swapped)
 		    {
-			swapl (&pictVisual->visual, n);
-			swapl (&pictVisual->format, n);
+			swapl (&pictVisual->visual);
+			swapl (&pictVisual->format);
 		    }
 		    pictVisual++;
 		    nvisual++;
@@ -506,7 +506,7 @@ ProcRenderQueryPictFormats (ClientPtr client)
 	    pictDepth->nPictVisuals = nvisual;
 	    if (client->swapped)
 	    {
-		swaps (&pictDepth->nPictVisuals, n);
+		swaps (&pictDepth->nPictVisuals);
 	    }
 	    ndepth++;
 	    pictDepth = (xPictDepth *) pictVisual;
@@ -519,8 +519,8 @@ ProcRenderQueryPictFormats (ClientPtr client)
 	    pictScreen->fallback = 0;
 	if (client->swapped)
 	{
-	    swapl (&pictScreen->nDepth, n);
-	    swapl (&pictScreen->fallback, n);
+	    swapl (&pictScreen->nDepth);
+	    swapl (&pictScreen->fallback);
 	}
 	pictScreen = (xPictScreen *) pictDepth;
     }
@@ -536,20 +536,20 @@ ProcRenderQueryPictFormats (ClientPtr client)
 	    *pictSubpixel = SubPixelUnknown;
 	if (client->swapped)
 	{
-	    swapl (pictSubpixel, n);
+	    swapl (pictSubpixel);
 	}
 	++pictSubpixel;
     }
     
     if (client->swapped)
     {
-	swaps (&reply->sequenceNumber, n);
-	swapl (&reply->length, n);
-	swapl (&reply->numFormats, n);
-	swapl (&reply->numScreens, n);
-	swapl (&reply->numDepths, n);
-	swapl (&reply->numVisuals, n);
-	swapl (&reply->numSubpixel, n);
+	swaps (&reply->sequenceNumber);
+	swapl (&reply->length);
+	swapl (&reply->numFormats);
+	swapl (&reply->numScreens);
+	swapl (&reply->numDepths);
+	swapl (&reply->numVisuals);
+	swapl (&reply->numSubpixel);
     }
     WriteToClient(client, rlength, (char *) reply);
     free (reply);
@@ -563,7 +563,7 @@ ProcRenderQueryPictIndexValues (ClientPtr client)
     PictFormatPtr   pFormat;
     int		    num;
     int		    rlength;
-    int		    i, n;
+    int		    i;
     REQUEST(xRenderQueryPictIndexValuesReq);
     xRenderQueryPictIndexValuesReply *reply;
     xIndexValue	    *values;
@@ -605,15 +605,15 @@ ProcRenderQueryPictIndexValues (ClientPtr client)
     {
 	for (i = 0; i < num; i++)
 	{
-	    swapl (&values[i].pixel, n);
-	    swaps (&values[i].red, n);
-	    swaps (&values[i].green, n);
-	    swaps (&values[i].blue, n);
-	    swaps (&values[i].alpha, n);
+	    swapl (&values[i].pixel);
+	    swaps (&values[i].red);
+	    swaps (&values[i].green);
+	    swaps (&values[i].blue);
+	    swaps (&values[i].alpha);
 	}
-	swaps (&reply->sequenceNumber, n);
-	swapl (&reply->length, n);
-	swapl (&reply->numIndexValues, n);
+	swaps (&reply->sequenceNumber);
+	swapl (&reply->length);
+	swapl (&reply->numIndexValues);
     }
 
     WriteToClient(client, rlength, (char *) reply);
@@ -1807,16 +1807,14 @@ ProcRenderQueryFilters (ClientPtr client)
 
     if (client->swapped)
     {
-	register int n;
-
 	for (i = 0; i < reply->numAliases; i++)
 	{
-	    swaps (&aliases[i], n);
+	    swaps (&aliases[i]);
 	}
-    	swaps(&reply->sequenceNumber, n);
-    	swapl(&reply->length, n);
-	swapl(&reply->numAliases, n);
-	swapl(&reply->numFilters, n);
+	swaps(&reply->sequenceNumber);
+	swapl(&reply->length);
+	swapl(&reply->numAliases);
+	swapl(&reply->numFilters);
     }
     WriteToClient(client, total_bytes, (char *) reply);
     free (reply);
@@ -2039,34 +2037,31 @@ ProcRenderDispatch (ClientPtr client)
 static int
 SProcRenderQueryVersion (ClientPtr client)
 {
-    register int n;
     REQUEST(xRenderQueryVersionReq);
     REQUEST_SIZE_MATCH(xRenderQueryVersionReq);
 
-    swaps(&stuff->length, n);
-    swapl(&stuff->majorVersion, n);
-    swapl(&stuff->minorVersion, n);
+    swaps(&stuff->length);
+    swapl(&stuff->majorVersion);
+    swapl(&stuff->minorVersion);
     return (*ProcRenderVector[stuff->renderReqType])(client);
 }
 
 static int
 SProcRenderQueryPictFormats (ClientPtr client)
 {
-    register int n;
     REQUEST(xRenderQueryPictFormatsReq);
     REQUEST_SIZE_MATCH(xRenderQueryPictFormatsReq);
-    swaps(&stuff->length, n);
+    swaps(&stuff->length);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
 
 static int
 SProcRenderQueryPictIndexValues (ClientPtr client)
 {
-    register int n;
     REQUEST(xRenderQueryPictIndexValuesReq);
     REQUEST_AT_LEAST_SIZE(xRenderQueryPictIndexValuesReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->format, n);
+    swaps(&stuff->length);
+    swapl(&stuff->format);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
 
@@ -2079,14 +2074,13 @@ SProcRenderQueryDithers (ClientPtr client)
 static int
 SProcRenderCreatePicture (ClientPtr client)
 {
-    register int n;
     REQUEST(xRenderCreatePictureReq);
     REQUEST_AT_LEAST_SIZE(xRenderCreatePictureReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->pid, n);
-    swapl(&stuff->drawable, n);
-    swapl(&stuff->format, n);
-    swapl(&stuff->mask, n);
+    swaps(&stuff->length);
+    swapl(&stuff->pid);
+    swapl(&stuff->drawable);
+    swapl(&stuff->format);
+    swapl(&stuff->mask);
     SwapRestL(stuff);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
@@ -2094,12 +2088,11 @@ SProcRenderCreatePicture (ClientPtr client)
 static int
 SProcRenderChangePicture (ClientPtr client)
 {
-    register int n;
     REQUEST(xRenderChangePictureReq);
     REQUEST_AT_LEAST_SIZE(xRenderChangePictureReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->picture, n);
-    swapl(&stuff->mask, n);
+    swaps(&stuff->length);
+    swapl(&stuff->picture);
+    swapl(&stuff->mask);
     SwapRestL(stuff);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
@@ -2107,11 +2100,10 @@ SProcRenderChangePicture (ClientPtr client)
 static int
 SProcRenderSetPictureClipRectangles (ClientPtr client)
 {
-    register int n;
     REQUEST(xRenderSetPictureClipRectanglesReq);
     REQUEST_AT_LEAST_SIZE(xRenderSetPictureClipRectanglesReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->picture, n);
+    swaps(&stuff->length);
+    swapl(&stuff->picture);
     SwapRestS(stuff);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
@@ -2119,68 +2111,64 @@ SProcRenderSetPictureClipRectangles (ClientPtr client)
 static int
 SProcRenderFreePicture (ClientPtr client)
 {
-    register int n;
     REQUEST(xRenderFreePictureReq);
     REQUEST_SIZE_MATCH(xRenderFreePictureReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->picture, n);
+    swaps(&stuff->length);
+    swapl(&stuff->picture);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
 
 static int
 SProcRenderComposite (ClientPtr client)
 {
-    register int n;
     REQUEST(xRenderCompositeReq);
     REQUEST_SIZE_MATCH(xRenderCompositeReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->src, n);
-    swapl(&stuff->mask, n);
-    swapl(&stuff->dst, n);
-    swaps(&stuff->xSrc, n);
-    swaps(&stuff->ySrc, n);
-    swaps(&stuff->xMask, n);
-    swaps(&stuff->yMask, n);
-    swaps(&stuff->xDst, n);
-    swaps(&stuff->yDst, n);
-    swaps(&stuff->width, n);
-    swaps(&stuff->height, n);
+    swaps(&stuff->length);
+    swapl(&stuff->src);
+    swapl(&stuff->mask);
+    swapl(&stuff->dst);
+    swaps(&stuff->xSrc);
+    swaps(&stuff->ySrc);
+    swaps(&stuff->xMask);
+    swaps(&stuff->yMask);
+    swaps(&stuff->xDst);
+    swaps(&stuff->yDst);
+    swaps(&stuff->width);
+    swaps(&stuff->height);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
 
 static int
 SProcRenderScale (ClientPtr client)
 {
-    register int n;
     REQUEST(xRenderScaleReq);
     REQUEST_SIZE_MATCH(xRenderScaleReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->src, n);
-    swapl(&stuff->dst, n);
-    swapl(&stuff->colorScale, n);
-    swapl(&stuff->alphaScale, n);
-    swaps(&stuff->xSrc, n);
-    swaps(&stuff->ySrc, n);
-    swaps(&stuff->xDst, n);
-    swaps(&stuff->yDst, n);
-    swaps(&stuff->width, n);
-    swaps(&stuff->height, n);
+    swaps(&stuff->length);
+    swapl(&stuff->src);
+    swapl(&stuff->dst);
+    swapl(&stuff->colorScale);
+    swapl(&stuff->alphaScale);
+    swaps(&stuff->xSrc);
+    swaps(&stuff->ySrc);
+    swaps(&stuff->xDst);
+    swaps(&stuff->yDst);
+    swaps(&stuff->width);
+    swaps(&stuff->height);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
 
 static int
 SProcRenderTrapezoids (ClientPtr client)
 {
-    register int n;
     REQUEST(xRenderTrapezoidsReq);
 
     REQUEST_AT_LEAST_SIZE(xRenderTrapezoidsReq);
-    swaps (&stuff->length, n);
-    swapl (&stuff->src, n);
-    swapl (&stuff->dst, n);
-    swapl (&stuff->maskFormat, n);
-    swaps (&stuff->xSrc, n);
-    swaps (&stuff->ySrc, n);
+    swaps (&stuff->length);
+    swapl (&stuff->src);
+    swapl (&stuff->dst);
+    swapl (&stuff->maskFormat);
+    swaps (&stuff->xSrc);
+    swaps (&stuff->ySrc);
     SwapRestL(stuff);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
@@ -2188,16 +2176,15 @@ SProcRenderTrapezoids (ClientPtr client)
 static int
 SProcRenderTriangles (ClientPtr client)
 {
-    register int n;
     REQUEST(xRenderTrianglesReq);
 
     REQUEST_AT_LEAST_SIZE(xRenderTrianglesReq);
-    swaps (&stuff->length, n);
-    swapl (&stuff->src, n);
-    swapl (&stuff->dst, n);
-    swapl (&stuff->maskFormat, n);
-    swaps (&stuff->xSrc, n);
-    swaps (&stuff->ySrc, n);
+    swaps (&stuff->length);
+    swapl (&stuff->src);
+    swapl (&stuff->dst);
+    swapl (&stuff->maskFormat);
+    swaps (&stuff->xSrc);
+    swaps (&stuff->ySrc);
     SwapRestL(stuff);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
@@ -2205,16 +2192,15 @@ SProcRenderTriangles (ClientPtr client)
 static int
 SProcRenderTriStrip (ClientPtr client)
 {
-    register int n;
     REQUEST(xRenderTriStripReq);
 
     REQUEST_AT_LEAST_SIZE(xRenderTriStripReq);
-    swaps (&stuff->length, n);
-    swapl (&stuff->src, n);
-    swapl (&stuff->dst, n);
-    swapl (&stuff->maskFormat, n);
-    swaps (&stuff->xSrc, n);
-    swaps (&stuff->ySrc, n);
+    swaps (&stuff->length);
+    swapl (&stuff->src);
+    swapl (&stuff->dst);
+    swapl (&stuff->maskFormat);
+    swaps (&stuff->xSrc);
+    swaps (&stuff->ySrc);
     SwapRestL(stuff);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
@@ -2222,16 +2208,15 @@ SProcRenderTriStrip (ClientPtr client)
 static int
 SProcRenderTriFan (ClientPtr client)
 {
-    register int n;
     REQUEST(xRenderTriFanReq);
 
     REQUEST_AT_LEAST_SIZE(xRenderTriFanReq);
-    swaps (&stuff->length, n);
-    swapl (&stuff->src, n);
-    swapl (&stuff->dst, n);
-    swapl (&stuff->maskFormat, n);
-    swaps (&stuff->xSrc, n);
-    swaps (&stuff->ySrc, n);
+    swaps (&stuff->length);
+    swapl (&stuff->src);
+    swapl (&stuff->dst);
+    swapl (&stuff->maskFormat);
+    swaps (&stuff->xSrc);
+    swaps (&stuff->ySrc);
     SwapRestL(stuff);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
@@ -2257,51 +2242,47 @@ SProcRenderTransform (ClientPtr client)
 static int
 SProcRenderCreateGlyphSet (ClientPtr client)
 {
-    register int n;
     REQUEST(xRenderCreateGlyphSetReq);
     REQUEST_SIZE_MATCH(xRenderCreateGlyphSetReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->gsid, n);
-    swapl(&stuff->format, n);
+    swaps(&stuff->length);
+    swapl(&stuff->gsid);
+    swapl(&stuff->format);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
 
 static int
 SProcRenderReferenceGlyphSet (ClientPtr client)
 {
-    register int n;
     REQUEST(xRenderReferenceGlyphSetReq);
     REQUEST_SIZE_MATCH(xRenderReferenceGlyphSetReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->gsid, n);
-    swapl(&stuff->existing, n);
+    swaps(&stuff->length);
+    swapl(&stuff->gsid);
+    swapl(&stuff->existing);
     return (*ProcRenderVector[stuff->renderReqType])  (client);
 }
 
 static int
 SProcRenderFreeGlyphSet (ClientPtr client)
 {
-    register int n;
     REQUEST(xRenderFreeGlyphSetReq);
     REQUEST_SIZE_MATCH(xRenderFreeGlyphSetReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->glyphset, n);
+    swaps(&stuff->length);
+    swapl(&stuff->glyphset);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
 
 static int
 SProcRenderAddGlyphs (ClientPtr client)
 {
-    register int n;
     register int i;
     CARD32  *gids;
     void    *end;
     xGlyphInfo *gi;
     REQUEST(xRenderAddGlyphsReq);
     REQUEST_AT_LEAST_SIZE(xRenderAddGlyphsReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->glyphset, n);
-    swapl(&stuff->nglyphs, n);
+    swaps(&stuff->length);
+    swapl(&stuff->glyphset);
+    swapl(&stuff->nglyphs);
     if (stuff->nglyphs & 0xe0000000)
 	return BadLength;
     end = (CARD8 *) stuff + (client->req_len << 2);
@@ -2313,13 +2294,13 @@ SProcRenderAddGlyphs (ClientPtr client)
 	return BadLength;
     for (i = 0; i < stuff->nglyphs; i++)
     {
-	swapl (&gids[i], n);
-	swaps (&gi[i].width, n);
-	swaps (&gi[i].height, n);
-	swaps (&gi[i].x, n);
-	swaps (&gi[i].y, n);
-	swaps (&gi[i].xOff, n);
-	swaps (&gi[i].yOff, n);
+	swapl (&gids[i]);
+	swaps (&gi[i].width);
+	swaps (&gi[i].height);
+	swaps (&gi[i].x);
+	swaps (&gi[i].y);
+	swaps (&gi[i].xOff);
+	swaps (&gi[i].yOff);
     }
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
@@ -2333,11 +2314,10 @@ SProcRenderAddGlyphsFromPicture (ClientPtr client)
 static int
 SProcRenderFreeGlyphs (ClientPtr client)
 {
-    register int n;
     REQUEST(xRenderFreeGlyphsReq);
     REQUEST_AT_LEAST_SIZE(xRenderFreeGlyphsReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->glyphset, n);
+    swaps(&stuff->length);
+    swapl(&stuff->glyphset);
     SwapRestL(stuff);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
@@ -2345,7 +2325,6 @@ SProcRenderFreeGlyphs (ClientPtr client)
 static int
 SProcRenderCompositeGlyphs (ClientPtr client)
 {
-    register int n;
     xGlyphElt	*elt;
     CARD8	*buffer;
     CARD8	*end;
@@ -2362,13 +2341,13 @@ SProcRenderCompositeGlyphs (ClientPtr client)
     case X_RenderCompositeGlyphs32: size = 4; break;
     }
 	    
-    swaps(&stuff->length, n);
-    swapl(&stuff->src, n);
-    swapl(&stuff->dst, n);
-    swapl(&stuff->maskFormat, n);
-    swapl(&stuff->glyphset, n);
-    swaps(&stuff->xSrc, n);
-    swaps(&stuff->ySrc, n);
+    swaps(&stuff->length);
+    swapl(&stuff->src);
+    swapl(&stuff->dst);
+    swapl(&stuff->maskFormat);
+    swapl(&stuff->glyphset);
+    swaps(&stuff->xSrc);
+    swaps(&stuff->ySrc);
     buffer = (CARD8 *) (stuff + 1);
     end = (CARD8 *) stuff + (client->req_len << 2);
     while (buffer + sizeof (xGlyphElt) < end)
@@ -2376,13 +2355,13 @@ SProcRenderCompositeGlyphs (ClientPtr client)
 	elt = (xGlyphElt *) buffer;
 	buffer += sizeof (xGlyphElt);
 	
-	swaps (&elt->deltax, n);
-	swaps (&elt->deltay, n);
+	swaps (&elt->deltax);
+	swaps (&elt->deltay);
 	
 	i = elt->len;
 	if (i == 0xff)
 	{
-	    swapl (buffer, n);
+	    swapl ((int *) buffer);
 	    buffer += 4;
 	}
 	else
@@ -2395,14 +2374,14 @@ SProcRenderCompositeGlyphs (ClientPtr client)
 	    case 2:
 		while (i--)
 		{
-		    swaps (buffer, n);
+		    swaps ((short *) buffer);
 		    buffer += 2;
 		}
 		break;
 	    case 4:
 		while (i--)
 		{
-		    swapl (buffer, n);
+		    swapl ((int *) buffer);
 		    buffer += 4;
 		}
 		break;
@@ -2417,16 +2396,15 @@ SProcRenderCompositeGlyphs (ClientPtr client)
 static int
 SProcRenderFillRectangles (ClientPtr client)
 {
-    register int n;
     REQUEST(xRenderFillRectanglesReq);
 
     REQUEST_AT_LEAST_SIZE (xRenderFillRectanglesReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->dst, n);
-    swaps(&stuff->color.red, n);
-    swaps(&stuff->color.green, n);
-    swaps(&stuff->color.blue, n);
-    swaps(&stuff->color.alpha, n);
+    swaps(&stuff->length);
+    swapl(&stuff->dst);
+    swaps(&stuff->color.red);
+    swaps(&stuff->color.green);
+    swaps(&stuff->color.blue);
+    swaps(&stuff->color.alpha);
     SwapRestS(stuff);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
@@ -2434,73 +2412,68 @@ SProcRenderFillRectangles (ClientPtr client)
 static int
 SProcRenderCreateCursor (ClientPtr client)
 {
-    register int n;
     REQUEST(xRenderCreateCursorReq);
     REQUEST_SIZE_MATCH (xRenderCreateCursorReq);
     
-    swaps(&stuff->length, n);
-    swapl(&stuff->cid, n);
-    swapl(&stuff->src, n);
-    swaps(&stuff->x, n);
-    swaps(&stuff->y, n);
+    swaps(&stuff->length);
+    swapl(&stuff->cid);
+    swapl(&stuff->src);
+    swaps(&stuff->x);
+    swaps(&stuff->y);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
     
 static int
 SProcRenderSetPictureTransform (ClientPtr client)
 {
-    register int n;
     REQUEST(xRenderSetPictureTransformReq);
     REQUEST_SIZE_MATCH(xRenderSetPictureTransformReq);
 
-    swaps(&stuff->length, n);
-    swapl(&stuff->picture, n);
-    swapl(&stuff->transform.matrix11, n);
-    swapl(&stuff->transform.matrix12, n);
-    swapl(&stuff->transform.matrix13, n);
-    swapl(&stuff->transform.matrix21, n);
-    swapl(&stuff->transform.matrix22, n);
-    swapl(&stuff->transform.matrix23, n);
-    swapl(&stuff->transform.matrix31, n);
-    swapl(&stuff->transform.matrix32, n);
-    swapl(&stuff->transform.matrix33, n);
+    swaps(&stuff->length);
+    swapl(&stuff->picture);
+    swapl(&stuff->transform.matrix11);
+    swapl(&stuff->transform.matrix12);
+    swapl(&stuff->transform.matrix13);
+    swapl(&stuff->transform.matrix21);
+    swapl(&stuff->transform.matrix22);
+    swapl(&stuff->transform.matrix23);
+    swapl(&stuff->transform.matrix31);
+    swapl(&stuff->transform.matrix32);
+    swapl(&stuff->transform.matrix33);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
 
 static int
 SProcRenderQueryFilters (ClientPtr client)
 {
-    register int n;
     REQUEST (xRenderQueryFiltersReq);
     REQUEST_SIZE_MATCH (xRenderQueryFiltersReq);
 
-    swaps(&stuff->length, n);
-    swapl(&stuff->drawable, n);
+    swaps(&stuff->length);
+    swapl(&stuff->drawable);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
     
 static int
 SProcRenderSetPictureFilter (ClientPtr client)
 {
-    register int n;
     REQUEST (xRenderSetPictureFilterReq);
     REQUEST_AT_LEAST_SIZE (xRenderSetPictureFilterReq);
 
-    swaps(&stuff->length, n);
-    swapl(&stuff->picture, n);
-    swaps(&stuff->nbytes, n);
+    swaps(&stuff->length);
+    swapl(&stuff->picture);
+    swaps(&stuff->nbytes);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
     
 static int
 SProcRenderCreateAnimCursor (ClientPtr client)
 {
-    register int n;
     REQUEST (xRenderCreateAnimCursorReq);
     REQUEST_AT_LEAST_SIZE (xRenderCreateAnimCursorReq);
 
-    swaps(&stuff->length, n);
-    swapl(&stuff->cid, n);
+    swaps(&stuff->length);
+    swapl(&stuff->cid);
     SwapRestL(stuff);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
@@ -2508,14 +2481,13 @@ SProcRenderCreateAnimCursor (ClientPtr client)
 static int
 SProcRenderAddTraps (ClientPtr client)
 {
-    register int n;
     REQUEST (xRenderAddTrapsReq);
     REQUEST_AT_LEAST_SIZE (xRenderAddTrapsReq);
 
-    swaps(&stuff->length, n);
-    swapl(&stuff->picture, n);
-    swaps(&stuff->xOff, n);
-    swaps(&stuff->yOff, n);
+    swaps(&stuff->length);
+    swapl(&stuff->picture);
+    swaps(&stuff->xOff);
+    swaps(&stuff->yOff);
     SwapRestL(stuff);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
@@ -2523,49 +2495,50 @@ SProcRenderAddTraps (ClientPtr client)
 static int
 SProcRenderCreateSolidFill(ClientPtr client)
 {
-    register int n;
     REQUEST (xRenderCreateSolidFillReq);
     REQUEST_AT_LEAST_SIZE (xRenderCreateSolidFillReq);
 
-    swaps(&stuff->length, n);
-    swapl(&stuff->pid, n);
-    swaps(&stuff->color.alpha, n);
-    swaps(&stuff->color.red, n);
-    swaps(&stuff->color.green, n);
-    swaps(&stuff->color.blue, n);
+    swaps(&stuff->length);
+    swapl(&stuff->pid);
+    swaps(&stuff->color.alpha);
+    swaps(&stuff->color.red);
+    swaps(&stuff->color.green);
+    swaps(&stuff->color.blue);
     return (*ProcRenderVector[stuff->renderReqType]) (client);
 }
 
 static void swapStops(void *stuff, int num)
 {
-    int i, n;
+    int i;
     CARD32 *stops;
+    CARD16 *colors;
+
     stops = (CARD32 *)(stuff);
     for (i = 0; i < num; ++i) {
-        swapl(stops, n);
+        swapl(stops);
         ++stops;
     }
+    colors = (CARD16 *) (stops);
     for (i = 0; i < 4*num; ++i) {
-        swaps(stops, n);
-        ++stops;
+        swaps(colors);
+        ++colors;
     }
 }
 
 static int
 SProcRenderCreateLinearGradient (ClientPtr client)
 {
-    register int n;
     int len;
     REQUEST (xRenderCreateLinearGradientReq);
     REQUEST_AT_LEAST_SIZE (xRenderCreateLinearGradientReq);
 
-    swaps(&stuff->length, n);
-    swapl(&stuff->pid, n);
-    swapl(&stuff->p1.x, n);
-    swapl(&stuff->p1.y, n);
-    swapl(&stuff->p2.x, n);
-    swapl(&stuff->p2.y, n);
-    swapl(&stuff->nStops, n);
+    swaps(&stuff->length);
+    swapl(&stuff->pid);
+    swapl(&stuff->p1.x);
+    swapl(&stuff->p1.y);
+    swapl(&stuff->p2.x);
+    swapl(&stuff->p2.y);
+    swapl(&stuff->nStops);
 
     len = (client->req_len << 2) - sizeof(xRenderCreateLinearGradientReq);
     if (stuff->nStops > UINT32_MAX/(sizeof(xFixed) + sizeof(xRenderColor)))
@@ -2581,20 +2554,19 @@ SProcRenderCreateLinearGradient (ClientPtr client)
 static int
 SProcRenderCreateRadialGradient (ClientPtr client)
 {
-    register int n;
     int len;
     REQUEST (xRenderCreateRadialGradientReq);
     REQUEST_AT_LEAST_SIZE (xRenderCreateRadialGradientReq);
 
-    swaps(&stuff->length, n);
-    swapl(&stuff->pid, n);
-    swapl(&stuff->inner.x, n);
-    swapl(&stuff->inner.y, n);
-    swapl(&stuff->outer.x, n);
-    swapl(&stuff->outer.y, n);
-    swapl(&stuff->inner_radius, n);
-    swapl(&stuff->outer_radius, n);
-    swapl(&stuff->nStops, n);
+    swaps(&stuff->length);
+    swapl(&stuff->pid);
+    swapl(&stuff->inner.x);
+    swapl(&stuff->inner.y);
+    swapl(&stuff->outer.x);
+    swapl(&stuff->outer.y);
+    swapl(&stuff->inner_radius);
+    swapl(&stuff->outer_radius);
+    swapl(&stuff->nStops);
 
     len = (client->req_len << 2) - sizeof(xRenderCreateRadialGradientReq);
     if (stuff->nStops > UINT32_MAX/(sizeof(xFixed) + sizeof(xRenderColor)))
@@ -2610,17 +2582,16 @@ SProcRenderCreateRadialGradient (ClientPtr client)
 static int
 SProcRenderCreateConicalGradient (ClientPtr client)
 {
-    register int n;
     int len;
     REQUEST (xRenderCreateConicalGradientReq);
     REQUEST_AT_LEAST_SIZE (xRenderCreateConicalGradientReq);
 
-    swaps(&stuff->length, n);
-    swapl(&stuff->pid, n);
-    swapl(&stuff->center.x, n);
-    swapl(&stuff->center.y, n);
-    swapl(&stuff->angle, n);
-    swapl(&stuff->nStops, n);
+    swaps(&stuff->length);
+    swapl(&stuff->pid);
+    swapl(&stuff->center.x);
+    swapl(&stuff->center.y);
+    swapl(&stuff->angle);
+    swapl(&stuff->nStops);
 
     len = (client->req_len << 2) - sizeof(xRenderCreateConicalGradientReq);
     if (stuff->nStops > UINT32_MAX/(sizeof(xFixed) + sizeof(xRenderColor)))
diff --git a/nx-X11/programs/Xserver/xfixes/cursor.c b/nx-X11/programs/Xserver/xfixes/cursor.c
index c60d4b37c..29c6061d6 100755
--- a/nx-X11/programs/Xserver/xfixes/cursor.c
+++ b/nx-X11/programs/Xserver/xfixes/cursor.c
@@ -225,12 +225,11 @@ GetBit (unsigned char *line, int x)
 int
 SProcXFixesSelectCursorInput (ClientPtr client)
 {
-    register int n;
     REQUEST(xXFixesSelectCursorInputReq);
 
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
-    swapl(&stuff->eventMask, n);
+    swaps(&stuff->length);
+    swapl(&stuff->window);
+    swapl(&stuff->eventMask);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
     
@@ -329,20 +328,18 @@ ProcXFixesGetCursorImage (ClientPtr client)
     rep->cursorSerial = pCursor->serialNumber;
 
     image = (CARD32 *) (rep + 1);
-    CopyCursorToImage (pCursor, image);
-    if (client->swapped)
-    {
-	int n;
-	swaps (&rep->sequenceNumber, n);
-	swapl (&rep->length, n);
-	swaps (&rep->x, n);
-	swaps (&rep->y, n);
-	swaps (&rep->width, n);
-	swaps (&rep->height, n);
-	swaps (&rep->xhot, n);
-	swaps (&rep->yhot, n);
-	swapl (&rep->cursorSerial, n);
-	SwapLongs (image, npixels);
+    CopyCursorToImage(pCursor, image);
+    if (client->swapped) {
+	swaps(&rep->sequenceNumber);
+	swapl(&rep->length);
+	swaps(&rep->x);
+	swaps(&rep->y);
+	swaps(&rep->width);
+	swaps(&rep->height);
+	swaps(&rep->xhot);
+	swaps(&rep->yhot);
+	swapl(&rep->cursorSerial);
+	SwapLongs(image, npixels);
     }
     (void) WriteToClient(client, sizeof (xXFixesGetCursorImageReply) +
 			 (npixels << 2), (char *) rep);
@@ -353,9 +350,8 @@ ProcXFixesGetCursorImage (ClientPtr client)
 int
 SProcXFixesGetCursorImage (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesGetCursorImageReq);
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -381,13 +377,12 @@ ProcXFixesSetCursorName (ClientPtr client)
 int
 SProcXFixesSetCursorName (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesSetCursorNameReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xXFixesSetCursorNameReq);
-    swapl (&stuff->cursor, n);
-    swaps (&stuff->nbytes, n);
+    swapl(&stuff->cursor);
+    swaps(&stuff->nbytes);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -413,13 +408,11 @@ ProcXFixesGetCursorName (ClientPtr client)
     reply.sequenceNumber = client->sequence;
     reply.atom = pCursor->name;
     reply.nbytes = len;
-    if (client->swapped)
-    {
-	int n;
-	swaps (&reply.sequenceNumber, n);
-	swapl (&reply.length, n);
-	swapl (&reply.atom, n);
-	swaps (&reply.nbytes, n);
+    if (client->swapped) {
+	swaps(&reply.sequenceNumber);
+	swapl(&reply.length);
+	swapl(&reply.atom);
+	swaps(&reply.nbytes);
     }
     WriteReplyToClient(client, sizeof(xXFixesGetCursorNameReply), &reply);
     (void)WriteToClient(client, len, str);
@@ -430,12 +423,11 @@ ProcXFixesGetCursorName (ClientPtr client)
 int
 SProcXFixesGetCursorName (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesSetCursorNameReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXFixesGetCursorNameReq);
-    swapl (&stuff->cursor, n);
+    swapl(&stuff->cursor);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -482,23 +474,21 @@ ProcXFixesGetCursorImageAndName (ClientPtr client)
     rep->nbytes = nbytes;
 
     image = (CARD32 *) (rep + 1);
-    CopyCursorToImage (pCursor, image);
-    memcpy ((image + npixels), name, nbytes);
-    if (client->swapped)
-    {
-	int n;
-	swaps (&rep->sequenceNumber, n);
-	swapl (&rep->length, n);
-	swaps (&rep->x, n);
-	swaps (&rep->y, n);
-	swaps (&rep->width, n);
-	swaps (&rep->height, n);
-	swaps (&rep->xhot, n);
-	swaps (&rep->yhot, n);
-	swapl (&rep->cursorSerial, n);
-	swapl (&rep->cursorName, n);
-	swaps (&rep->nbytes, n);
-	SwapLongs (image, npixels);
+    CopyCursorToImage(pCursor, image);
+    memcpy((image + npixels), name, nbytes);
+    if (client->swapped) {
+	swaps(&rep->sequenceNumber);
+	swapl(&rep->length);
+	swaps(&rep->x);
+	swaps(&rep->y);
+	swaps(&rep->width);
+	swaps(&rep->height);
+	swaps(&rep->xhot);
+	swaps(&rep->yhot);
+	swapl(&rep->cursorSerial);
+	swapl(&rep->cursorName);
+	swaps(&rep->nbytes);
+	SwapLongs(image, npixels);
     }
     (void) WriteToClient(client, sizeof (xXFixesGetCursorImageAndNameReply) +
 			 (npixels << 2) + nbytesRound, (char *) rep);
@@ -509,9 +499,8 @@ ProcXFixesGetCursorImageAndName (ClientPtr client)
 int
 SProcXFixesGetCursorImageAndName (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesGetCursorImageAndNameReq);
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -642,13 +631,12 @@ ProcXFixesChangeCursor (ClientPtr client)
 int
 SProcXFixesChangeCursor (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesChangeCursorReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXFixesChangeCursorReq);
-    swapl (&stuff->source, n);
-    swapl (&stuff->destination, n);
+    swapl(&stuff->source);
+    swapl(&stuff->destination);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -678,13 +666,12 @@ ProcXFixesChangeCursorByName (ClientPtr client)
 int
 SProcXFixesChangeCursorByName (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesChangeCursorByNameReq);
 
-    swaps (&stuff->length, n);
-    REQUEST_AT_LEAST_SIZE (xXFixesChangeCursorByNameReq);
-    swapl (&stuff->source, n);
-    swaps (&stuff->nbytes, n);
+    swaps(&stuff->length);
+    REQUEST_AT_LEAST_SIZE(xXFixesChangeCursorByNameReq);
+    swapl(&stuff->source);
+    swaps(&stuff->nbytes);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
diff --git a/nx-X11/programs/Xserver/xfixes/region.c b/nx-X11/programs/Xserver/xfixes/region.c
index 09f33d0ac..398409e61 100755
--- a/nx-X11/programs/Xserver/xfixes/region.c
+++ b/nx-X11/programs/Xserver/xfixes/region.c
@@ -96,12 +96,11 @@ ProcXFixesCreateRegion (ClientPtr client)
 int
 SProcXFixesCreateRegion (ClientPtr client)
 {
-    register int n;
     REQUEST(xXFixesCreateRegionReq);
-    
-    swaps(&stuff->length, n);
+
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xXFixesCreateRegionReq);
-    swapl(&stuff->region, n);
+    swapl(&stuff->region);
     SwapRestS(stuff);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
@@ -141,13 +140,12 @@ ProcXFixesCreateRegionFromBitmap (ClientPtr client)
 int
 SProcXFixesCreateRegionFromBitmap (ClientPtr client)
 {
-    int n;
-    REQUEST (xXFixesCreateRegionFromBitmapReq);
+    REQUEST(xXFixesCreateRegionFromBitmapReq);
 
-    swaps(&stuff->length, n);
-    REQUEST_SIZE_MATCH (xXFixesCreateRegionFromBitmapReq);
-    swapl(&stuff->region, n);
-    swapl(&stuff->bitmap, n);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xXFixesCreateRegionFromBitmapReq);
+    swapl(&stuff->region);
+    swapl(&stuff->bitmap);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -205,13 +203,12 @@ ProcXFixesCreateRegionFromWindow (ClientPtr client)
 int
 SProcXFixesCreateRegionFromWindow (ClientPtr client)
 {
-    int n;
-    REQUEST (xXFixesCreateRegionFromWindowReq);
+    REQUEST(xXFixesCreateRegionFromWindowReq);
 
-    swaps(&stuff->length, n);
-    REQUEST_SIZE_MATCH (xXFixesCreateRegionFromWindowReq);
-    swapl(&stuff->region, n);
-    swapl(&stuff->window, n);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xXFixesCreateRegionFromWindowReq);
+    swapl(&stuff->region);
+    swapl(&stuff->window);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -252,13 +249,12 @@ ProcXFixesCreateRegionFromGC (ClientPtr client)
 int
 SProcXFixesCreateRegionFromGC (ClientPtr client)
 {
-    int n;
-    REQUEST (xXFixesCreateRegionFromGCReq);
+    REQUEST(xXFixesCreateRegionFromGCReq);
 
-    swaps(&stuff->length, n);
-    REQUEST_SIZE_MATCH (xXFixesCreateRegionFromGCReq);
-    swapl(&stuff->region, n);
-    swapl(&stuff->gc, n);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xXFixesCreateRegionFromGCReq);
+    swapl(&stuff->region);
+    swapl(&stuff->gc);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -304,13 +300,12 @@ ProcXFixesCreateRegionFromPicture (ClientPtr client)
 int
 SProcXFixesCreateRegionFromPicture (ClientPtr client)
 {
-    int n;
-    REQUEST (xXFixesCreateRegionFromPictureReq);
+    REQUEST(xXFixesCreateRegionFromPictureReq);
 
-    swaps(&stuff->length, n);
-    REQUEST_SIZE_MATCH (xXFixesCreateRegionFromPictureReq);
-    swapl(&stuff->region, n);
-    swapl(&stuff->picture, n);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xXFixesCreateRegionFromPictureReq);
+    swapl(&stuff->region);
+    swapl(&stuff->picture);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -329,12 +324,11 @@ ProcXFixesDestroyRegion (ClientPtr client)
 int
 SProcXFixesDestroyRegion (ClientPtr client)
 {
-    int n;
-    REQUEST (xXFixesDestroyRegionReq);
+    REQUEST(xXFixesDestroyRegionReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXFixesDestroyRegionReq);
-    swapl (&stuff->region, n);
+    swapl(&stuff->region);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -368,12 +362,11 @@ ProcXFixesSetRegion (ClientPtr client)
 int
 SProcXFixesSetRegion (ClientPtr client)
 {
-    int n;
-    REQUEST (xXFixesSetRegionReq);
+    REQUEST(xXFixesSetRegionReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xXFixesSetRegionReq);
-    swapl (&stuff->region, n);
+    swapl(&stuff->region);
     SwapRestS(stuff);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
@@ -396,13 +389,12 @@ ProcXFixesCopyRegion (ClientPtr client)
 int
 SProcXFixesCopyRegion (ClientPtr client)
 {
-    int n;
-    REQUEST (xXFixesCopyRegionReq);
+    REQUEST(xXFixesCopyRegionReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xXFixesCopyRegionReq);
-    swapl (&stuff->source, n);
-    swapl (&stuff->destination, n);
+    swapl(&stuff->source);
+    swapl(&stuff->destination);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -441,14 +433,13 @@ ProcXFixesCombineRegion (ClientPtr client)
 int
 SProcXFixesCombineRegion (ClientPtr client)
 {
-    int n;
-    REQUEST (xXFixesCombineRegionReq);
+    REQUEST(xXFixesCombineRegionReq);
 
-    swaps (&stuff->length, n);
-    REQUEST_SIZE_MATCH (xXFixesCombineRegionReq);
-    swapl (&stuff->source1, n);
-    swapl (&stuff->source2, n);
-    swapl (&stuff->destination, n);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xXFixesCombineRegionReq);
+    swapl(&stuff->source1);
+    swapl(&stuff->source2);
+    swapl(&stuff->destination);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -488,17 +479,16 @@ ProcXFixesInvertRegion (ClientPtr client)
 int
 SProcXFixesInvertRegion (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesInvertRegionReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXFixesInvertRegionReq);
-    swapl (&stuff->source, n);
-    swaps (&stuff->x, n);
-    swaps (&stuff->y, n);
-    swaps (&stuff->width, n);
-    swaps (&stuff->height, n);
-    swapl (&stuff->destination, n);
+    swapl(&stuff->source);
+    swaps(&stuff->x);
+    swaps(&stuff->y);
+    swaps(&stuff->width);
+    swaps(&stuff->height);
+    swapl(&stuff->destination);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -518,14 +508,13 @@ ProcXFixesTranslateRegion (ClientPtr client)
 int
 SProcXFixesTranslateRegion (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesTranslateRegionReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXFixesTranslateRegionReq);
-    swapl (&stuff->region, n);
-    swaps (&stuff->dx, n);
-    swaps (&stuff->dy, n);
+    swapl(&stuff->region);
+    swaps(&stuff->dx);
+    swaps(&stuff->dy);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -547,13 +536,12 @@ ProcXFixesRegionExtents (ClientPtr client)
 int
 SProcXFixesRegionExtents (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesRegionExtentsReq);
-    
-    swaps (&stuff->length, n);
+
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXFixesRegionExtentsReq);
-    swapl (&stuff->source, n);
-    swapl (&stuff->destination, n);
+    swapl(&stuff->source);
+    swapl(&stuff->destination);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -595,16 +583,14 @@ ProcXFixesFetchRegion (ClientPtr client)
 	pRect[i].width = pBox[i].x2 - pBox[i].x1;
 	pRect[i].height = pBox[i].y2 - pBox[i].y1;
     }
-    if (client->swapped)
-    {
-	int n;
-	swaps (&reply->sequenceNumber, n);
-	swapl (&reply->length, n);
-	swaps (&reply->x, n);
-	swaps (&reply->y, n);
-	swaps (&reply->width, n);
-	swaps (&reply->height, n);
-	SwapShorts ((INT16 *) pRect, nBox * 4);
+    if (client->swapped) {
+	swaps(&reply->sequenceNumber);
+	swapl(&reply->length);
+	swaps(&reply->x);
+	swaps(&reply->y);
+	swaps(&reply->width);
+	swaps(&reply->height);
+	SwapShorts((INT16 *) pRect, nBox * 4);
     }
     (void) WriteToClient(client, sizeof (xXFixesFetchRegionReply) +
 			 nBox * sizeof (xRectangle), (char *) reply);
@@ -615,12 +601,11 @@ ProcXFixesFetchRegion (ClientPtr client)
 int
 SProcXFixesFetchRegion (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesFetchRegionReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXFixesFetchRegionReq);
-    swapl (&stuff->region, n);
+    swapl(&stuff->region);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -654,15 +639,14 @@ ProcXFixesSetGCClipRegion (ClientPtr client)
 int
 SProcXFixesSetGCClipRegion (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesSetGCClipRegionReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXFixesSetGCClipRegionReq);
-    swapl (&stuff->gc, n);
-    swapl (&stuff->region, n);
-    swaps (&stuff->xOrigin, n);
-    swaps (&stuff->yOrigin, n);
+    swapl(&stuff->gc);
+    swapl(&stuff->region);
+    swaps(&stuff->xOrigin);
+    swaps(&stuff->yOrigin);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -752,15 +736,14 @@ ProcXFixesSetWindowShapeRegion (ClientPtr client)
 int
 SProcXFixesSetWindowShapeRegion (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesSetWindowShapeRegionReq);
 
-    swaps (&stuff->length, n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXFixesSetWindowShapeRegionReq);
-    swapl (&stuff->dest, n);
-    swaps (&stuff->xOff, n);
-    swaps (&stuff->yOff, n);
-    swapl (&stuff->region, n);
+    swapl(&stuff->dest);
+    swaps(&stuff->xOff);
+    swaps(&stuff->yOff);
+    swapl(&stuff->region);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -791,15 +774,14 @@ ProcXFixesSetPictureClipRegion (ClientPtr client)
 int
 SProcXFixesSetPictureClipRegion (ClientPtr client)
 {
-    int n;
     REQUEST(xXFixesSetPictureClipRegionReq);
-    
-    swaps (&stuff->length, n);
-    REQUEST_SIZE_MATCH (xXFixesSetPictureClipRegionReq);
-    swapl (&stuff->picture, n);
-    swapl (&stuff->region, n);
-    swaps (&stuff->xOrigin, n);
-    swaps (&stuff->yOrigin, n);
+
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xXFixesSetPictureClipRegionReq);
+    swapl(&stuff->picture);
+    swapl(&stuff->region);
+    swaps(&stuff->xOrigin);
+    swaps(&stuff->yOrigin);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
@@ -848,17 +830,15 @@ ProcXFixesExpandRegion (ClientPtr client)
 int
 SProcXFixesExpandRegion (ClientPtr client)
 {
-    int n;
-    REQUEST (xXFixesExpandRegionReq);
+    REQUEST(xXFixesExpandRegionReq);
 
-    swaps (&stuff->length, n);
-    REQUEST_SIZE_MATCH (xXFixesExpandRegionReq);
-    swapl (&stuff->source, n);
-    swapl (&stuff->destination, n);
-    swaps (&stuff->left, n);
-    swaps (&stuff->right, n);
-    swaps (&stuff->top, n);
-    swaps (&stuff->bottom, n);
+    swaps(&stuff->length);
+    REQUEST_SIZE_MATCH(xXFixesExpandRegionReq);
+    swapl(&stuff->source);
+    swapl(&stuff->destination);
+    swaps(&stuff->left);
+    swaps(&stuff->right);
+    swaps(&stuff->top);
+    swaps(&stuff->bottom);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
-
diff --git a/nx-X11/programs/Xserver/xfixes/saveset.c b/nx-X11/programs/Xserver/xfixes/saveset.c
index 934651218..a81c0ca1b 100755
--- a/nx-X11/programs/Xserver/xfixes/saveset.c
+++ b/nx-X11/programs/Xserver/xfixes/saveset.c
@@ -70,10 +70,9 @@ ProcXFixesChangeSaveSet(ClientPtr client)
 int
 SProcXFixesChangeSaveSet(ClientPtr client)
 {
-    register int n;
     REQUEST(xXFixesChangeSaveSetReq);
 
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
+    swaps(&stuff->length);
+    swapl(&stuff->window);
     return ProcXFixesChangeSaveSet(client);
 }
diff --git a/nx-X11/programs/Xserver/xfixes/select.c b/nx-X11/programs/Xserver/xfixes/select.c
index 6fe632c0d..2a20bfe87 100755
--- a/nx-X11/programs/Xserver/xfixes/select.c
+++ b/nx-X11/programs/Xserver/xfixes/select.c
@@ -215,14 +215,13 @@ ProcXFixesSelectSelectionInput (ClientPtr client)
 int
 SProcXFixesSelectSelectionInput (ClientPtr client)
 {
-    register int n;
     REQUEST(xXFixesSelectSelectionInputReq);
 
     REQUEST_SIZE_MATCH(xXFixesSelectSelectionInputReq);
-    swaps(&stuff->length, n);
-    swapl(&stuff->window, n);
-    swapl(&stuff->selection, n);
-    swapl(&stuff->eventMask, n);
+    swaps(&stuff->length);
+    swapl(&stuff->window);
+    swapl(&stuff->selection);
+    swapl(&stuff->eventMask);
     return ProcXFixesSelectSelectionInput(client);
 }
     
diff --git a/nx-X11/programs/Xserver/xfixes/xfixes.c b/nx-X11/programs/Xserver/xfixes/xfixes.c
index f97a0632d..fdee46d90 100755
--- a/nx-X11/programs/Xserver/xfixes/xfixes.c
+++ b/nx-X11/programs/Xserver/xfixes/xfixes.c
@@ -39,7 +39,6 @@ ProcXFixesQueryVersion(ClientPtr client)
 {
     XFixesClientPtr pXFixesClient = GetXFixesClient (client);
     xXFixesQueryVersionReply rep;
-    register int n;
     REQUEST(xXFixesQueryVersionReq);
 
     REQUEST_SIZE_MATCH(xXFixesQueryVersionReq);
@@ -61,10 +60,10 @@ ProcXFixesQueryVersion(ClientPtr client)
     pXFixesClient->major_version = rep.majorVersion;
     pXFixesClient->minor_version = rep.minorVersion;
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-    	swapl(&rep.length, n);
-	swapl(&rep.majorVersion, n);
-	swapl(&rep.minorVersion, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swapl(&rep.majorVersion);
+	swapl(&rep.minorVersion);
     }
     WriteToClient(client, sizeof(xXFixesQueryVersionReply), (char *)&rep);
     return(client->noClientException);
@@ -131,12 +130,11 @@ ProcXFixesDispatch (ClientPtr client)
 static int
 SProcXFixesQueryVersion(ClientPtr client)
 {
-    register int n;
     REQUEST(xXFixesQueryVersionReq);
 
-    swaps(&stuff->length, n);
-    swapl(&stuff->majorVersion, n);
-    swapl(&stuff->minorVersion, n);
+    swaps(&stuff->length);
+    swapl(&stuff->majorVersion);
+    swapl(&stuff->minorVersion);
     return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
 }
 
diff --git a/nx-X11/programs/Xserver/xkb/ddxList.c b/nx-X11/programs/Xserver/xkb/ddxList.c
index 2b8f90bad..90ac3d892 100644
--- a/nx-X11/programs/Xserver/xkb/ddxList.c
+++ b/nx-X11/programs/Xserver/xkb/ddxList.c
@@ -118,9 +118,8 @@ char *		tmp;
     wire16[1]= slen;
     memcpy(wire8,str,slen);
     if (client->swapped) {
-	register int n;
-	swaps(&wire16[0],n);
-	swaps(&wire16[1],n);
+	swaps(&wire16[0]);
+	swaps(&wire16[1]);
     }
     list->nPool+= wlen;
     list->nFound[what]++;
diff --git a/nx-X11/programs/Xserver/xkb/xkb.c b/nx-X11/programs/Xserver/xkb/xkb.c
index 7085fbfe4..6c6e67f1e 100644
--- a/nx-X11/programs/Xserver/xkb/xkb.c
+++ b/nx-X11/programs/Xserver/xkb/xkb.c
@@ -165,7 +165,6 @@ ProcXkbUseExtension(ClientPtr client)
 {
     REQUEST(xkbUseExtensionReq);
     xkbUseExtensionReply	rep;
-    register int n;
     int	supported;
 
     REQUEST_SIZE_MATCH(xkbUseExtensionReq);
@@ -201,9 +200,9 @@ ProcXkbUseExtension(ClientPtr client)
     rep.serverMajor = SERVER_XKB_MAJOR_VERSION;
     rep.serverMinor = SERVER_XKB_MINOR_VERSION;
     if ( client->swapped ) {
-	swaps(&rep.sequenceNumber, n);
-	swaps(&rep.serverMajor, n);
-	swaps(&rep.serverMinor, n);
+	swaps(&rep.sequenceNumber);
+	swaps(&rep.serverMajor);
+	swaps(&rep.serverMinor);
     }
     WriteToClient(client,SIZEOF(xkbUseExtensionReply), (char *)&rep);
     return client->noClientException;
@@ -535,9 +534,8 @@ ProcXkbGetState(ClientPtr client)
     rep.compatState = xkb->compat_state;
     rep.ptrBtnState = xkb->ptr_buttons;
     if (client->swapped) {
-	register int n;
-	swaps(&rep.sequenceNumber,n);
-	swaps(&rep.ptrBtnState,n);
+	swaps(&rep.sequenceNumber);
+	swaps(&rep.ptrBtnState);
     }
     WriteToClient(client, SIZEOF(xkbGetStateReply), (char *)&rep);
     return client->noClientException;
@@ -610,7 +608,6 @@ ProcXkbGetControls(ClientPtr client)
     xkbGetControlsReply rep;
     XkbControlsPtr	xkb;
     DeviceIntPtr 	dev;
-    register int 	n;
 
     REQUEST(xkbGetControlsReq);
     REQUEST_SIZE_MATCH(xkbGetControlsReq);
@@ -653,26 +650,26 @@ ProcXkbGetControls(ClientPtr client)
     rep.axOptions = xkb->ax_options;
     memcpy(rep.perKeyRepeat,xkb->per_key_repeat,XkbPerKeyBitArraySize);
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-	swapl(&rep.length,n);
-	swaps(&rep.internalVMods, n);
-	swaps(&rep.ignoreLockVMods, n);
-	swapl(&rep.enabledCtrls, n);
-	swaps(&rep.repeatDelay, n);
-	swaps(&rep.repeatInterval, n);
-	swaps(&rep.slowKeysDelay, n);
-	swaps(&rep.debounceDelay, n);
-	swaps(&rep.mkDelay, n);
-	swaps(&rep.mkInterval, n);
-	swaps(&rep.mkTimeToMax, n);
-	swaps(&rep.mkMaxSpeed, n);
-	swaps(&rep.mkCurve, n);
-	swaps(&rep.axTimeout, n);
-	swapl(&rep.axtCtrlsMask, n);
-	swapl(&rep.axtCtrlsValues, n);
-	swaps(&rep.axtOptsMask, n);
-	swaps(&rep.axtOptsValues, n);
-	swaps(&rep.axOptions, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swaps(&rep.internalVMods);
+	swaps(&rep.ignoreLockVMods);
+	swapl(&rep.enabledCtrls);
+	swaps(&rep.repeatDelay);
+	swaps(&rep.repeatInterval);
+	swaps(&rep.slowKeysDelay);
+	swaps(&rep.debounceDelay);
+	swaps(&rep.mkDelay);
+	swaps(&rep.mkInterval);
+	swaps(&rep.mkTimeToMax);
+	swaps(&rep.mkMaxSpeed);
+	swaps(&rep.mkCurve);
+	swaps(&rep.axTimeout);
+	swapl(&rep.axtCtrlsMask);
+	swapl(&rep.axtCtrlsValues);
+	swaps(&rep.axtOptsMask);
+	swaps(&rep.axtOptsValues);
+	swaps(&rep.axOptions);
     }
     WriteToClient(client, SIZEOF(xkbGetControlsReply), (char *)&rep);
     return(client->noClientException);
@@ -940,8 +937,7 @@ XkbWriteKeyTypes(	XkbDescPtr		xkb,
 	wire->nMapEntries = type->map_count;
 	wire->preserve = (type->preserve!=NULL);
 	if (client->swapped) {
-	    register int n;
-	    swaps(&wire->virtualMods,n);
+	    swaps(&wire->virtualMods);
 	}	
 
 	buf= (char *)&wire[1];
@@ -957,8 +953,7 @@ XkbWriteKeyTypes(	XkbDescPtr		xkb,
 		wire->realMods= entry->mods.real_mods;
 		wire->virtualMods= entry->mods.vmods;
 		if (client->swapped) {
-		    register int n;
-		    swaps(&wire->virtualMods,n);
+		    swaps(&wire->virtualMods);
 		}
 	    }
 	    buf= (char *)wire;
@@ -972,8 +967,7 @@ XkbWriteKeyTypes(	XkbDescPtr		xkb,
 		    pwire->realMods= preserve->real_mods;
 		    pwire->virtualMods= preserve->vmods;
 		    if (client->swapped) {
-			register int n;
-			swaps(&pwire->virtualMods,n);
+			swaps(&pwire->virtualMods);
 		    }
 		}
 		buf= (char *)pwire;
@@ -1053,10 +1047,10 @@ register unsigned	i;
 	pSym = &xkb->map->syms[symMap->offset];
 	memcpy((char *)buf,(char *)pSym,outMap->nSyms*4);
 	if (client->swapped) {
-	    register int n,nSyms= outMap->nSyms;
-	    swaps(&outMap->nSyms,n);
+	    register int nSyms= outMap->nSyms;
+	    swaps(&outMap->nSyms);
 	    while (nSyms-->0) {
-		swapl(buf,n);
+		swapl((int *)buf);
 		buf+= 4;
 	    }
 	}
@@ -1345,12 +1339,11 @@ char		*desc,*start;
 					len, (unsigned long)(desc-start));
     }
     if (client->swapped) {
-	register int n;
-	swaps(&rep->sequenceNumber,n);
-	swapl(&rep->length,n);
-	swaps(&rep->present,n);
-	swaps(&rep->totalSyms,n);
-	swaps(&rep->totalActs,n);
+	swaps(&rep->sequenceNumber);
+	swapl(&rep->length);
+	swaps(&rep->present);
+	swaps(&rep->totalSyms);
+	swaps(&rep->totalActs);
     }
     WriteToClient(client, (i=SIZEOF(xkbGetMapReply)), (char *)rep);
     WriteToClient(client, len, start);
@@ -1532,8 +1525,7 @@ register xkbKeyTypeWireDesc	*wire = *wireRtrn;
     for (i=0;i<req->nTypes;i++) {
 	unsigned	width;
 	if (client->swapped) {
-	    register int s;
-	    swaps(&wire->virtualMods,s);
+	    swaps(&wire->virtualMods);
 	}
 	n= i+req->firstType;
 	width= wire->numLevels;
@@ -1559,8 +1551,7 @@ register xkbKeyTypeWireDesc	*wire = *wireRtrn;
 	    preWire= (xkbModsWireDesc *)&mapWire[wire->nMapEntries];
 	    for (n=0;n<wire->nMapEntries;n++) {
 		if (client->swapped) {
-		    register int s;
-		    swaps(&mapWire[n].virtualMods,s);
+		    swaps(&mapWire[n].virtualMods);
 		}
 		if (mapWire[n].realMods&(~wire->realMods)) {
 		    *nMapsRtrn= _XkbErrCode4(0x06,n,mapWire[n].realMods,
@@ -1578,8 +1569,7 @@ register xkbKeyTypeWireDesc	*wire = *wireRtrn;
 		}
 		if (wire->preserve) {
 		    if (client->swapped) {
-			register int s;
-			swaps(&preWire[n].virtualMods,s);
+			swaps(&preWire[n].virtualMods);
 		    }
 		    if (preWire[n].realMods&(~mapWire[n].realMods)) {
 			*nMapsRtrn= _XkbErrCode4(0x09,n,preWire[n].realMods,
@@ -1643,7 +1633,7 @@ xkbSymMapWireDesc*	wire = *wireRtrn;
 	KeySym *pSyms;
 	register unsigned nG;
 	if (client->swapped) {
-	    swaps(&wire->nSyms,nG);
+	    swaps(&wire->nSyms);
 	}
 	nG = XkbNumGroups(wire->groupInfo);
 	if (nG>XkbNumKbdGroups) {
@@ -2023,9 +2013,8 @@ unsigned		first,last;
 		newSyms[s]= pSyms[s];
 	    }
 	    if (client->swapped) {
-		int n;
 		for (s=0;s<wire->nSyms;s++) {
-		    swapl(&newSyms[s],n);
+		    swapl(&newSyms[s]);
 		}
 	    }
 	}
@@ -2516,8 +2505,7 @@ int		size;
 		wire->flags= sym->flags;
 		memcpy((char*)&wire->act,(char*)&sym->act,sz_xkbActionWireDesc);
 		if (client->swapped) {
-		    register int n;
-		    swapl(&wire->sym,n);
+		    swapl(&wire->sym);
 		}
 	    }
 	    if (rep->groups) {
@@ -2528,8 +2516,7 @@ int		size;
 			grp->realMods= compat->groups[i].real_mods;
 			grp->virtualMods= compat->groups[i].vmods;
 			if (client->swapped) {
-			    register int n;
-			    swaps(&grp->virtualMods,n);
+			    swaps(&grp->virtualMods);
 			}
 			grp++;
 		    }
@@ -2542,12 +2529,11 @@ int		size;
     else data= NULL;
 
     if (client->swapped) {
-	register int n;
-	swaps(&rep->sequenceNumber,n);
-	swapl(&rep->length,n);
-	swaps(&rep->firstSI,n);
-	swaps(&rep->nSI,n);
-	swaps(&rep->nTotalSI,n);
+	swaps(&rep->sequenceNumber);
+	swapl(&rep->length);
+	swaps(&rep->firstSI);
+	swaps(&rep->nSI);
+	swaps(&rep->nTotalSI);
     }
 
     WriteToClient(client, SIZEOF(xkbGetCompatMapReply), (char *)rep);
@@ -2662,8 +2648,7 @@ ProcXkbSetCompatMap(ClientPtr client)
 	sym = &compat->sym_interpret[stuff->firstSI];
 	for (i=0;i<stuff->nSI;i++,wire++,sym++) {
 	    if (client->swapped) {
-		register int n;
-		swapl(&wire->sym,n);
+		swapl(&wire->sym);
 	    }
 	    sym->sym= wire->sym;
 	    sym->mods= wire->mods;
@@ -2685,8 +2670,7 @@ ProcXkbSetCompatMap(ClientPtr client)
 	for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
 	    if (stuff->groups&bit) {
 		if (client->swapped) {
-		    register int n;
-		    swaps(&wire->virtualMods,n);
+		    swaps(&wire->virtualMods);
 		}
 		compat->groups[i].mask= wire->realMods;
 		compat->groups[i].real_mods= wire->realMods;
@@ -2742,7 +2726,6 @@ ProcXkbGetIndicatorState(ClientPtr client)
     xkbGetIndicatorStateReply 	rep;
     XkbSrvLedInfoPtr		sli;
     DeviceIntPtr 		dev;
-    register int 		i;
 
     REQUEST(xkbGetIndicatorStateReq);
     REQUEST_SIZE_MATCH(xkbGetIndicatorStateReq);
@@ -2764,8 +2747,8 @@ ProcXkbGetIndicatorState(ClientPtr client)
     rep.state = sli->effectiveState;
 
     if (client->swapped) {
-	swaps(&rep.sequenceNumber,i);
-	swapl(&rep.state,i);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.state);
     }
     WriteToClient(client, SIZEOF(xkbGetIndicatorStateReply), (char *)&rep);
     return client->noClientException;
@@ -2817,9 +2800,8 @@ register unsigned	bit;
 		    wire->virtualMods= indicators->maps[i].mods.vmods;
 		    wire->ctrls= indicators->maps[i].ctrls;
 		    if (client->swapped) {
-			register int n;
-			swaps(&wire->virtualMods,n);
-			swapl(&wire->ctrls,n);
+			swaps(&wire->virtualMods);
+			swapl(&wire->ctrls);
 		    }
 		    wire++;
 		}
@@ -2834,10 +2816,10 @@ register unsigned	bit;
     }
     else map = NULL;
     if (client->swapped) {
-	swaps(&rep->sequenceNumber,i);
-	swapl(&rep->length,i);
-	swapl(&rep->which,i);
-	swapl(&rep->realIndicators,i);
+	swaps(&rep->sequenceNumber);
+	swapl(&rep->length);
+	swapl(&rep->which);
+	swapl(&rep->realIndicators);
     }
     WriteToClient(client, SIZEOF(xkbGetIndicatorMapReply), (char *)rep);
     if (map) {
@@ -2920,9 +2902,8 @@ ProcXkbSetIndicatorMap(ClientPtr client)
     for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) {
 	if (stuff->which&bit) {
 	    if (client->swapped) {
-		register int n;
-		swaps(&from->virtualMods,n);
-		swapl(&from->ctrls,n);
+		swaps(&from->virtualMods);
+		swapl(&from->ctrls);
 	    }
 	    CHK_MASK_LEGAL(i,from->whichGroups,XkbIM_UseAnyGroup);
 	    CHK_MASK_LEGAL(i,from->whichMods,XkbIM_UseAnyMods);
@@ -3037,12 +3018,11 @@ ProcXkbGetNamedIndicator(ClientPtr client)
 	rep.supported= 		supported;
     }
     if ( client->swapped ) {
-	register int n;
-	swapl(&rep.length,n);
-	swaps(&rep.sequenceNumber,n);
-	swapl(&rep.indicator,n);
-	swaps(&rep.virtualMods,n);
-	swapl(&rep.ctrls,n);
+	swapl(&rep.length);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.indicator);
+	swaps(&rep.virtualMods);
+	swapl(&rep.ctrls);
     }
 
     WriteToClient(client,SIZEOF(xkbGetNamedIndicatorReply), (char *)&rep);
@@ -3203,8 +3183,7 @@ Atom *atm;
 	if (atoms[i]!=None) {
 	    *atm= atoms[i];
 	    if (swap) {
-		register int n;
-		swapl(atm,n);
+		swapl(atm);
 	    }
 	    atm++;
 	}
@@ -3327,12 +3306,11 @@ char *			desc;
     length= rep->length*4;
     which= rep->which;
     if (client->swapped) {
-	register int n;
-	swaps(&rep->sequenceNumber,n);
-	swapl(&rep->length,n);
-	swapl(&rep->which,n);
-	swaps(&rep->virtualMods,n);
-	swapl(&rep->indicators,n);
+	swaps(&rep->sequenceNumber);
+	swapl(&rep->length);
+	swapl(&rep->which);
+	swaps(&rep->virtualMods);
+	swapl(&rep->indicators);
     }
 
     start = desc = (char *)ALLOCATE_LOCAL(length);
@@ -3341,24 +3319,21 @@ char *			desc;
     if (which&XkbKeycodesNameMask) {
 	*((CARD32 *)desc)= xkb->names->keycodes;
 	if (client->swapped) {
-	    register int n;
-	    swapl(desc,n);
+	    swapl((int *)desc);
 	}
 	desc+= 4;
     }
     if (which&XkbGeometryNameMask)  {
 	*((CARD32 *)desc)= xkb->names->geometry;
 	if (client->swapped) {
-	    register int n;
-	    swapl(desc,n);
+	    swapl((int *)desc);
 	}
 	desc+= 4;
     }
     if (which&XkbSymbolsNameMask) {
 	*((CARD32 *)desc)= xkb->names->symbols;
 	if (client->swapped) {
-	    register int n;
-	    swapl(desc,n);
+	    swapl((int *)desc);
 	}
 	desc+= 4;
     }
@@ -3366,24 +3341,21 @@ char *			desc;
 	register CARD32 *atm= (CARD32 *)desc;
 	atm[0]= (CARD32)xkb->names->phys_symbols;
 	if (client->swapped) {
-	    register int n;
-	    swapl(&atm[0],n);
+	    swapl(&atm[0]);
 	}
 	desc+= 4;
     }
     if (which&XkbTypesNameMask) {
 	*((CARD32 *)desc)= (CARD32)xkb->names->types;
 	if (client->swapped) {
-	    register int n;
-	    swapl(desc,n);
+	    swapl((int *)desc);
 	}
 	desc+= 4;
     }
     if (which&XkbCompatNameMask) {
 	*((CARD32 *)desc)= (CARD32)xkb->names->compat;
 	if (client->swapped) {
-	    register int n;
-	    swapl(desc,n);
+	    swapl((int *)desc);
 	}
 	desc+= 4;
     }
@@ -3394,8 +3366,7 @@ char *			desc;
 	for (i=0;i<xkb->map->num_types;i++,atm++,type++) {
 	    *atm= (CARD32)type->name;
 	    if (client->swapped) {
-		register int n;
-		swapl(atm,n);
+		swapl(atm);
 	    }
 	}
 	desc= (char *)atm;
@@ -3416,8 +3387,7 @@ char *			desc;
 		for (l=0;l<type->num_levels;l++,atm++) {
 		    *atm= type->level_names[l];
 		    if (client->swapped) {
-			register unsigned n;
-			swapl(atm,n);
+			swapl(atm);
 		    }
 		}
 		desc+= type->num_levels*4;
@@ -3453,8 +3423,7 @@ char *			desc;
 	for (i=0;i<rep->nRadioGroups;i++,atm++) {
 	    *atm= (CARD32)xkb->names->radio_groups[i];
 	    if (client->swapped) {
-		register unsigned n;
-		swapl(atm,n);
+		swapl(atm);
 	    }
 	}
 	desc+= rep->nRadioGroups*4;
@@ -3515,8 +3484,7 @@ register int i;
 
     for (i=0;i<nAtoms;i++,wire++) {
 	if (swapped) {
-	    register int n;
-	    swapl(wire,n);
+	    swapl(wire);
 	}
 	if ((((Atom)*wire)!=None)&&(!ValidAtom((Atom)*wire))) {
 	    *pError= ((Atom)*wire);
@@ -3536,8 +3504,7 @@ register unsigned i,bit;
 	if ((present&bit)==0)
 	    continue;
 	if (swapped) {
-	    register int n;
-	    swapl(wire,n);
+	    swapl(wire);
 	}
 	if ((((Atom)*wire)!=None)&&(!ValidAtom(((Atom)*wire)))) {
 	    *pError= (Atom)*wire;
@@ -3930,8 +3897,7 @@ CARD16	len,*pLen;
     pLen= (CARD16 *)wire;
     *pLen= len;
     if (swap) {
-	register int n;
-	swaps(pLen,n);
+	swaps(pLen);
     }
     memcpy(&wire[2],str,len);
     wire+= ((2+len+3)/4)*4;
@@ -4046,8 +4012,7 @@ xkbShapeWireDesc *	shapeWire;
 	     shapeWire->approxNdx= XkbOutlineIndex(shape,shape->approx);
 	else shapeWire->approxNdx= XkbNoShape;
 	if (swap) {
-	    register int n;
-	    swapl(&shapeWire->name,n);
+	    swapl(&shapeWire->name);
 	}
 	wire= (char *)&shapeWire[1];
 	for (o=0,ol=shape->outlines;o<shape->num_outlines;o++,ol++) {
@@ -4063,9 +4028,8 @@ xkbShapeWireDesc *	shapeWire;
 		ptWire[p].x= pt->x;
 		ptWire[p].y= pt->y;
 		if (swap) {
-		    register int n;
-		    swaps(&ptWire[p].x,n);
-		    swaps(&ptWire[p].y,n);
+		    swaps(&ptWire[p].x);
+		    swaps(&ptWire[p].y);
 		}
 	    }
 	    wire= (char *)&ptWire[ol->num_points];
@@ -4108,10 +4072,9 @@ xkbDoodadWireDesc *	doodadWire;
 	doodadWire->any.top= doodad->any.top;
 	doodadWire->any.left= doodad->any.left;
 	if (swap) {
-	    register int n;
-	    swapl(&doodadWire->any.name,n);
-	    swaps(&doodadWire->any.top,n);
-	    swaps(&doodadWire->any.left,n);
+	    swapl(&doodadWire->any.name);
+	    swaps(&doodadWire->any.top);
+	    swaps(&doodadWire->any.left);
 	}
 	switch (doodad->any.type) {
 	    case XkbOutlineDoodad:
@@ -4120,8 +4083,7 @@ xkbDoodadWireDesc *	doodadWire;
 		doodadWire->shape.colorNdx= doodad->shape.color_ndx;
 		doodadWire->shape.shapeNdx= doodad->shape.shape_ndx;
 		if (swap) {
-		    register int n;
-		    swaps(&doodadWire->shape.angle,n);
+		    swaps(&doodadWire->shape.angle);
 		}
 		break;
 	    case XkbTextDoodad:
@@ -4130,10 +4092,9 @@ xkbDoodadWireDesc *	doodadWire;
 		doodadWire->text.height= doodad->text.height;
 		doodadWire->text.colorNdx= doodad->text.color_ndx;
 		if (swap) {
-		    register int n;
-		    swaps(&doodadWire->text.angle,n);
-		    swaps(&doodadWire->text.width,n);
-		    swaps(&doodadWire->text.height,n);
+		    swaps(&doodadWire->text.angle);
+		    swaps(&doodadWire->text.width);
+		    swaps(&doodadWire->text.height);
 		}
 		wire= XkbWriteCountedString(wire,doodad->text.text,swap);
 		wire= XkbWriteCountedString(wire,doodad->text.font,swap);
@@ -4171,8 +4132,7 @@ xkbOverlayWireDesc *	olWire;
    olWire->name= ol->name;
    olWire->nRows= ol->num_rows;
    if (swap) {
-	register int n;
-	swapl(&olWire->name,n);
+	swapl(&olWire->name);
    }
    wire= (char *)&olWire[1];
    for (r=0,row=ol->rows;r<ol->num_rows;r++,row++) {
@@ -4250,13 +4210,12 @@ xkbSectionWireDesc *	sectionWire;
 	sectionWire->nOverlays= section->num_overlays;
 	sectionWire->pad= 0;
 	if (swap) {
-	    register int n;
-	    swapl(&sectionWire->name,n);
-	    swaps(&sectionWire->top,n);
-	    swaps(&sectionWire->left,n);
-	    swaps(&sectionWire->width,n);
-	    swaps(&sectionWire->height,n);
-	    swaps(&sectionWire->angle,n);
+	    swapl(&sectionWire->name);
+	    swaps(&sectionWire->top);
+	    swaps(&sectionWire->left);
+	    swaps(&sectionWire->width);
+	    swaps(&sectionWire->height);
+	    swaps(&sectionWire->angle);
 	}
 	wire= (char *)&sectionWire[1];
 	if (section->rows) {
@@ -4271,9 +4230,8 @@ xkbSectionWireDesc *	sectionWire;
 		rowWire->vertical= row->vertical;
 		rowWire->pad= 0;
 		if (swap) {
-		    register int n;
-		    swaps(&rowWire->top,n);
-		    swaps(&rowWire->left,n);
+		    swaps(&rowWire->top);
+		    swaps(&rowWire->left);
 		}
 		wire= (char *)&rowWire[1];
 		if (row->keys) {
@@ -4287,8 +4245,7 @@ xkbSectionWireDesc *	sectionWire;
 			keyWire[k].shapeNdx= key->shape_ndx;
 			keyWire[k].colorNdx= key->color_ndx;
 			if (swap) {
-			    register int n;
-			    swaps(&keyWire[k].gap,n);
+			    swaps(&keyWire[k].gap);
 			}
 		    }
 		    wire= (char *)&keyWire[row->num_keys];
@@ -4390,18 +4347,17 @@ XkbSendGeometry(	ClientPtr		client,
 	start= NULL;
     }
     if (client->swapped) {
-	register int n;
-	swaps(&rep->sequenceNumber,n);
-	swapl(&rep->length,n);
-	swapl(&rep->name,n);
-	swaps(&rep->widthMM,n);
-	swaps(&rep->heightMM,n);
-	swaps(&rep->nProperties,n);
-	swaps(&rep->nColors,n);
-	swaps(&rep->nShapes,n);
-	swaps(&rep->nSections,n);
-	swaps(&rep->nDoodads,n);
-	swaps(&rep->nKeyAliases,n);
+	swaps(&rep->sequenceNumber);
+	swapl(&rep->length);
+	swapl(&rep->name);
+	swaps(&rep->widthMM);
+	swaps(&rep->heightMM);
+	swaps(&rep->nProperties);
+	swaps(&rep->nColors);
+	swaps(&rep->nShapes);
+	swaps(&rep->nSections);
+	swaps(&rep->nDoodads);
+	swaps(&rep->nKeyAliases);
     }
     WriteToClient(client, SIZEOF(xkbGetGeometryReply), (char *)rep);
     if (len>0)
@@ -4453,8 +4409,7 @@ CARD16	len;
     wire= *wire_inout;
     len= (CARD16 *)wire;
     if (client->swapped) {
-	register int n;
-	swaps(&len, n);
+	swaps(&len);
     }
     next = wire + XkbPaddedSize(len + 2);
     /* Check we're still within the size of the request */
@@ -4487,11 +4442,10 @@ Status			status;
     any = dWire->any;
     wire= (char *)&dWire[1];
     if (client->swapped) {
-	register int n;
-	swapl(&any.name, n);
-	swaps(&any.top, n);
-	swaps(&any.left, n);
-	swaps(&any.angle, n);
+	swapl(&any.name);
+	swaps(&any.top);
+	swaps(&any.left);
+	swaps(&any.angle);
     }
     CHK_ATOM_ONLY(dWire->any.name);
     doodad = XkbAddGeomDoodad(geom, section, any.name);
@@ -4526,9 +4480,8 @@ Status			status;
 	    }
 	    text = dWire->text;
 	    if (client->swapped) {
-		register int n;
-		swaps(&text.width, n);
-		swaps(&text.height, n);
+		swaps(&text.width);
+		swaps(&text.height);
 	    }
 	    doodad->text.width= text.width;
 	    doodad->text.height= text.height;
@@ -4602,8 +4555,7 @@ xkbOverlayRowWireDesc *	rWire;
     wire= *wire_inout;
     olWire= (xkbOverlayWireDesc *)wire;
     if (client->swapped) {
-	register int n;
-	swapl(&olWire->name,n);
+	swapl(&olWire->name);
     }
     CHK_ATOM_ONLY(olWire->name);
     ol= XkbAddGeomOverlay(section,olWire->name,olWire->nRows);
@@ -4655,13 +4607,12 @@ XkbSectionPtr		section;
 	register int		r;
 	xkbRowWireDesc *	rWire;
 	if (client->swapped) {
-	    register int n;
-	    swapl(&sWire->name,n);
-	    swaps(&sWire->top,n);
-	    swaps(&sWire->left,n);
-	    swaps(&sWire->width,n);
-	    swaps(&sWire->height,n);
-	    swaps(&sWire->angle,n);
+	    swapl(&sWire->name);
+	    swaps(&sWire->top);
+	    swaps(&sWire->left);
+	    swaps(&sWire->width);
+	    swaps(&sWire->height);
+	    swaps(&sWire->angle);
 	}
 	CHK_ATOM_ONLY(sWire->name);
 	section= XkbAddGeomSection(geom,sWire->name,sWire->nRows,
@@ -4680,9 +4631,8 @@ XkbSectionPtr		section;
 	    XkbRowPtr		row;
 	    xkbKeyWireDesc *	kWire;
 	    if (client->swapped) {
-		register int n;
-		swaps(&rWire->top,n);
-		swaps(&rWire->left,n);
+		swaps(&rWire->top);
+		swaps(&rWire->left);
 	    }
 	    row= XkbAddGeomRow(section,rWire->nKeys);
 	    if (!row)
@@ -4777,9 +4727,8 @@ char *		wire;
 		    pt->x= ptWire[p].x;
 		    pt->y= ptWire[p].y;
 		    if (client->swapped) {
-			register int n;
-			swaps(&pt->x,n);
-			swaps(&pt->y,n);
+			swaps(&pt->x);
+			swaps(&pt->y);
 		    }
 		}
 		ol->num_points= olWire->nPoints;
@@ -5022,12 +4971,11 @@ ProcXkbPerClientFlags(ClientPtr client)
 	rep.autoCtrls= rep.autoCtrlValues= 0;
     }
     if ( client->swapped ) {
-	register int n;
-	swaps(&rep.sequenceNumber, n);
-	swapl(&rep.supported,n);
-	swapl(&rep.value,n);
-	swapl(&rep.autoCtrls,n);
-	swapl(&rep.autoCtrlValues,n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.supported);
+	swapl(&rep.value);
+	swapl(&rep.autoCtrls);
+	swapl(&rep.autoCtrlValues);
     }
     WriteToClient(client,SIZEOF(xkbPerClientFlagsReply), (char *)&rep);
     return client->noClientException;
@@ -5148,16 +5096,15 @@ ProcXkbListComponents(ClientPtr client)
     if (list.nTotal>list.maxRtrn)
 	rep.extra = (list.nTotal-list.maxRtrn);
     if (client->swapped) {
-	register int n;
-	swaps(&rep.sequenceNumber,n);
-	swapl(&rep.length,n);
-	swaps(&rep.nKeymaps,n);
-	swaps(&rep.nKeycodes,n);
-	swaps(&rep.nTypes,n);
-	swaps(&rep.nCompatMaps,n);
-	swaps(&rep.nSymbols,n);
-	swaps(&rep.nGeometries,n);
-	swaps(&rep.extra,n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swaps(&rep.nKeymaps);
+	swaps(&rep.nKeycodes);
+	swaps(&rep.nTypes);
+	swaps(&rep.nCompatMaps);
+	swaps(&rep.nSymbols);
+	swaps(&rep.nGeometries);
+	swaps(&rep.extra);
     }
     WriteToClient(client,SIZEOF(xkbListComponentsReply),(char *)&rep);
     if (list.nPool && list.pool) {
@@ -5416,11 +5363,10 @@ ProcXkbGetKbdByName(ClientPtr client)
 
     reported= rep.reported;
     if ( client->swapped ) {
-	register int n;
-	swaps(&rep.sequenceNumber,n);
-	swapl(&rep.length,n);
-	swaps(&rep.found,n);
-	swaps(&rep.reported,n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swaps(&rep.found);
+	swaps(&rep.reported);
     }
     WriteToClient(client,SIZEOF(xkbGetKbdByNameReply), (char *)&rep);
     if (reported&(XkbGBN_SymbolsMask|XkbGBN_TypesMask))
@@ -5606,13 +5552,12 @@ int			length;
     wire.physIndicators= 	sli->physIndicators;
     wire.state=			sli->effectiveState;
     if (client->swapped) {
-	register int n;
-	swaps(&wire.ledClass,n);
-	swaps(&wire.ledID,n);
-	swapl(&wire.namesPresent,n);
-	swapl(&wire.mapsPresent,n);
-	swapl(&wire.physIndicators,n);
-	swapl(&wire.state,n);
+	swaps(&wire.ledClass);
+	swaps(&wire.ledID);
+	swapl(&wire.namesPresent);
+	swapl(&wire.mapsPresent);
+	swapl(&wire.physIndicators);
+	swapl(&wire.state);
     }
     WriteToClient(client,SIZEOF(xkbDeviceLedsWireDesc),(char *)&wire);
     length+= SIZEOF(xkbDeviceLedsWireDesc);
@@ -5624,8 +5569,7 @@ int			length;
 		if (sli->namesPresent&bit) {
 		    awire= (CARD32)sli->names[i];
 		    if (client->swapped) {
-			register int n;
-			swapl(&awire,n);
+			swapl(&awire);
 		    }
 		    WriteToClient(client,4,(char *)&awire);
 		    length+= 4;
@@ -5645,9 +5589,8 @@ int			length;
 		    iwire.virtualMods=	sli->maps[i].mods.vmods;
 		    iwire.ctrls= 	sli->maps[i].ctrls;
 		    if (client->swapped) {
-			register int n;
-			swaps(&iwire.virtualMods,n);
-			swapl(&iwire.ctrls,n);
+			swaps(&iwire.virtualMods);
+			swapl(&iwire.ctrls);
 		    }
 		    WriteToClient(client,SIZEOF(xkbIndicatorMapWireDesc),
 								(char *)&iwire);
@@ -5802,14 +5745,16 @@ char *			str;
     supported= rep.supported;
     nDeviceLedFBs = rep.nDeviceLedFBs;
     if (client->swapped) {
-	register int n;
-	swaps(&rep.sequenceNumber,n);
-	swapl(&rep.length,n);
-	swaps(&rep.present,n);
-	swaps(&rep.supported,n);
-	swaps(&rep.unsupported,n);
-	swaps(&rep.nDeviceLedFBs,n);
-	swapl(&rep.type,n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.length);
+	swaps(&rep.present);
+	swaps(&rep.supported);
+	swaps(&rep.unsupported);
+	swaps(&rep.nDeviceLedFBs);
+
+	// FIXME: rep.type here is an Atom... this might go terribly wrong...
+
+	swapl((int *)&rep.type);
     }
     WriteToClient(client,SIZEOF(xkbGetDeviceInfoReply), (char *)&rep);
 
@@ -5871,12 +5816,11 @@ XkbSrvLedInfoPtr 	sli;
     ledWire= (xkbDeviceLedsWireDesc *)wire;
     for (i=0;i<num;i++) {
 	if (client->swapped) {
-	   register int n;
-	   swaps(&ledWire->ledClass,n);
-	   swaps(&ledWire->ledID,n);
-	   swapl(&ledWire->namesPresent,n);
-	   swapl(&ledWire->mapsPresent,n);
-	   swapl(&ledWire->physIndicators,n);
+	   swaps(&ledWire->ledClass);
+	   swaps(&ledWire->ledID);
+	   swapl(&ledWire->namesPresent);
+	   swapl(&ledWire->mapsPresent);
+	   swapl(&ledWire->physIndicators);
 	}
 
         sli= XkbFindSrvLedInfo(dev,ledWire->ledClass,ledWire->ledID,
@@ -5899,8 +5843,7 @@ XkbSrvLedInfoPtr 	sli;
 	    if (nNames>0) {
 		for (n=0;n<nNames;n++) {
 		    if (client->swapped) {
-			register int t;
-			swapl(atomWire,t);
+			swapl(atomWire);
 		    }
 		    CHK_ATOM_OR_NONE3(((Atom)(*atomWire)),client->errorValue,
 							*status_rtrn,NULL);
@@ -5911,9 +5854,8 @@ XkbSrvLedInfoPtr 	sli;
 	    if (nMaps>0) {
 		for (n=0;n<nMaps;n++) {
 		    if (client->swapped) {
-			register int t;
-			swaps(&mapWire->virtualMods,t);
-			swapl(&mapWire->ctrls,t);
+			swaps(&mapWire->virtualMods);
+			swapl(&mapWire->ctrls);
 		    }
 		    CHK_MASK_LEGAL3(0x21,mapWire->whichGroups,
 						XkbIM_UseAnyGroup,
@@ -6165,12 +6107,11 @@ xkbSetDebuggingFlagsReply 	rep;
     rep.supportedFlags = ~0;
     rep.supportedCtrls = ~0;
     if ( client->swapped ) {
-	register int n;
-	swaps(&rep.sequenceNumber, n);
-	swapl(&rep.currentFlags, n);
-	swapl(&rep.currentCtrls, n);
-	swapl(&rep.supportedFlags, n);
-	swapl(&rep.supportedCtrls, n);
+	swaps(&rep.sequenceNumber);
+	swapl(&rep.currentFlags);
+	swapl(&rep.currentCtrls);
+	swapl(&rep.supportedFlags);
+	swapl(&rep.supportedCtrls);
     }
     WriteToClient(client,SIZEOF(xkbSetDebuggingFlagsReply), (char *)&rep);
     return client->noClientException;
diff --git a/nx-X11/programs/Xserver/xkb/xkbEvents.c b/nx-X11/programs/Xserver/xkb/xkbEvents.c
index 6c0aa0761..c36653f2e 100644
--- a/nx-X11/programs/Xserver/xkb/xkbEvents.c
+++ b/nx-X11/programs/Xserver/xkb/xkbEvents.c
@@ -67,10 +67,9 @@ CARD16		changed;
 		pNKN->time = time;
 		pNKN->changed = changed;
 		if ( clients[i]->swapped ) {
-		    register int n;
-		    swaps(&pNKN->sequenceNumber,n);
-		    swapl(&pNKN->time,n);
-		    swaps(&pNKN->changed,n);
+		    swaps(&pNKN->sequenceNumber);
+		    swapl(&pNKN->time);
+		    swaps(&pNKN->changed);
 		}
 		WriteToClient(clients[i],sizeof(xEvent),(char *)pNKN);
 		if (changed&XkbNKN_KeycodesMask) {
@@ -87,8 +86,7 @@ CARD16		changed;
 	    event.u.mappingNotify.count= clients[i]->maxKC-clients[i]->minKC+1;
 	    event.u.u.sequenceNumber= clients[i]->sequence;
 	    if (clients[i]->swapped) {
-		int n;
-		swaps(&event.u.u.sequenceNumber,n);
+		swaps(&event.u.u.sequenceNumber);
 	    }
 	    WriteToClient(clients[i],SIZEOF(xEvent), (char *)&event);
 	    event.u.mappingNotify.request= MappingModifier;
@@ -146,11 +144,10 @@ register CARD16	changed,bState;
 	    pSN->changed = changed;
 	    pSN->ptrBtnState = bState;
 	    if ( interest->client->swapped ) {
-		register int n;
-		swaps(&pSN->sequenceNumber,n);
-		swapl(&pSN->time,n);
-		swaps(&pSN->changed,n);
-		swaps(&pSN->ptrBtnState,n);
+		swaps(&pSN->sequenceNumber);
+		swapl(&pSN->time);
+		swaps(&pSN->changed);
+		swaps(&pSN->ptrBtnState);
 	    }
 	    WriteToClient(interest->client, sizeof(xEvent), (char *)pSN);
 	}
@@ -192,10 +189,9 @@ CARD16		changed;
 	    pMN->sequenceNumber = clients[i]->sequence;
 	    pMN->changed = changed;
 	    if ( clients[i]->swapped ) {
-		register int n;
-		swaps(&pMN->sequenceNumber,n);
-		swapl(&pMN->time,n);
-		swaps(&pMN->changed,n);
+		swaps(&pMN->sequenceNumber);
+		swapl(&pMN->time);
+		swaps(&pMN->changed);
 	    }
 	    WriteToClient(clients[i],sizeof(xEvent),(char *)pMN);
 	}
@@ -315,12 +311,11 @@ Time 		 	time = 0;
 	    pCN->sequenceNumber = interest->client->sequence;
 	    pCN->time = time;
 	    if ( interest->client->swapped ) {
-		register int n;
-		swaps(&pCN->sequenceNumber,n);
-		swapl(&pCN->changedControls,n);
-		swapl(&pCN->enabledControls,n);
-		swapl(&pCN->enabledControlChanges,n);
-		swapl(&pCN->time,n);
+		swaps(&pCN->sequenceNumber);
+		swapl(&pCN->changedControls);
+		swapl(&pCN->enabledControls);
+		swapl(&pCN->enabledControlChanges);
+		swapl(&pCN->time);
 	    }
 	    WriteToClient(interest->client, sizeof(xEvent), (char *)pCN);
 	}
@@ -364,11 +359,10 @@ CARD32		state,changed;
 	    pEv->changed = changed;
 	    pEv->state = state;
 	    if ( interest->client->swapped ) {
-		register int n;
-		swaps(&pEv->sequenceNumber,n);
-		swapl(&pEv->time,n);
-		swapl(&pEv->changed,n);
-		swapl(&pEv->state,n);
+		swaps(&pEv->sequenceNumber);
+		swapl(&pEv->time);
+		swapl(&pEv->changed);
+		swapl(&pEv->state);
 	    }
 	    WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
 	}
@@ -447,13 +441,12 @@ XID		winID = 0;
 	    bn.name = name;
 	    bn.window=  winID;
 	    if ( interest->client->swapped ) {
-		register int n;
-		swaps(&bn.sequenceNumber,n);
-		swapl(&bn.time,n);
-		swaps(&bn.pitch,n);
-		swaps(&bn.duration,n);
-		swapl(&bn.name,n);
-		swapl(&bn.window,n);
+		swaps(&bn.sequenceNumber);
+		swapl(&bn.time);
+		swaps(&bn.pitch);
+		swaps(&bn.duration);
+		swapl(&bn.name);
+		swapl(&bn.window);
 	    }
 	    WriteToClient(interest->client, sizeof(xEvent), (char *)&bn);
 	}
@@ -494,11 +487,10 @@ CARD16		sk_delay,db_delay;
 	    pEv->slowKeysDelay = sk_delay;
 	    pEv->debounceDelay = db_delay;
 	    if ( interest->client->swapped ) {
-		register int n;
-		swaps(&pEv->sequenceNumber,n);
-		swapl(&pEv->time,n);
-		swaps(&pEv->slowKeysDelay,n);
-		swaps(&pEv->debounceDelay,n);
+		swaps(&pEv->sequenceNumber);
+		swapl(&pEv->time);
+		swaps(&pEv->slowKeysDelay);
+		swaps(&pEv->debounceDelay);
 	    }
 	    WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
 	}
@@ -542,12 +534,11 @@ CARD32		changedIndicators;
 	    pEv->changedIndicators = changedIndicators;
 	    pEv->changedVirtualMods= changedVirtualMods;
 	    if ( interest->client->swapped ) {
-		register int n;
-		swaps(&pEv->sequenceNumber,n);
-		swapl(&pEv->time,n);
-		swaps(&pEv->changed,n);
-		swapl(&pEv->changedIndicators,n);
-		swaps(&pEv->changedVirtualMods,n);
+		swaps(&pEv->sequenceNumber);
+		swapl(&pEv->time);
+		swaps(&pEv->changed);
+		swapl(&pEv->changedIndicators);
+		swaps(&pEv->changedVirtualMods);
 	    }
 	    WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
 	}
@@ -590,12 +581,11 @@ CARD16		firstSI = 0, nSI = 0, nTotalSI = 0;
 	    pEv->nSI = nSI;
 	    pEv->nTotalSI = nTotalSI;
 	    if ( interest->client->swapped ) {
-		register int n;
-		swaps(&pEv->sequenceNumber,n);
-		swapl(&pEv->time,n);
-		swaps(&pEv->firstSI,n);
-		swaps(&pEv->nSI,n);
-		swaps(&pEv->nTotalSI,n);
+		swaps(&pEv->sequenceNumber);
+		swapl(&pEv->time);
+		swaps(&pEv->firstSI);
+		swaps(&pEv->nSI);
+		swaps(&pEv->nTotalSI);
 	    }
 	    WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
 	}
@@ -636,9 +626,8 @@ Time 		 time = 0;
 	    pEv->sequenceNumber = interest->client->sequence;
 	    pEv->time = time;
 	    if ( interest->client->swapped ) {
-		register int n;
-		swaps(&pEv->sequenceNumber,n);
-		swapl(&pEv->time,n);
+		swaps(&pEv->sequenceNumber);
+		swapl(&pEv->time);
 	    }
 	    WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
 	}
@@ -696,13 +685,12 @@ CARD16		 reason, supported = 0;
 		    continue;
 	    }
 	    if ( interest->client->swapped ) {
-		register int n;
-		swaps(&pEv->sequenceNumber,n);
-		swapl(&pEv->time,n);
-		swapl(&pEv->ledsDefined,n);
-		swapl(&pEv->ledState,n);
-		swaps(&pEv->reason,n);
-		swaps(&pEv->supported,n);
+		swaps(&pEv->sequenceNumber);
+		swapl(&pEv->time);
+		swapl(&pEv->ledsDefined);
+		swapl(&pEv->ledState);
+		swaps(&pEv->reason);
+		swaps(&pEv->supported);
 	    }
 	    WriteToClient(interest->client, sizeof(xEvent), (char *)pEv);
 	}
diff --git a/nx-X11/programs/Xserver/xkb/xkbSwap.c b/nx-X11/programs/Xserver/xkb/xkbSwap.c
index c16209153..1aaff519e 100644
--- a/nx-X11/programs/Xserver/xkb/xkbSwap.c
+++ b/nx-X11/programs/Xserver/xkb/xkbSwap.c
@@ -48,32 +48,30 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 static int
 SProcXkbUseExtension(ClientPtr client)
 {
-register int n;
 
     REQUEST(xkbUseExtensionReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xkbUseExtensionReq);
-    swaps(&stuff->wantedMajor,n);
-    swaps(&stuff->wantedMinor,n);
+    swaps(&stuff->wantedMajor);
+    swaps(&stuff->wantedMinor);
     return ProcXkbUseExtension(client);
 }
 
 static int
 SProcXkbSelectEvents(ClientPtr client)
 {
-register int n;
 
     REQUEST(xkbSelectEventsReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xkbSelectEventsReq);
-    swaps(&stuff->deviceSpec,n);
-    swaps(&stuff->affectWhich,n);
-    swaps(&stuff->clear,n);
-    swaps(&stuff->selectAll,n);
-    swaps(&stuff->affectMap,n);
-    swaps(&stuff->map,n);
+    swaps(&stuff->deviceSpec);
+    swaps(&stuff->affectWhich);
+    swaps(&stuff->clear);
+    swaps(&stuff->selectAll);
+    swaps(&stuff->affectMap);
+    swaps(&stuff->map);
     if ((stuff->affectWhich&(~XkbMapNotifyMask))!=0)  {
 	union {
 	    BOOL	*b;
@@ -117,12 +115,12 @@ register int n;
 	    if (dataLeft<(size*2))
 		return BadLength;
 	    if (size==2) {
-		swaps(&from.c16[0],n);
-		swaps(&from.c16[1],n);
+		swaps(&from.c16[0]);
+		swaps(&from.c16[1]);
 	    }
 	    else if (size==4) {
-		swapl(&from.c32[0],n);
-		swapl(&from.c32[1],n);
+		swapl(&from.c32[0]);
+		swapl(&from.c32[1]);
 	    }
 	    else {
 		size= 2;
@@ -141,128 +139,114 @@ register int n;
 static int
 SProcXkbBell(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbBellReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xkbBellReq);
-    swaps(&stuff->deviceSpec,n);
-    swaps(&stuff->bellClass,n);
-    swaps(&stuff->bellID,n);
-    swapl(&stuff->name,n);
-    swapl(&stuff->window,n);
-    swaps(&stuff->pitch,n);
-    swaps(&stuff->duration,n);
+    swaps(&stuff->deviceSpec);
+    swaps(&stuff->bellClass);
+    swaps(&stuff->bellID);
+    swapl(&stuff->name);
+    swapl(&stuff->window);
+    swaps(&stuff->pitch);
+    swaps(&stuff->duration);
     return ProcXkbBell(client);
 }
 
 static int
 SProcXkbGetState(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbGetStateReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xkbGetStateReq);
-    swaps(&stuff->deviceSpec,n);
+    swaps(&stuff->deviceSpec);
     return ProcXkbGetState(client);
 }
 
 static int
 SProcXkbLatchLockState(ClientPtr client)
 {
-register int 	n;
-
     REQUEST(xkbLatchLockStateReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xkbLatchLockStateReq);
-    swaps(&stuff->deviceSpec,n);
-    swaps(&stuff->groupLatch,n);
+    swaps(&stuff->deviceSpec);
+    swaps(&stuff->groupLatch);
     return ProcXkbLatchLockState(client);
 }
 
 static int
 SProcXkbGetControls(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbGetControlsReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xkbGetControlsReq);
-    swaps(&stuff->deviceSpec,n);
+    swaps(&stuff->deviceSpec);
     return ProcXkbGetControls(client);
 }
 
 static int
 SProcXkbSetControls(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbSetControlsReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xkbSetControlsReq);
-    swaps(&stuff->deviceSpec,n);
-    swaps(&stuff->affectInternalVMods,n);
-    swaps(&stuff->internalVMods,n);
-    swaps(&stuff->affectIgnoreLockVMods,n);
-    swaps(&stuff->ignoreLockVMods,n);
-    swaps(&stuff->axOptions,n);
-    swapl(&stuff->affectEnabledCtrls,n);
-    swapl(&stuff->enabledCtrls,n);
-    swapl(&stuff->changeCtrls,n);
-    swaps(&stuff->repeatDelay,n);
-    swaps(&stuff->repeatInterval,n);
-    swaps(&stuff->slowKeysDelay,n);
-    swaps(&stuff->debounceDelay,n);
-    swaps(&stuff->mkDelay,n);
-    swaps(&stuff->mkInterval,n);
-    swaps(&stuff->mkTimeToMax,n);
-    swaps(&stuff->mkMaxSpeed,n);
-    swaps(&stuff->mkCurve,n);
-    swaps(&stuff->axTimeout,n);
-    swapl(&stuff->axtCtrlsMask,n);
-    swapl(&stuff->axtCtrlsValues,n);
-    swaps(&stuff->axtOptsMask,n);
-    swaps(&stuff->axtOptsValues,n);
+    swaps(&stuff->deviceSpec);
+    swaps(&stuff->affectInternalVMods);
+    swaps(&stuff->internalVMods);
+    swaps(&stuff->affectIgnoreLockVMods);
+    swaps(&stuff->ignoreLockVMods);
+    swaps(&stuff->axOptions);
+    swapl(&stuff->affectEnabledCtrls);
+    swapl(&stuff->enabledCtrls);
+    swapl(&stuff->changeCtrls);
+    swaps(&stuff->repeatDelay);
+    swaps(&stuff->repeatInterval);
+    swaps(&stuff->slowKeysDelay);
+    swaps(&stuff->debounceDelay);
+    swaps(&stuff->mkDelay);
+    swaps(&stuff->mkInterval);
+    swaps(&stuff->mkTimeToMax);
+    swaps(&stuff->mkMaxSpeed);
+    swaps(&stuff->mkCurve);
+    swaps(&stuff->axTimeout);
+    swapl(&stuff->axtCtrlsMask);
+    swapl(&stuff->axtCtrlsValues);
+    swaps(&stuff->axtOptsMask);
+    swaps(&stuff->axtOptsValues);
     return ProcXkbSetControls(client);
 }
 
 static int
 SProcXkbGetMap(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbGetMapReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xkbGetMapReq);
-    swaps(&stuff->deviceSpec,n);
-    swaps(&stuff->full,n);
-    swaps(&stuff->partial,n);
-    swaps(&stuff->virtualMods,n);
+    swaps(&stuff->deviceSpec);
+    swaps(&stuff->full);
+    swaps(&stuff->partial);
+    swaps(&stuff->virtualMods);
     return ProcXkbGetMap(client);
 }
 
 static int
 SProcXkbSetMap(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbSetMapReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xkbSetMapReq);
-    swaps(&stuff->deviceSpec,n);
-    swaps(&stuff->present,n);
-    swaps(&stuff->flags,n);
-    swaps(&stuff->totalSyms,n);
-    swaps(&stuff->totalActs,n);
-    swaps(&stuff->virtualMods,n);
+    swaps(&stuff->deviceSpec);
+    swaps(&stuff->present);
+    swaps(&stuff->flags);
+    swaps(&stuff->totalSyms);
+    swaps(&stuff->totalActs);
+    swaps(&stuff->virtualMods);
     return ProcXkbSetMap(client);
 }
 
@@ -270,105 +254,91 @@ register int	n;
 static int
 SProcXkbGetCompatMap(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbGetCompatMapReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xkbGetCompatMapReq);
-    swaps(&stuff->deviceSpec,n);
-    swaps(&stuff->firstSI,n);
-    swaps(&stuff->nSI,n);
+    swaps(&stuff->deviceSpec);
+    swaps(&stuff->firstSI);
+    swaps(&stuff->nSI);
     return ProcXkbGetCompatMap(client);
 }
 
 static int
 SProcXkbSetCompatMap(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbSetCompatMapReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xkbSetCompatMapReq);
-    swaps(&stuff->deviceSpec,n);
-    swaps(&stuff->firstSI,n);
-    swaps(&stuff->nSI,n);
+    swaps(&stuff->deviceSpec);
+    swaps(&stuff->firstSI);
+    swaps(&stuff->nSI);
     return ProcXkbSetCompatMap(client);
 }
 
 static int
 SProcXkbGetIndicatorState(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbGetIndicatorStateReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xkbGetIndicatorStateReq);
-    swaps(&stuff->deviceSpec,n);
+    swaps(&stuff->deviceSpec);
     return ProcXkbGetIndicatorState(client);
 }
 
 static int
 SProcXkbGetIndicatorMap(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbGetIndicatorMapReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xkbGetIndicatorMapReq);
-    swaps(&stuff->deviceSpec,n);
-    swapl(&stuff->which,n);
+    swaps(&stuff->deviceSpec);
+    swapl(&stuff->which);
     return ProcXkbGetIndicatorMap(client);
 }
 
 static int
 SProcXkbSetIndicatorMap(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbSetIndicatorMapReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xkbSetIndicatorMapReq);
-    swaps(&stuff->deviceSpec,n);
-    swapl(&stuff->which,n);
+    swaps(&stuff->deviceSpec);
+    swapl(&stuff->which);
     return ProcXkbSetIndicatorMap(client);
 }
 
 static int
 SProcXkbGetNamedIndicator(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbGetNamedIndicatorReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xkbGetNamedIndicatorReq);
-    swaps(&stuff->deviceSpec,n);
-    swaps(&stuff->ledClass,n);
-    swaps(&stuff->ledID,n);
-    swapl(&stuff->indicator,n);
+    swaps(&stuff->deviceSpec);
+    swaps(&stuff->ledClass);
+    swaps(&stuff->ledID);
+    swapl(&stuff->indicator);
     return ProcXkbGetNamedIndicator(client);
 }
 
 static int
 SProcXkbSetNamedIndicator(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbSetNamedIndicatorReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xkbSetNamedIndicatorReq);
-    swaps(&stuff->deviceSpec,n);
-    swaps(&stuff->ledClass,n);
-    swaps(&stuff->ledID,n);
-    swapl(&stuff->indicator,n);
-    swaps(&stuff->virtualMods,n);
-    swapl(&stuff->ctrls,n);
+    swaps(&stuff->deviceSpec);
+    swaps(&stuff->ledClass);
+    swaps(&stuff->ledID);
+    swapl(&stuff->indicator);
+    swaps(&stuff->virtualMods);
+    swapl(&stuff->ctrls);
     return ProcXkbSetNamedIndicator(client);
 }
 
@@ -376,160 +346,140 @@ register int	n;
 static int
 SProcXkbGetNames(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbGetNamesReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xkbGetNamesReq);
-    swaps(&stuff->deviceSpec,n);
-    swapl(&stuff->which,n);
+    swaps(&stuff->deviceSpec);
+    swapl(&stuff->which);
     return ProcXkbGetNames(client);
 }
 
 static int
 SProcXkbSetNames(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbSetNamesReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xkbSetNamesReq);
-    swaps(&stuff->deviceSpec,n);
-    swaps(&stuff->virtualMods,n);
-    swapl(&stuff->which,n);
-    swapl(&stuff->indicators,n);
-    swaps(&stuff->totalKTLevelNames,n);
+    swaps(&stuff->deviceSpec);
+    swaps(&stuff->virtualMods);
+    swapl(&stuff->which);
+    swapl(&stuff->indicators);
+    swaps(&stuff->totalKTLevelNames);
     return ProcXkbSetNames(client);
 }
 
 static int
 SProcXkbGetGeometry(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbGetGeometryReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xkbGetGeometryReq);
-    swaps(&stuff->deviceSpec,n);
-    swapl(&stuff->name,n);
+    swaps(&stuff->deviceSpec);
+    swapl(&stuff->name);
     return ProcXkbGetGeometry(client);
 }
 
 static int
 SProcXkbSetGeometry(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbSetGeometryReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xkbSetGeometryReq);
-    swaps(&stuff->deviceSpec,n);
-    swapl(&stuff->name,n);
-    swaps(&stuff->widthMM,n);
-    swaps(&stuff->heightMM,n);
-    swaps(&stuff->nProperties,n);
-    swaps(&stuff->nColors,n);
-    swaps(&stuff->nDoodads,n);
-    swaps(&stuff->nKeyAliases,n);
+    swaps(&stuff->deviceSpec);
+    swapl(&stuff->name);
+    swaps(&stuff->widthMM);
+    swaps(&stuff->heightMM);
+    swaps(&stuff->nProperties);
+    swaps(&stuff->nColors);
+    swaps(&stuff->nDoodads);
+    swaps(&stuff->nKeyAliases);
     return ProcXkbSetGeometry(client);
 }
 
 static int
 SProcXkbPerClientFlags(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbPerClientFlagsReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xkbPerClientFlagsReq);
-    swaps(&stuff->deviceSpec,n);
-    swapl(&stuff->change,n);
-    swapl(&stuff->value,n);
-    swapl(&stuff->ctrlsToChange,n);
-    swapl(&stuff->autoCtrls,n);
-    swapl(&stuff->autoCtrlValues,n);
+    swaps(&stuff->deviceSpec);
+    swapl(&stuff->change);
+    swapl(&stuff->value);
+    swapl(&stuff->ctrlsToChange);
+    swapl(&stuff->autoCtrls);
+    swapl(&stuff->autoCtrlValues);
     return ProcXkbPerClientFlags(client);
 }
 
 static int
 SProcXkbListComponents(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbListComponentsReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xkbListComponentsReq);
-    swaps(&stuff->deviceSpec,n);
-    swaps(&stuff->maxNames,n);
+    swaps(&stuff->deviceSpec);
+    swaps(&stuff->maxNames);
     return ProcXkbListComponents(client);
 }
 
 static int
 SProcXkbGetKbdByName(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbGetKbdByNameReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xkbGetKbdByNameReq);
-    swaps(&stuff->deviceSpec,n);
-    swaps(&stuff->want,n);
-    swaps(&stuff->need,n);
+    swaps(&stuff->deviceSpec);
+    swaps(&stuff->want);
+    swaps(&stuff->need);
     return ProcXkbGetKbdByName(client);
 }
 
 static int
 SProcXkbGetDeviceInfo(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbGetDeviceInfoReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xkbGetDeviceInfoReq);
-    swaps(&stuff->deviceSpec,n);
-    swaps(&stuff->wanted,n);
-    swaps(&stuff->ledClass,n);
-    swaps(&stuff->ledID,n);
+    swaps(&stuff->deviceSpec);
+    swaps(&stuff->wanted);
+    swaps(&stuff->ledClass);
+    swaps(&stuff->ledID);
     return ProcXkbGetDeviceInfo(client);
 }
 
 static int
 SProcXkbSetDeviceInfo(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbSetDeviceInfoReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xkbSetDeviceInfoReq);
-    swaps(&stuff->deviceSpec,n);
-    swaps(&stuff->change,n);
-    swaps(&stuff->nDeviceLedFBs,n);
+    swaps(&stuff->deviceSpec);
+    swaps(&stuff->change);
+    swaps(&stuff->nDeviceLedFBs);
     return ProcXkbSetDeviceInfo(client);
 }
 
 static int
 SProcXkbSetDebuggingFlags(ClientPtr client)
 {
-register int	n;
-
     REQUEST(xkbSetDebuggingFlagsReq);
 
-    swaps(&stuff->length,n);
+    swaps(&stuff->length);
     REQUEST_AT_LEAST_SIZE(xkbSetDebuggingFlagsReq);
-    swapl(&stuff->affectFlags,n);
-    swapl(&stuff->flags,n);
-    swapl(&stuff->affectCtrls,n);
-    swapl(&stuff->ctrls,n);
-    swaps(&stuff->msgLength,n);
+    swapl(&stuff->affectFlags);
+    swapl(&stuff->flags);
+    swapl(&stuff->affectCtrls);
+    swapl(&stuff->ctrls);
+    swaps(&stuff->msgLength);
     return ProcXkbSetDebuggingFlags(client);
 }
 
-- 
cgit v1.2.3


From 9ea88717db376b54b2c821ab67e846918acc616a Mon Sep 17 00:00:00 2001
From: Jamey Sharp <jamey@minilop.net>
Date: Sun, 3 Jul 2016 22:06:43 +0200
Subject: Make WriteEventsToClient/WriteToClient no-op on fake or dead clients.

 This matches the test in TryClientEvents, and is a superset of tests
 done by the callers of these functions. The consequence of forgetting
 these tests is a server crash, so they're always desirable. In my
 opinion, it's better to not require the callers to remember to do these
 checks.

 For callers that don't do very much work before calling WriteToClient or
 WriteEventsToClient, I've removed the redundant checks.

 Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=27497
 Signed-off-by: Jamey Sharp <jamey@minilop.net>
 Cc: Chris Wilson <chris@chris-wilson.co.uk>
 Reviewed-by: Julien Cristau <jcristau@debian.org>
 Reviewed-by: Adam Jackson <ajax@redhat.com>
 Backport to nx-libs: Mike Gabriel <mike.gabriel@das-netzwerkteam.de>
---
 nx-X11/programs/Xserver/Xext/saver.c          |  2 --
 nx-X11/programs/Xserver/Xext/security.c       | 14 +++++---------
 nx-X11/programs/Xserver/Xext/shape.c          |  2 --
 nx-X11/programs/Xserver/Xext/sync.c           |  9 +++------
 nx-X11/programs/Xserver/damageext/damageext.c |  6 ++----
 nx-X11/programs/Xserver/dix/events.c          |  3 +++
 nx-X11/programs/Xserver/os/io.c               |  8 +++++---
 nx-X11/programs/Xserver/xfixes/cursor.c       |  3 +--
 nx-X11/programs/Xserver/xfixes/select.c       |  3 +--
 9 files changed, 20 insertions(+), 30 deletions(-)

(limited to 'nx-X11/programs/Xserver/xfixes/select.c')

diff --git a/nx-X11/programs/Xserver/Xext/saver.c b/nx-X11/programs/Xserver/Xext/saver.c
index 10bb2dc2f..0c5d28eb2 100644
--- a/nx-X11/programs/Xserver/Xext/saver.c
+++ b/nx-X11/programs/Xserver/Xext/saver.c
@@ -467,8 +467,6 @@ SendScreenSaverNotify (pScreen, state, forced)
     for (pEv = pPriv->events; pEv; pEv = pEv->next)
     {
 	client = pEv->client;
-	if (client->clientGone)
-	    continue;
 	if (!(pEv->mask & mask))
 	    continue;
 	ev.type = ScreenSaverNotify + ScreenSaverEventBase;
diff --git a/nx-X11/programs/Xserver/Xext/security.c b/nx-X11/programs/Xserver/Xext/security.c
index fe741128e..4f055ffe0 100644
--- a/nx-X11/programs/Xserver/Xext/security.c
+++ b/nx-X11/programs/Xserver/Xext/security.c
@@ -310,15 +310,11 @@ SecurityDeleteAuthorization(
     {
 	/* send revocation event event */
 	ClientPtr client = rClient(pEventClient);
-
-	if (!client->clientGone)
-	{
-	    xSecurityAuthorizationRevokedEvent are;
-	    are.type = SecurityEventBase + XSecurityAuthorizationRevoked;
-	    are.sequenceNumber = client->sequence;
-	    are.authId = pAuth->id;
-	    WriteEventsToClient(client, 1, (xEvent *)&are);
-	}
+	xSecurityAuthorizationRevokedEvent are;
+	are.type = SecurityEventBase + XSecurityAuthorizationRevoked;
+	are.sequenceNumber = client->sequence;
+	are.authId = pAuth->id;
+	WriteEventsToClient(client, 1, (xEvent *)&are);
 	FreeResource(pEventClient->resource, RT_NONE);
     }
 
diff --git a/nx-X11/programs/Xserver/Xext/shape.c b/nx-X11/programs/Xserver/Xext/shape.c
index 76d1fdd77..80ef71f67 100644
--- a/nx-X11/programs/Xserver/Xext/shape.c
+++ b/nx-X11/programs/Xserver/Xext/shape.c
@@ -969,8 +969,6 @@ SendShapeNotify (pWin, which)
     }
     for (pShapeEvent = *pHead; pShapeEvent; pShapeEvent = pShapeEvent->next) {
 	client = pShapeEvent->client;
-	if (client == serverClient || client->clientGone)
-	    continue;
 	se.type = ShapeNotify + ShapeEventBase;
 	se.kind = which;
 	se.window = pWin->drawable.id;
diff --git a/nx-X11/programs/Xserver/Xext/sync.c b/nx-X11/programs/Xserver/Xext/sync.c
index 222ef0353..3eb45a246 100644
--- a/nx-X11/programs/Xserver/Xext/sync.c
+++ b/nx-X11/programs/Xserver/Xext/sync.c
@@ -563,17 +563,14 @@ SyncSendAlarmNotifyEvents(pAlarm)
     ane.state = pAlarm->state;
 
     /* send to owner */
-    if (pAlarm->events && !pAlarm->client->clientGone) 
+    if (pAlarm->events)
 	WriteEventsToClient(pAlarm->client, 1, (xEvent *) &ane);
 
     /* send to other interested clients */
     for (pcl = pAlarm->pEventClients; pcl; pcl = pcl->next)
     {
-	if (!pAlarm->client->clientGone)
-	{
-	    ane.sequenceNumber = pcl->client->sequence;
-	    WriteEventsToClient(pcl->client, 1, (xEvent *) &ane);
-	}
+	ane.sequenceNumber = pcl->client->sequence;
+	WriteEventsToClient(pcl->client, 1, (xEvent *) &ane);
     }
 }
 
diff --git a/nx-X11/programs/Xserver/damageext/damageext.c b/nx-X11/programs/Xserver/damageext/damageext.c
index b2ee82657..9ab5b6ad6 100755
--- a/nx-X11/programs/Xserver/damageext/damageext.c
+++ b/nx-X11/programs/Xserver/damageext/damageext.c
@@ -69,8 +69,7 @@ DamageExtNotify (DamageExtPtr pDamageExt, BoxPtr pBoxes, int nBoxes)
 	    ev.area.y = pBoxes[i].y1;
 	    ev.area.width = pBoxes[i].x2 - pBoxes[i].x1;
 	    ev.area.height = pBoxes[i].y2 - pBoxes[i].y1;
-	    if (!pClient->clientGone)
-		WriteEventsToClient (pClient, 1, (xEvent *) &ev);
+	    WriteEventsToClient (pClient, 1, (xEvent *) &ev);
 	}
     }
     else
@@ -79,8 +78,7 @@ DamageExtNotify (DamageExtPtr pDamageExt, BoxPtr pBoxes, int nBoxes)
 	ev.area.y = 0;
 	ev.area.width = pDrawable->width;
 	ev.area.height = pDrawable->height;
-	if (!pClient->clientGone)
-	    WriteEventsToClient (pClient, 1, (xEvent *) &ev);
+	WriteEventsToClient (pClient, 1, (xEvent *) &ev);
     }
     /* Composite extension marks clients with manual Subwindows as critical */
     if (pDamageClient->critical > 0)
diff --git a/nx-X11/programs/Xserver/dix/events.c b/nx-X11/programs/Xserver/dix/events.c
index 676640f01..4d1472cc8 100644
--- a/nx-X11/programs/Xserver/dix/events.c
+++ b/nx-X11/programs/Xserver/dix/events.c
@@ -4439,6 +4439,9 @@ WriteEventsToClient(ClientPtr pClient, int count, xEvent *events)
     xEvent    eventTo, *eventFrom;
     int       i;
 
+    if (!pClient || pClient == serverClient || pClient->clientGone)
+	return;
+
 #ifdef XKB
     if ((!noXkbExtension)&&(!XkbFilterEvents(pClient, count, events)))
 	return;
diff --git a/nx-X11/programs/Xserver/os/io.c b/nx-X11/programs/Xserver/os/io.c
index 234ce8b58..4d12c6e89 100644
--- a/nx-X11/programs/Xserver/os/io.c
+++ b/nx-X11/programs/Xserver/os/io.c
@@ -859,14 +859,16 @@ SetCriticalOutputPending(void)
 int
 WriteToClient (ClientPtr who, int count, char *buf)
 {
-    OsCommPtr oc = (OsCommPtr)who->osPrivate;
-    ConnectionOutputPtr oco = oc->output;
+    OsCommPtr oc;
+    ConnectionOutputPtr oco;
     int padBytes;
 #ifdef DEBUG_COMMUNICATION
     Bool multicount = FALSE;
 #endif
-    if (!count)
+    if (!count || !who || who == serverClient || who->clientGone)
 	return(0);
+    oc = who->osPrivate;
+    oco = oc->output;
 #ifdef DEBUG_COMMUNICATION
     {
 	char info[128];
diff --git a/nx-X11/programs/Xserver/xfixes/cursor.c b/nx-X11/programs/Xserver/xfixes/cursor.c
index 29c6061d6..747471e18 100755
--- a/nx-X11/programs/Xserver/xfixes/cursor.c
+++ b/nx-X11/programs/Xserver/xfixes/cursor.c
@@ -96,8 +96,7 @@ CursorDisplayCursor (ScreenPtr pScreen,
 	CursorCurrent = pCursor;
 	for (e = cursorEvents; e; e = e->next)
 	{
-	    if ((e->eventMask & XFixesDisplayCursorNotifyMask) &&
-		!e->pClient->clientGone)
+	    if ((e->eventMask & XFixesDisplayCursorNotifyMask))
 	    {
 		xXFixesCursorNotifyEvent	ev;
 		ev.type = XFixesEventBase + XFixesCursorNotify;
diff --git a/nx-X11/programs/Xserver/xfixes/select.c b/nx-X11/programs/Xserver/xfixes/select.c
index 2a20bfe87..540499518 100755
--- a/nx-X11/programs/Xserver/xfixes/select.c
+++ b/nx-X11/programs/Xserver/xfixes/select.c
@@ -79,8 +79,7 @@ XFixesSelectionCallback (CallbackListPtr *callbacks, void * data, void * args)
     for (e = selectionEvents; e; e = e->next)
     {
 	if (e->selection == selection->selection && 
-	    (e->eventMask & eventMask) &&
-	    !e->pClient->clientGone)
+	    (e->eventMask & eventMask))
 	{
 	    xXFixesSelectionNotifyEvent	ev;
 
-- 
cgit v1.2.3


From cb0089bad114e79d5c6e4577da59fa8911d0ee8d Mon Sep 17 00:00:00 2001
From: Jamey Sharp <jamey@minilop.net>
Date: Sun, 3 Jul 2016 22:52:13 +0200
Subject: Set event sequence number in WriteEventsToClient instead of at
 callers.

 TryClientEvents already did this; this commit just moves the assignment
 one level down so that no event source has to worry about sequence
 numbers.

 ...No event source, that is, except XKB, which inexplicably calls
 WriteToClient directly for several events.

 Signed-off-by: Jamey Sharp <jamey@minilop.net>
 Reviewed-by: Julien Cristau <jcristau@debian.org>
 Reviewed-by: Adam Jackson <ajax@redhat.com>
 Backport to nx-libs: Mike Gabriel <mike.gabriel@das-netzwerkteam.de>
---
 nx-X11/programs/Xserver/Xext/saver.c       |  5 +----
 nx-X11/programs/Xserver/Xext/security.c    |  4 +---
 nx-X11/programs/Xserver/Xext/shape.c       |  5 +----
 nx-X11/programs/Xserver/Xext/shm.c         |  1 -
 nx-X11/programs/Xserver/Xext/sync.c        |  5 -----
 nx-X11/programs/Xserver/Xext/xvdisp.c      |  1 -
 nx-X11/programs/Xserver/dix/dispatch.c     |  1 -
 nx-X11/programs/Xserver/dix/events.c       | 12 ++++--------
 nx-X11/programs/Xserver/randr/rrcrtc.c     |  3 ---
 nx-X11/programs/Xserver/randr/rroutput.c   |  3 ---
 nx-X11/programs/Xserver/randr/rrproperty.c |  3 ---
 nx-X11/programs/Xserver/randr/rrscreen.c   |  3 ---
 nx-X11/programs/Xserver/xfixes/cursor.c    |  1 -
 nx-X11/programs/Xserver/xfixes/select.c    |  1 -
 14 files changed, 7 insertions(+), 41 deletions(-)

(limited to 'nx-X11/programs/Xserver/xfixes/select.c')

diff --git a/nx-X11/programs/Xserver/Xext/saver.c b/nx-X11/programs/Xserver/Xext/saver.c
index 0c5d28eb2..ab1096351 100644
--- a/nx-X11/programs/Xserver/Xext/saver.c
+++ b/nx-X11/programs/Xserver/Xext/saver.c
@@ -447,7 +447,6 @@ SendScreenSaverNotify (pScreen, state, forced)
     ScreenSaverEventPtr		pEv;
     unsigned long		mask;
     xScreenSaverNotifyEvent	ev;
-    ClientPtr			client;
     int				kind;
 
     UpdateCurrentTimeIf ();
@@ -466,18 +465,16 @@ SendScreenSaverNotify (pScreen, state, forced)
 	kind = ScreenSaverInternal;
     for (pEv = pPriv->events; pEv; pEv = pEv->next)
     {
-	client = pEv->client;
 	if (!(pEv->mask & mask))
 	    continue;
 	ev.type = ScreenSaverNotify + ScreenSaverEventBase;
 	ev.state = state;
-	ev.sequenceNumber = client->sequence;
 	ev.timestamp = currentTime.milliseconds;
 	ev.root = pScreen->root->drawable.id;
 	ev.window = savedScreenInfo[pScreen->myNum].wid;
 	ev.kind = kind;
 	ev.forced = forced;
-	WriteEventsToClient (client, 1, (xEvent *) &ev);
+	WriteEventsToClient (pEv->client, 1, (xEvent *) &ev);
     }
 }
 
diff --git a/nx-X11/programs/Xserver/Xext/security.c b/nx-X11/programs/Xserver/Xext/security.c
index 4f055ffe0..c7cd3f1fd 100644
--- a/nx-X11/programs/Xserver/Xext/security.c
+++ b/nx-X11/programs/Xserver/Xext/security.c
@@ -309,12 +309,10 @@ SecurityDeleteAuthorization(
     while ((pEventClient = pAuth->eventClients))
     {
 	/* send revocation event event */
-	ClientPtr client = rClient(pEventClient);
 	xSecurityAuthorizationRevokedEvent are;
 	are.type = SecurityEventBase + XSecurityAuthorizationRevoked;
-	are.sequenceNumber = client->sequence;
 	are.authId = pAuth->id;
-	WriteEventsToClient(client, 1, (xEvent *)&are);
+	WriteEventsToClient(rClient(pEventClient), 1, (xEvent *)&are);
 	FreeResource(pEventClient->resource, RT_NONE);
     }
 
diff --git a/nx-X11/programs/Xserver/Xext/shape.c b/nx-X11/programs/Xserver/Xext/shape.c
index 80ef71f67..a4aa5bece 100644
--- a/nx-X11/programs/Xserver/Xext/shape.c
+++ b/nx-X11/programs/Xserver/Xext/shape.c
@@ -915,7 +915,6 @@ SendShapeNotify (pWin, which)
     int		which;
 {
     ShapeEventPtr	*pHead, pShapeEvent;
-    ClientPtr		client;
     xShapeNotifyEvent	se;
     BoxRec		extents;
     RegionPtr		region;
@@ -968,18 +967,16 @@ SendShapeNotify (pWin, which)
 	return;
     }
     for (pShapeEvent = *pHead; pShapeEvent; pShapeEvent = pShapeEvent->next) {
-	client = pShapeEvent->client;
 	se.type = ShapeNotify + ShapeEventBase;
 	se.kind = which;
 	se.window = pWin->drawable.id;
-	se.sequenceNumber = client->sequence;
 	se.x = extents.x1;
 	se.y = extents.y1;
 	se.width = extents.x2 - extents.x1;
 	se.height = extents.y2 - extents.y1;
 	se.time = currentTime.milliseconds;
 	se.shaped = shaped;
-	WriteEventsToClient (client, 1, (xEvent *) &se);
+	WriteEventsToClient (pShapeEvent->client, 1, (xEvent *) &se);
     }
 }
 
diff --git a/nx-X11/programs/Xserver/Xext/shm.c b/nx-X11/programs/Xserver/Xext/shm.c
index b6e61de36..2f82ebcf6 100644
--- a/nx-X11/programs/Xserver/Xext/shm.c
+++ b/nx-X11/programs/Xserver/Xext/shm.c
@@ -928,7 +928,6 @@ ProcShmPutImage(client)
 
 	ev.type = ShmCompletionCode;
 	ev.drawable = stuff->drawable;
-	ev.sequenceNumber = client->sequence;
 	ev.minorEvent = X_ShmPutImage;
 	ev.majorEvent = ShmReqCode;
 	ev.shmseg = stuff->shmseg;
diff --git a/nx-X11/programs/Xserver/Xext/sync.c b/nx-X11/programs/Xserver/Xext/sync.c
index 3eb45a246..a137afedd 100644
--- a/nx-X11/programs/Xserver/Xext/sync.c
+++ b/nx-X11/programs/Xserver/Xext/sync.c
@@ -545,7 +545,6 @@ SyncSendAlarmNotifyEvents(pAlarm)
 
     ane.type = SyncEventBase + XSyncAlarmNotify;
     ane.kind = XSyncAlarmNotify;
-    ane.sequenceNumber = pAlarm->client->sequence;
     ane.alarm = pAlarm->alarm_id;
     if (pTrigger->pCounter)
     {
@@ -568,10 +567,7 @@ SyncSendAlarmNotifyEvents(pAlarm)
 
     /* send to other interested clients */
     for (pcl = pAlarm->pEventClients; pcl; pcl = pcl->next)
-    {
-	ane.sequenceNumber = pcl->client->sequence;
 	WriteEventsToClient(pcl->client, 1, (xEvent *) &ane);
-    }
 }
 
 
@@ -599,7 +595,6 @@ SyncSendCounterNotifyEvents(client, ppAwait, num_events)
 	SyncTrigger *pTrigger = &(*ppAwait)->trigger;
 	pev->type = SyncEventBase + XSyncCounterNotify;
 	pev->kind = XSyncCounterNotify;
-	pev->sequenceNumber = client->sequence;
 	pev->counter = pTrigger->pCounter->id;
 	pev->wait_value_lo = XSyncValueLow32(pTrigger->test_value);
 	pev->wait_value_hi = XSyncValueHigh32(pTrigger->test_value);
diff --git a/nx-X11/programs/Xserver/Xext/xvdisp.c b/nx-X11/programs/Xserver/Xext/xvdisp.c
index 905539c0b..923202701 100644
--- a/nx-X11/programs/Xserver/Xext/xvdisp.c
+++ b/nx-X11/programs/Xserver/Xext/xvdisp.c
@@ -1205,7 +1205,6 @@ ProcXvShmPutImage(ClientPtr client)
 
         ev.type = ShmCompletionCode;
         ev.drawable = stuff->drawable;
-        ev.sequenceNumber = client->sequence;
         ev.minorEvent = xv_ShmPutImage;
         ev.majorEvent = XvReqCode;
         ev.shmseg = stuff->shmseg;
diff --git a/nx-X11/programs/Xserver/dix/dispatch.c b/nx-X11/programs/Xserver/dix/dispatch.c
index f799ce289..826adfb5c 100644
--- a/nx-X11/programs/Xserver/dix/dispatch.c
+++ b/nx-X11/programs/Xserver/dix/dispatch.c
@@ -3953,7 +3953,6 @@ SendErrorToClient(ClientPtr client, unsigned majorCode, unsigned minorCode,
 
     memset(&rep, 0, sizeof(xError));
     rep.type = X_Error;
-    rep.sequenceNumber = client->sequence;
     rep.errorCode = errorCode;
     rep.majorCode = majorCode;
     rep.minorCode = minorCode;
diff --git a/nx-X11/programs/Xserver/dix/events.c b/nx-X11/programs/Xserver/dix/events.c
index 4d1472cc8..6fefa512a 100644
--- a/nx-X11/programs/Xserver/dix/events.c
+++ b/nx-X11/programs/Xserver/dix/events.c
@@ -1546,14 +1546,6 @@ TryClientEvents (ClientPtr client, xEvent *pEvents, int count, Mask mask,
 		return 1;
 	}
 #endif
-	type &= 0177;
-	if (type != KeymapNotify)
-	{
-	    /* all extension events must have a sequence number */
-	    for (i = 0; i < count; i++)
-		pEvents[i].u.u.sequenceNumber = client->sequence;
-	}
-
 	if (BitIsOn(criticalEvents, type))
 	{
 #ifdef SMART_SCHEDULE
@@ -4442,6 +4434,10 @@ WriteEventsToClient(ClientPtr pClient, int count, xEvent *events)
     if (!pClient || pClient == serverClient || pClient->clientGone)
 	return;
 
+    for (i = 0; i < count; i++)
+	if ((events[i].u.u.type & 0x7f) != KeymapNotify)
+	    events[i].u.u.sequenceNumber = pClient->sequence;
+
 #ifdef XKB
     if ((!noXkbExtension)&&(!XkbFilterEvents(pClient, count, events)))
 	return;
diff --git a/nx-X11/programs/Xserver/randr/rrcrtc.c b/nx-X11/programs/Xserver/randr/rrcrtc.c
index 072046e14..f1cc8c5e9 100644
--- a/nx-X11/programs/Xserver/randr/rrcrtc.c
+++ b/nx-X11/programs/Xserver/randr/rrcrtc.c
@@ -274,9 +274,6 @@ RRDeliverCrtcEvent(ClientPtr client, WindowPtr pWin, RRCrtcPtr crtc)
     xRRCrtcChangeNotifyEvent ce = {
         .type = RRNotify + RREventBase,
         .subCode = RRNotify_CrtcChange,
-#ifdef NXAGENT_SERVER
-        .sequenceNumber = client->sequence,
-#endif
         .timestamp = pScrPriv->lastSetTime.milliseconds,
         .window = pWin->drawable.id,
         .crtc = crtc->id,
diff --git a/nx-X11/programs/Xserver/randr/rroutput.c b/nx-X11/programs/Xserver/randr/rroutput.c
index c245de874..3a276e34a 100644
--- a/nx-X11/programs/Xserver/randr/rroutput.c
+++ b/nx-X11/programs/Xserver/randr/rroutput.c
@@ -351,9 +351,6 @@ RRDeliverOutputEvent(ClientPtr client, WindowPtr pWin, RROutputPtr output)
     xRROutputChangeNotifyEvent oe = {
         .type = RRNotify + RREventBase,
         .subCode = RRNotify_OutputChange,
-#ifdef NXAGENT_SERVER
-        .sequenceNumber = client->sequence,
-#endif
         .timestamp = pScrPriv->lastSetTime.milliseconds,
         .configTimestamp = pScrPriv->lastConfigTime.milliseconds,
         .window = pWin->drawable.id,
diff --git a/nx-X11/programs/Xserver/randr/rrproperty.c b/nx-X11/programs/Xserver/randr/rrproperty.c
index 334fd4720..b97f85b38 100644
--- a/nx-X11/programs/Xserver/randr/rrproperty.c
+++ b/nx-X11/programs/Xserver/randr/rrproperty.c
@@ -43,9 +43,6 @@ DeliverPropertyEvent(WindowPtr pWin, void *value)
         if (!(pRREvent->mask & RROutputPropertyNotifyMask))
             continue;
 
-#ifdef NXAGENT_SERVER
-        event->sequenceNumber = pRREvent->client->sequence;
-#endif
         event->window = pRREvent->window->drawable.id;
         WriteEventsToClient(pRREvent->client, 1, (xEvent *) event);
     }
diff --git a/nx-X11/programs/Xserver/randr/rrscreen.c b/nx-X11/programs/Xserver/randr/rrscreen.c
index 81ae5b741..9a6af7f39 100644
--- a/nx-X11/programs/Xserver/randr/rrscreen.c
+++ b/nx-X11/programs/Xserver/randr/rrscreen.c
@@ -111,9 +111,6 @@ RRDeliverScreenEvent(ClientPtr client, WindowPtr pWin, ScreenPtr pScreen)
 
     xRRScreenChangeNotifyEvent se = {
         .type = RRScreenChangeNotify + RREventBase,
-#ifdef NXAGENT_SERVER
-        .sequenceNumber = client->sequence,
-#endif
         .rotation = (CARD8) (crtc ? crtc->rotation : RR_Rotate_0),
         .timestamp = pScrPriv->lastSetTime.milliseconds,
         .configTimestamp = pScrPriv->lastConfigTime.milliseconds,
diff --git a/nx-X11/programs/Xserver/xfixes/cursor.c b/nx-X11/programs/Xserver/xfixes/cursor.c
index 747471e18..c053a5aa3 100755
--- a/nx-X11/programs/Xserver/xfixes/cursor.c
+++ b/nx-X11/programs/Xserver/xfixes/cursor.c
@@ -101,7 +101,6 @@ CursorDisplayCursor (ScreenPtr pScreen,
 		xXFixesCursorNotifyEvent	ev;
 		ev.type = XFixesEventBase + XFixesCursorNotify;
 		ev.subtype = XFixesDisplayCursorNotify;
-		ev.sequenceNumber = e->pClient->sequence;
 		ev.window = e->pWindow->drawable.id;
 		ev.cursorSerial = pCursor->serialNumber;
 		ev.timestamp = currentTime.milliseconds;
diff --git a/nx-X11/programs/Xserver/xfixes/select.c b/nx-X11/programs/Xserver/xfixes/select.c
index 540499518..600abc660 100755
--- a/nx-X11/programs/Xserver/xfixes/select.c
+++ b/nx-X11/programs/Xserver/xfixes/select.c
@@ -87,7 +87,6 @@ XFixesSelectionCallback (CallbackListPtr *callbacks, void * data, void * args)
 
 	    ev.type = XFixesEventBase + XFixesSelectionNotify;
 	    ev.subtype = subtype;
-	    ev.sequenceNumber = e->pClient->sequence;
 	    ev.window = e->pWindow->drawable.id;
 	    if (subtype == XFixesSetSelectionOwnerNotify)
 		ev.owner = selection->window;
-- 
cgit v1.2.3


From ee02822071a75d9a7d52a0fc6485b257a91ec16a Mon Sep 17 00:00:00 2001
From: Mike Gabriel <mike.gabriel@das-netzwerkteam.de>
Date: Tue, 5 Jul 2016 10:47:55 +0200
Subject: File permission fixes: No executable bit on Imakefile files, *.c and
 *.h files.

---
 nx-X11/extras/Mesa/src/mesa/shader/shaderobjects_3dlabs.c                 | 0
 nx-X11/extras/Mesa/src/mesa/shader/shaderobjects_3dlabs.h                 | 0
 .../Mesa/src/mesa/shader/slang/library/slang_common_builtin_gc_bin.h      | 0
 nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_core_gc_bin.h      | 0
 .../Mesa/src/mesa/shader/slang/library/slang_fragment_builtin_gc_bin.h    | 0
 nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_version_syn.h      | 0
 .../Mesa/src/mesa/shader/slang/library/slang_vertex_builtin_gc_bin.h      | 0
 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble.c                 | 0
 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble.h                 | 0
 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_assignment.c      | 0
 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_assignment.h      | 0
 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_conditional.c     | 0
 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_conditional.h     | 0
 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_constructor.c     | 0
 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_constructor.h     | 0
 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_typeinfo.c        | 0
 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_typeinfo.h        | 0
 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_execute.c                  | 0
 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_execute.h                  | 0
 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_preprocess.c               | 0
 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_preprocess.h               | 0
 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_storage.c                  | 0
 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_storage.h                  | 0
 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_utility.c                  | 0
 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_utility.h                  | 0
 nx-X11/extras/Mesa/src/mesa/shader/slang/traverse_wrap.h                  | 0
 nx-X11/programs/Xserver/damageext/damageext.c                             | 0
 nx-X11/programs/Xserver/miext/cw/Imakefile                                | 0
 nx-X11/programs/Xserver/miext/damage/Imakefile                            | 0
 nx-X11/programs/Xserver/miext/damage/damage.c                             | 0
 nx-X11/programs/Xserver/miext/damage/damage.h                             | 0
 nx-X11/programs/Xserver/miext/damage/damagestr.h                          | 0
 nx-X11/programs/Xserver/xfixes/Imakefile                                  | 0
 nx-X11/programs/Xserver/xfixes/cursor.c                                   | 0
 nx-X11/programs/Xserver/xfixes/region.c                                   | 0
 nx-X11/programs/Xserver/xfixes/saveset.c                                  | 0
 nx-X11/programs/Xserver/xfixes/select.c                                   | 0
 nx-X11/programs/Xserver/xfixes/xfixes.c                                   | 0
 nx-X11/programs/Xserver/xfixes/xfixes.h                                   | 0
 nx-X11/programs/Xserver/xfixes/xfixesint.h                                | 0
 40 files changed, 0 insertions(+), 0 deletions(-)
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/shaderobjects_3dlabs.c
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/shaderobjects_3dlabs.h
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_common_builtin_gc_bin.h
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_core_gc_bin.h
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_fragment_builtin_gc_bin.h
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_version_syn.h
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_vertex_builtin_gc_bin.h
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble.c
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble.h
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_assignment.c
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_assignment.h
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_conditional.c
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_conditional.h
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_constructor.c
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_constructor.h
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_typeinfo.c
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_typeinfo.h
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_execute.c
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_execute.h
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_preprocess.c
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_preprocess.h
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_storage.c
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_storage.h
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_utility.c
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/slang_utility.h
 mode change 100755 => 100644 nx-X11/extras/Mesa/src/mesa/shader/slang/traverse_wrap.h
 mode change 100755 => 100644 nx-X11/programs/Xserver/damageext/damageext.c
 mode change 100755 => 100644 nx-X11/programs/Xserver/miext/cw/Imakefile
 mode change 100755 => 100644 nx-X11/programs/Xserver/miext/damage/Imakefile
 mode change 100755 => 100644 nx-X11/programs/Xserver/miext/damage/damage.c
 mode change 100755 => 100644 nx-X11/programs/Xserver/miext/damage/damage.h
 mode change 100755 => 100644 nx-X11/programs/Xserver/miext/damage/damagestr.h
 mode change 100755 => 100644 nx-X11/programs/Xserver/xfixes/Imakefile
 mode change 100755 => 100644 nx-X11/programs/Xserver/xfixes/cursor.c
 mode change 100755 => 100644 nx-X11/programs/Xserver/xfixes/region.c
 mode change 100755 => 100644 nx-X11/programs/Xserver/xfixes/saveset.c
 mode change 100755 => 100644 nx-X11/programs/Xserver/xfixes/select.c
 mode change 100755 => 100644 nx-X11/programs/Xserver/xfixes/xfixes.c
 mode change 100755 => 100644 nx-X11/programs/Xserver/xfixes/xfixes.h
 mode change 100755 => 100644 nx-X11/programs/Xserver/xfixes/xfixesint.h

(limited to 'nx-X11/programs/Xserver/xfixes/select.c')

diff --git a/nx-X11/extras/Mesa/src/mesa/shader/shaderobjects_3dlabs.c b/nx-X11/extras/Mesa/src/mesa/shader/shaderobjects_3dlabs.c
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/shaderobjects_3dlabs.h b/nx-X11/extras/Mesa/src/mesa/shader/shaderobjects_3dlabs.h
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_common_builtin_gc_bin.h b/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_common_builtin_gc_bin.h
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_core_gc_bin.h b/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_core_gc_bin.h
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_fragment_builtin_gc_bin.h b/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_fragment_builtin_gc_bin.h
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_version_syn.h b/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_version_syn.h
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_vertex_builtin_gc_bin.h b/nx-X11/extras/Mesa/src/mesa/shader/slang/library/slang_vertex_builtin_gc_bin.h
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble.c b/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble.c
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble.h b/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble.h
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_assignment.c b/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_assignment.c
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_assignment.h b/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_assignment.h
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_conditional.c b/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_conditional.c
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_conditional.h b/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_conditional.h
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_constructor.c b/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_constructor.c
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_constructor.h b/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_constructor.h
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_typeinfo.c b/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_typeinfo.c
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_typeinfo.h b/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_assemble_typeinfo.h
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_execute.c b/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_execute.c
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_execute.h b/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_execute.h
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_preprocess.c b/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_preprocess.c
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_preprocess.h b/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_preprocess.h
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_storage.c b/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_storage.c
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_storage.h b/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_storage.h
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_utility.c b/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_utility.c
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_utility.h b/nx-X11/extras/Mesa/src/mesa/shader/slang/slang_utility.h
old mode 100755
new mode 100644
diff --git a/nx-X11/extras/Mesa/src/mesa/shader/slang/traverse_wrap.h b/nx-X11/extras/Mesa/src/mesa/shader/slang/traverse_wrap.h
old mode 100755
new mode 100644
diff --git a/nx-X11/programs/Xserver/damageext/damageext.c b/nx-X11/programs/Xserver/damageext/damageext.c
old mode 100755
new mode 100644
diff --git a/nx-X11/programs/Xserver/miext/cw/Imakefile b/nx-X11/programs/Xserver/miext/cw/Imakefile
old mode 100755
new mode 100644
diff --git a/nx-X11/programs/Xserver/miext/damage/Imakefile b/nx-X11/programs/Xserver/miext/damage/Imakefile
old mode 100755
new mode 100644
diff --git a/nx-X11/programs/Xserver/miext/damage/damage.c b/nx-X11/programs/Xserver/miext/damage/damage.c
old mode 100755
new mode 100644
diff --git a/nx-X11/programs/Xserver/miext/damage/damage.h b/nx-X11/programs/Xserver/miext/damage/damage.h
old mode 100755
new mode 100644
diff --git a/nx-X11/programs/Xserver/miext/damage/damagestr.h b/nx-X11/programs/Xserver/miext/damage/damagestr.h
old mode 100755
new mode 100644
diff --git a/nx-X11/programs/Xserver/xfixes/Imakefile b/nx-X11/programs/Xserver/xfixes/Imakefile
old mode 100755
new mode 100644
diff --git a/nx-X11/programs/Xserver/xfixes/cursor.c b/nx-X11/programs/Xserver/xfixes/cursor.c
old mode 100755
new mode 100644
diff --git a/nx-X11/programs/Xserver/xfixes/region.c b/nx-X11/programs/Xserver/xfixes/region.c
old mode 100755
new mode 100644
diff --git a/nx-X11/programs/Xserver/xfixes/saveset.c b/nx-X11/programs/Xserver/xfixes/saveset.c
old mode 100755
new mode 100644
diff --git a/nx-X11/programs/Xserver/xfixes/select.c b/nx-X11/programs/Xserver/xfixes/select.c
old mode 100755
new mode 100644
diff --git a/nx-X11/programs/Xserver/xfixes/xfixes.c b/nx-X11/programs/Xserver/xfixes/xfixes.c
old mode 100755
new mode 100644
diff --git a/nx-X11/programs/Xserver/xfixes/xfixes.h b/nx-X11/programs/Xserver/xfixes/xfixes.h
old mode 100755
new mode 100644
diff --git a/nx-X11/programs/Xserver/xfixes/xfixesint.h b/nx-X11/programs/Xserver/xfixes/xfixesint.h
old mode 100755
new mode 100644
-- 
cgit v1.2.3


From 104a3e9e2dbafd31e7b1def3686d052a356fc74a Mon Sep 17 00:00:00 2001
From: Mike Gabriel <mike.gabriel@das-netzwerkteam.de>
Date: Wed, 15 Feb 2017 09:59:00 +0100
Subject: Naming change: Security*Access -> Dix*Access

 Backported from X.org:

 commit 6c46645cfc1afda8aeabfe0ed4d9342673b702f1
 Author: Eamon Walsh <ewalsh@tycho.nsa.gov>
 Date:   Thu Dec 14 14:45:42 2006 -0500

    Naming change: Security*Access -> Dix*Access

 Backported-to-NX-by: Mike Gabriel <mike.gabriel@das-netzwerkteam.de>
---
 nx-X11/programs/Xserver/Xext/panoramiXprocs.c   | 172 ++++++++++++------------
 nx-X11/programs/Xserver/Xext/saver.c            |  10 +-
 nx-X11/programs/Xserver/Xext/security.c         |  10 +-
 nx-X11/programs/Xserver/Xext/shape.c            |  22 +--
 nx-X11/programs/Xserver/Xext/shm.c              |   6 +-
 nx-X11/programs/Xserver/Xext/sync.c             |  16 +--
 nx-X11/programs/Xserver/Xext/xf86bigfont.c      |   4 +-
 nx-X11/programs/Xserver/Xext/xvdisp.c           |  30 ++---
 nx-X11/programs/Xserver/composite/compwindow.c  |   2 +-
 nx-X11/programs/Xserver/damageext/damageext.c   |  10 +-
 nx-X11/programs/Xserver/dbe/dbe.c               |  12 +-
 nx-X11/programs/Xserver/dix/colormap.c          |   4 +-
 nx-X11/programs/Xserver/dix/cursor.c            |   4 +-
 nx-X11/programs/Xserver/dix/dispatch.c          | 116 ++++++++--------
 nx-X11/programs/Xserver/dix/dixfonts.c          |   8 +-
 nx-X11/programs/Xserver/dix/dixutils.c          |   6 +-
 nx-X11/programs/Xserver/dix/events.c            |  38 +++---
 nx-X11/programs/Xserver/dix/gc.c                |   8 +-
 nx-X11/programs/Xserver/dix/property.c          |  20 +--
 nx-X11/programs/Xserver/dix/resource.c          |   4 +-
 nx-X11/programs/Xserver/dix/window.c            |  10 +-
 nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c |  16 +--
 nx-X11/programs/Xserver/hw/nxagent/NXevents.c   |   2 +-
 nx-X11/programs/Xserver/hw/nxagent/NXproperty.c |  10 +-
 nx-X11/programs/Xserver/hw/nxagent/NXrender.c   |  48 +++----
 nx-X11/programs/Xserver/hw/nxagent/NXwindow.c   |   2 +-
 nx-X11/programs/Xserver/hw/nxagent/Rootless.c   |  10 +-
 nx-X11/programs/Xserver/include/dix.h           |  10 +-
 nx-X11/programs/Xserver/include/resource.h      |   8 +-
 nx-X11/programs/Xserver/randr/randrstr.h        |   8 +-
 nx-X11/programs/Xserver/randr/rrdispatch.c      |   2 +-
 nx-X11/programs/Xserver/randr/rrmode.c          |   2 +-
 nx-X11/programs/Xserver/randr/rrmonitor.c       |   6 +-
 nx-X11/programs/Xserver/randr/rroutput.c        |   4 +-
 nx-X11/programs/Xserver/randr/rrprovider.c      |   2 +-
 nx-X11/programs/Xserver/randr/rrscreen.c        |  10 +-
 nx-X11/programs/Xserver/randr/rrxinerama.c      |   6 +-
 nx-X11/programs/Xserver/render/picture.c        |   4 +-
 nx-X11/programs/Xserver/render/render.c         | 122 ++++++++---------
 nx-X11/programs/Xserver/xfixes/cursor.c         |  12 +-
 nx-X11/programs/Xserver/xfixes/region.c         |  46 +++----
 nx-X11/programs/Xserver/xfixes/saveset.c        |   2 +-
 nx-X11/programs/Xserver/xfixes/select.c         |   2 +-
 43 files changed, 421 insertions(+), 425 deletions(-)

(limited to 'nx-X11/programs/Xserver/xfixes/select.c')

diff --git a/nx-X11/programs/Xserver/Xext/panoramiXprocs.c b/nx-X11/programs/Xserver/Xext/panoramiXprocs.c
index 9da3328f8..906fdd137 100644
--- a/nx-X11/programs/Xserver/Xext/panoramiXprocs.c
+++ b/nx-X11/programs/Xserver/Xext/panoramiXprocs.c
@@ -89,7 +89,7 @@ int PanoramiXCreateWindow(ClientPtr client)
         return BadLength;
 
     if (!(parent = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->parent, XRT_WINDOW, SecurityWriteAccess)))
+		client, stuff->parent, XRT_WINDOW, DixWriteAccess)))
         return BadWindow;
 
     if(stuff->class == CopyFromParent)
@@ -103,7 +103,7 @@ int PanoramiXCreateWindow(ClientPtr client)
 	tmp = *((CARD32 *) &stuff[1] + pback_offset);
 	if ((tmp != None) && (tmp != ParentRelative)) {
 	   if(!(backPix = (PanoramiXRes*) SecurityLookupIDByType(
-		client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+		client, tmp, XRT_PIXMAP, DixReadAccess)))
 	      return BadPixmap;
 	}
     }
@@ -112,7 +112,7 @@ int PanoramiXCreateWindow(ClientPtr client)
 	tmp = *((CARD32 *) &stuff[1] + pbord_offset);
 	if (tmp != CopyFromParent) {
 	   if(!(bordPix = (PanoramiXRes*) SecurityLookupIDByType(
-		client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+		client, tmp, XRT_PIXMAP, DixReadAccess)))
 	      return BadPixmap;
 	}
     }
@@ -121,7 +121,7 @@ int PanoramiXCreateWindow(ClientPtr client)
 	tmp = *((CARD32 *) &stuff[1] + cmap_offset);
 	if ((tmp != CopyFromParent) && (tmp != None)) {
 	   if(!(cmap = (PanoramiXRes*) SecurityLookupIDByType(
-		client, tmp, XRT_COLORMAP, SecurityReadAccess)))
+		client, tmp, XRT_COLORMAP, DixReadAccess)))
 	      return BadColor;
 	}
     }
@@ -190,7 +190,7 @@ int PanoramiXChangeWindowAttributes(ClientPtr client)
         return BadLength;
 
     if (!(win = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->window, XRT_WINDOW, SecurityWriteAccess)))
+		client, stuff->window, XRT_WINDOW, DixWriteAccess)))
         return BadWindow;
 
     if((win->u.win.class == InputOnly) && 
@@ -202,7 +202,7 @@ int PanoramiXChangeWindowAttributes(ClientPtr client)
 	tmp = *((CARD32 *) &stuff[1] + pback_offset);
 	if ((tmp != None) && (tmp != ParentRelative)) {
 	   if(!(backPix = (PanoramiXRes*) SecurityLookupIDByType(
-		client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+		client, tmp, XRT_PIXMAP, DixReadAccess)))
 	      return BadPixmap;
 	}
     }
@@ -211,7 +211,7 @@ int PanoramiXChangeWindowAttributes(ClientPtr client)
 	tmp = *((CARD32 *) &stuff[1] + pbord_offset);
 	if (tmp != CopyFromParent) {
 	   if(!(bordPix = (PanoramiXRes*) SecurityLookupIDByType(
-		client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+		client, tmp, XRT_PIXMAP, DixReadAccess)))
 	      return BadPixmap;
 	}
     }
@@ -220,7 +220,7 @@ int PanoramiXChangeWindowAttributes(ClientPtr client)
 	tmp = *((CARD32 *) &stuff[1] + cmap_offset);
 	if ((tmp != CopyFromParent) && (tmp != None)) {
 	   if(!(cmap = (PanoramiXRes*) SecurityLookupIDByType(
-		client, tmp, XRT_COLORMAP, SecurityReadAccess)))
+		client, tmp, XRT_COLORMAP, DixReadAccess)))
 	      return BadColor;
 	}
     }
@@ -249,7 +249,7 @@ int PanoramiXDestroyWindow(ClientPtr client)
     REQUEST_SIZE_MATCH(xResourceReq);
 
     if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->id, XRT_WINDOW, SecurityDestroyAccess)))
+		client, stuff->id, XRT_WINDOW, DixDestroyAccess)))
 	return BadWindow;
 
     FOR_NSCREENS_BACKWARD(j) {
@@ -274,7 +274,7 @@ int PanoramiXDestroySubwindows(ClientPtr client)
     REQUEST_SIZE_MATCH(xResourceReq);
 
     if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->id, XRT_WINDOW, SecurityDestroyAccess)))
+		client, stuff->id, XRT_WINDOW, DixDestroyAccess)))
 	return BadWindow;
 
     FOR_NSCREENS_BACKWARD(j) {
@@ -299,7 +299,7 @@ int PanoramiXChangeSaveSet(ClientPtr client)
     REQUEST_SIZE_MATCH(xChangeSaveSetReq);
 
     if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->window, XRT_WINDOW, SecurityReadAccess)))
+		client, stuff->window, XRT_WINDOW, DixReadAccess)))
 	return BadWindow;
 
     FOR_NSCREENS_BACKWARD(j) {
@@ -323,11 +323,11 @@ int PanoramiXReparentWindow(ClientPtr client)
     REQUEST_SIZE_MATCH(xReparentWindowReq);
 
     if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->window, XRT_WINDOW, SecurityWriteAccess)))
+		client, stuff->window, XRT_WINDOW, DixWriteAccess)))
 	return BadWindow;
 
     if(!(parent = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->parent, XRT_WINDOW, SecurityWriteAccess)))
+		client, stuff->parent, XRT_WINDOW, DixWriteAccess)))
 	return BadWindow;
 
     x = stuff->x;
@@ -358,7 +358,7 @@ int PanoramiXMapWindow(ClientPtr client)
     REQUEST_SIZE_MATCH(xResourceReq);
 
     if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->id, XRT_WINDOW, SecurityReadAccess)))
+		client, stuff->id, XRT_WINDOW, DixReadAccess)))
 	return BadWindow;
 
     FOR_NSCREENS_FORWARD(j) {
@@ -380,7 +380,7 @@ int PanoramiXMapSubwindows(ClientPtr client)
     REQUEST_SIZE_MATCH(xResourceReq);
 
     if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->id, XRT_WINDOW, SecurityReadAccess)))
+		client, stuff->id, XRT_WINDOW, DixReadAccess)))
 	return BadWindow;
 
     FOR_NSCREENS_FORWARD(j) {
@@ -402,7 +402,7 @@ int PanoramiXUnmapWindow(ClientPtr client)
     REQUEST_SIZE_MATCH(xResourceReq);
 
     if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->id, XRT_WINDOW, SecurityReadAccess)))
+		client, stuff->id, XRT_WINDOW, DixReadAccess)))
 	return BadWindow;
 
     FOR_NSCREENS_FORWARD(j) {
@@ -424,7 +424,7 @@ int PanoramiXUnmapSubwindows(ClientPtr client)
     REQUEST_SIZE_MATCH(xResourceReq);
 
     if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->id, XRT_WINDOW, SecurityReadAccess)))
+		client, stuff->id, XRT_WINDOW, DixReadAccess)))
 	return BadWindow;
 
     FOR_NSCREENS_FORWARD(j) {
@@ -455,11 +455,11 @@ int PanoramiXConfigureWindow(ClientPtr client)
 
     /* because we need the parent */
     if (!(pWin = (WindowPtr)SecurityLookupIDByType(
-		client, stuff->window, RT_WINDOW, SecurityWriteAccess)))
+		client, stuff->window, RT_WINDOW, DixWriteAccess)))
         return BadWindow;
 
     if (!(win = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->window, XRT_WINDOW, SecurityWriteAccess)))
+		client, stuff->window, XRT_WINDOW, DixWriteAccess)))
         return BadWindow;
 
     if ((Mask)stuff->mask & CWSibling) {
@@ -467,7 +467,7 @@ int PanoramiXConfigureWindow(ClientPtr client)
 	sib_offset = Ones((Mask)stuff->mask & (CWSibling - 1));
 	if ((tmp = *((CARD32 *) &stuff[1] + sib_offset))) {
 	   if(!(sib = (PanoramiXRes*) SecurityLookupIDByType(
-		client, tmp, XRT_WINDOW, SecurityReadAccess)))
+		client, tmp, XRT_WINDOW, DixReadAccess)))
 	      return BadWindow;
 	}
     }
@@ -512,7 +512,7 @@ int PanoramiXCirculateWindow(ClientPtr client)
     REQUEST_SIZE_MATCH(xCirculateWindowReq);
 
     if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->window, XRT_WINDOW, SecurityWriteAccess)))
+		client, stuff->window, XRT_WINDOW, DixWriteAccess)))
 	return BadWindow;
 
     FOR_NSCREENS_FORWARD(j) {
@@ -577,11 +577,11 @@ int PanoramiXTranslateCoords(ClientPtr client)
 
     REQUEST_SIZE_MATCH(xTranslateCoordsReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->srcWid, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
     if (!pWin)
         return(BadWindow);
     pDst = (WindowPtr)SecurityLookupWindow(stuff->dstWid, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
     if (!pDst)
         return(BadWindow);
     rep.type = X_Reply;
@@ -653,7 +653,7 @@ int PanoramiXCreatePixmap(ClientPtr client)
     client->errorValue = stuff->pid;
 
     if(!(refDraw = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->drawable, XRC_DRAWABLE, SecurityReadAccess)))
+		client, stuff->drawable, XRC_DRAWABLE, DixReadAccess)))
 	return BadDrawable;
 
     if(!(newPix = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
@@ -692,7 +692,7 @@ int PanoramiXFreePixmap(ClientPtr client)
     client->errorValue = stuff->id;
 
     if(!(pix = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->id, XRT_PIXMAP, SecurityDestroyAccess)))
+		client, stuff->id, XRT_PIXMAP, DixDestroyAccess)))
 	return BadPixmap;
 
     FOR_NSCREENS_BACKWARD(j) {
@@ -728,14 +728,14 @@ int PanoramiXCreateGC(ClientPtr client)
         return BadLength;
 
     if (!(refDraw = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->drawable, XRC_DRAWABLE, SecurityReadAccess)))
+		client, stuff->drawable, XRC_DRAWABLE, DixReadAccess)))
         return BadDrawable;
 
     if ((Mask)stuff->mask & GCTile) {
 	tile_offset = Ones((Mask)stuff->mask & (GCTile - 1));
 	if ((tmp = *((CARD32 *) &stuff[1] + tile_offset))) {
 	   if(!(tile = (PanoramiXRes*) SecurityLookupIDByType(
-		client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+		client, tmp, XRT_PIXMAP, DixReadAccess)))
 	      return BadPixmap;
 	}
     }
@@ -743,7 +743,7 @@ int PanoramiXCreateGC(ClientPtr client)
 	stip_offset = Ones((Mask)stuff->mask & (GCStipple - 1));
 	if ((tmp = *((CARD32 *) &stuff[1] + stip_offset))) {
 	   if(!(stip = (PanoramiXRes*) SecurityLookupIDByType(
-		client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+		client, tmp, XRT_PIXMAP, DixReadAccess)))
 	      return BadPixmap;
 	}
     }
@@ -751,7 +751,7 @@ int PanoramiXCreateGC(ClientPtr client)
 	clip_offset = Ones((Mask)stuff->mask & (GCClipMask - 1));
 	if ((tmp = *((CARD32 *) &stuff[1] + clip_offset))) {
 	   if(!(clip = (PanoramiXRes*) SecurityLookupIDByType(
-		client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+		client, tmp, XRT_PIXMAP, DixReadAccess)))
 	      return BadPixmap;
 	}
     }
@@ -803,14 +803,14 @@ int PanoramiXChangeGC(ClientPtr client)
         return BadLength;
 
     if (!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+		client, stuff->gc, XRT_GC, DixReadAccess)))
         return BadGC;
 
     if ((Mask)stuff->mask & GCTile) {
 	tile_offset = Ones((Mask)stuff->mask & (GCTile - 1));
 	if ((tmp = *((CARD32 *) &stuff[1] + tile_offset))) {
 	   if(!(tile = (PanoramiXRes*) SecurityLookupIDByType(
-		client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+		client, tmp, XRT_PIXMAP, DixReadAccess)))
 	      return BadPixmap;
 	}
     }
@@ -818,7 +818,7 @@ int PanoramiXChangeGC(ClientPtr client)
 	stip_offset = Ones((Mask)stuff->mask & (GCStipple - 1));
 	if ((tmp = *((CARD32 *) &stuff[1] + stip_offset))) {
 	   if(!(stip = (PanoramiXRes*) SecurityLookupIDByType(
-		client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+		client, tmp, XRT_PIXMAP, DixReadAccess)))
 	      return BadPixmap;
 	}
     }
@@ -826,7 +826,7 @@ int PanoramiXChangeGC(ClientPtr client)
 	clip_offset = Ones((Mask)stuff->mask & (GCClipMask - 1));
 	if ((tmp = *((CARD32 *) &stuff[1] + clip_offset))) {
 	   if(!(clip = (PanoramiXRes*) SecurityLookupIDByType(
-		client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+		client, tmp, XRT_PIXMAP, DixReadAccess)))
 	      return BadPixmap;
 	}
     }
@@ -857,11 +857,11 @@ int PanoramiXCopyGC(ClientPtr client)
     REQUEST_SIZE_MATCH(xCopyGCReq);
 
     if(!(srcGC = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->srcGC, XRT_GC, SecurityReadAccess)))
+		client, stuff->srcGC, XRT_GC, DixReadAccess)))
 	return BadGC;
 
     if(!(dstGC = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->dstGC, XRT_GC, SecurityWriteAccess)))
+		client, stuff->dstGC, XRT_GC, DixWriteAccess)))
 	return BadGC;
 
     FOR_NSCREENS(j) {
@@ -884,7 +884,7 @@ int PanoramiXSetDashes(ClientPtr client)
     REQUEST_FIXED_SIZE(xSetDashesReq, stuff->nDashes);
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->gc, XRT_GC, SecurityWriteAccess)))
+		client, stuff->gc, XRT_GC, DixWriteAccess)))
 	return BadGC;
 
     FOR_NSCREENS_BACKWARD(j) {
@@ -906,7 +906,7 @@ int PanoramiXSetClipRectangles(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xSetClipRectanglesReq);
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->gc, XRT_GC, SecurityWriteAccess)))
+		client, stuff->gc, XRT_GC, DixWriteAccess)))
 	return BadGC;
 
     FOR_NSCREENS_BACKWARD(j) {
@@ -928,7 +928,7 @@ int PanoramiXFreeGC(ClientPtr client)
     REQUEST_SIZE_MATCH(xResourceReq);
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->id, XRT_GC, SecurityDestroyAccess)))
+		client, stuff->id, XRT_GC, DixDestroyAccess)))
 	return BadGC;
 
     FOR_NSCREENS_BACKWARD(j) {
@@ -954,7 +954,7 @@ int PanoramiXClearToBackground(ClientPtr client)
     REQUEST_SIZE_MATCH(xClearAreaReq);
 
     if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->window, XRT_WINDOW, SecurityWriteAccess)))
+		client, stuff->window, XRT_WINDOW, DixWriteAccess)))
 	return BadWindow;
 
     x = stuff->x;
@@ -996,13 +996,13 @@ int PanoramiXCopyArea(ClientPtr client)
     REQUEST_SIZE_MATCH(xCopyAreaReq);
 
     if(!(src = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->srcDrawable, XRC_DRAWABLE, SecurityReadAccess)))
+		client, stuff->srcDrawable, XRC_DRAWABLE, DixReadAccess)))
 	return BadDrawable;
 
     srcShared = IS_SHARED_PIXMAP(src);
 
     if(!(dst = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->dstDrawable, XRC_DRAWABLE, SecurityWriteAccess)))
+		client, stuff->dstDrawable, XRC_DRAWABLE, DixWriteAccess)))
 	return BadDrawable;
 
     dstShared = IS_SHARED_PIXMAP(dst);
@@ -1011,7 +1011,7 @@ int PanoramiXCopyArea(ClientPtr client)
 	return (* SavedProcVector[X_CopyArea])(client);
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+		client, stuff->gc, XRT_GC, DixReadAccess)))
 	return BadGC;
 
     if((dst->type == XRT_WINDOW) && dst->u.win.root)
@@ -1080,7 +1080,7 @@ int PanoramiXCopyArea(ClientPtr client)
 	    VALIDATE_DRAWABLE_AND_GC(stuff->dstDrawable, pDst, pGC, client); 
 	    if (stuff->dstDrawable != stuff->srcDrawable) {
 		SECURITY_VERIFY_DRAWABLE(pSrc, stuff->srcDrawable, client,
-                                 SecurityReadAccess);
+                                 DixReadAccess);
 		if ((pDst->pScreen != pSrc->pScreen) || 
 		    (pDst->depth != pSrc->depth)) {
 			client->errorValue = stuff->dstDrawable;
@@ -1144,13 +1144,13 @@ int PanoramiXCopyPlane(ClientPtr client)
     REQUEST_SIZE_MATCH(xCopyPlaneReq);
 
     if(!(src = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->srcDrawable, XRC_DRAWABLE, SecurityReadAccess)))
+		client, stuff->srcDrawable, XRC_DRAWABLE, DixReadAccess)))
 	return BadDrawable;    
 
     srcShared = IS_SHARED_PIXMAP(src);
 
     if(!(dst = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->dstDrawable, XRC_DRAWABLE, SecurityWriteAccess)))
+		client, stuff->dstDrawable, XRC_DRAWABLE, DixWriteAccess)))
 	return BadDrawable;
 
     dstShared = IS_SHARED_PIXMAP(dst);
@@ -1159,7 +1159,7 @@ int PanoramiXCopyPlane(ClientPtr client)
 	return (* SavedProcVector[X_CopyPlane])(client);
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+		client, stuff->gc, XRT_GC, DixReadAccess)))
 	return BadGC;
 
     if((dst->type == XRT_WINDOW) && dst->u.win.root)
@@ -1186,7 +1186,7 @@ int PanoramiXCopyPlane(ClientPtr client)
 	VALIDATE_DRAWABLE_AND_GC(stuff->dstDrawable, pdstDraw, pGC, client);
 	if (stuff->dstDrawable != stuff->srcDrawable) {
 	    SECURITY_VERIFY_DRAWABLE(psrcDraw, stuff->srcDrawable, client,
-                                 SecurityReadAccess);
+                                 DixReadAccess);
             if (pdstDraw->pScreen != psrcDraw->pScreen) {
 		client->errorValue = stuff->dstDrawable;
 		return (BadMatch);
@@ -1244,14 +1244,14 @@ int PanoramiXPolyPoint(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xPolyPointReq);
 
     if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+		client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
 	return BadDrawable;
 
     if(IS_SHARED_PIXMAP(draw))
 	return (*SavedProcVector[X_PolyPoint])(client);
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+		client, stuff->gc, XRT_GC, DixReadAccess)))
 	return BadGC;    
 
     isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
@@ -1302,14 +1302,14 @@ int PanoramiXPolyLine(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xPolyLineReq);
 
     if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+		client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
 	return BadDrawable;    
 
     if(IS_SHARED_PIXMAP(draw))
 	return (*SavedProcVector[X_PolyLine])(client);
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+		client, stuff->gc, XRT_GC, DixReadAccess)))
 	return BadGC;    
 
     isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
@@ -1360,14 +1360,14 @@ int PanoramiXPolySegment(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xPolySegmentReq);
 
     if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+		client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
 	return BadDrawable;    
 
     if(IS_SHARED_PIXMAP(draw))
 	return (*SavedProcVector[X_PolySegment])(client);
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+		client, stuff->gc, XRT_GC, DixReadAccess)))
 	return BadGC;    
 
     isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
@@ -1422,14 +1422,14 @@ int PanoramiXPolyRectangle(ClientPtr client)
 
 
     if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+		client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
 	return BadDrawable;
 
     if(IS_SHARED_PIXMAP(draw))
 	return (*SavedProcVector[X_PolyRectangle])(client);
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+		client, stuff->gc, XRT_GC, DixReadAccess)))
 	return BadGC;    
 
     isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
@@ -1482,14 +1482,14 @@ int PanoramiXPolyArc(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xPolyArcReq);
 
     if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+		client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
 	return BadDrawable;    
 
     if(IS_SHARED_PIXMAP(draw))
 	return (*SavedProcVector[X_PolyArc])(client);
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+		client, stuff->gc, XRT_GC, DixReadAccess)))
 	return BadGC;    
 
     isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
@@ -1540,14 +1540,14 @@ int PanoramiXFillPoly(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xFillPolyReq);
 
     if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+		client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
 	return BadDrawable;    
 
     if(IS_SHARED_PIXMAP(draw))
 	return (*SavedProcVector[X_FillPoly])(client);
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+		client, stuff->gc, XRT_GC, DixReadAccess)))
 	return BadGC;    
 
     isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
@@ -1599,14 +1599,14 @@ int PanoramiXPolyFillRectangle(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xPolyFillRectangleReq);
 
     if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+		client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
 	return BadDrawable;    
 
     if(IS_SHARED_PIXMAP(draw))
 	return (*SavedProcVector[X_PolyFillRectangle])(client);
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+		client, stuff->gc, XRT_GC, DixReadAccess)))
 	return BadGC;    
 
     isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
@@ -1658,14 +1658,14 @@ int PanoramiXPolyFillArc(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xPolyFillArcReq);
 
     if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+		client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
 	return BadDrawable;    
 
     if(IS_SHARED_PIXMAP(draw))
 	return (*SavedProcVector[X_PolyFillArc])(client);
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+		client, stuff->gc, XRT_GC, DixReadAccess)))
 	return BadGC;    
 
     isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
@@ -1716,14 +1716,14 @@ int PanoramiXPutImage(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xPutImageReq);
 
     if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+		client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
 	return BadDrawable;    
 
     if(IS_SHARED_PIXMAP(draw))
 	return (*SavedProcVector[X_PutImage])(client);
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+		client, stuff->gc, XRT_GC, DixReadAccess)))
 	return BadGC;    
 
     isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
@@ -1767,7 +1767,7 @@ int PanoramiXGetImage(ClientPtr client)
     }
 
     if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+		client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
 	return BadDrawable;
 
     if(draw->type == XRT_PIXMAP)
@@ -1907,14 +1907,14 @@ PanoramiXPolyText8(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xPolyTextReq);
 
     if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+		client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
 	return BadDrawable;    
 
     if(IS_SHARED_PIXMAP(draw))
 	return (*SavedProcVector[X_PolyText8])(client);
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+		client, stuff->gc, XRT_GC, DixReadAccess)))
 	return BadGC;    
 
     isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
@@ -1946,14 +1946,14 @@ PanoramiXPolyText16(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xPolyTextReq);
 
     if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+		client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
 	return BadDrawable;    
 
     if(IS_SHARED_PIXMAP(draw))
 	return (*SavedProcVector[X_PolyText16])(client);
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+		client, stuff->gc, XRT_GC, DixReadAccess)))
 	return BadGC;    
 
     isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
@@ -1985,14 +1985,14 @@ int PanoramiXImageText8(ClientPtr client)
     REQUEST_FIXED_SIZE(xImageTextReq, stuff->nChars);
 
     if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+		client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
 	return BadDrawable;    
 
     if(IS_SHARED_PIXMAP(draw))
 	return (*SavedProcVector[X_ImageText8])(client);
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+		client, stuff->gc, XRT_GC, DixReadAccess)))
 	return BadGC;    
 
     isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
@@ -2024,14 +2024,14 @@ int PanoramiXImageText16(ClientPtr client)
     REQUEST_FIXED_SIZE(xImageTextReq, stuff->nChars << 1);
 
     if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+		client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
 	return BadDrawable;    
 
     if(IS_SHARED_PIXMAP(draw))
 	return (*SavedProcVector[X_ImageText16])(client);
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->gc, XRT_GC, SecurityReadAccess)))
+		client, stuff->gc, XRT_GC, DixReadAccess)))
 	return BadGC;    
 
     isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
@@ -2062,7 +2062,7 @@ int PanoramiXCreateColormap(ClientPtr client)
     REQUEST_SIZE_MATCH(xCreateColormapReq);
 
     if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->window, XRT_WINDOW, SecurityReadAccess)))
+		client, stuff->window, XRT_WINDOW, DixReadAccess)))
 	return BadWindow;    
 
     if(!stuff->visual || (stuff->visual > 255)) 
@@ -2105,7 +2105,7 @@ int PanoramiXFreeColormap(ClientPtr client)
     client->errorValue = stuff->id;
 
     if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
-                client, stuff->id, XRT_COLORMAP, SecurityDestroyAccess)))
+                client, stuff->id, XRT_COLORMAP, DixDestroyAccess)))
         return BadColor;
 
     FOR_NSCREENS_BACKWARD(j) {
@@ -2134,7 +2134,7 @@ PanoramiXCopyColormapAndFree(ClientPtr client)
 
     if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
                 client, stuff->srcCmap, XRT_COLORMAP, 
-		SecurityReadAccess | SecurityWriteAccess)))
+		DixReadAccess | DixWriteAccess)))
         return BadColor;
 
     if(!(newCmap = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
@@ -2172,7 +2172,7 @@ int PanoramiXInstallColormap(ClientPtr client)
     client->errorValue = stuff->id;
 
     if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
-                client, stuff->id, XRT_COLORMAP, SecurityReadAccess)))
+                client, stuff->id, XRT_COLORMAP, DixReadAccess)))
         return BadColor;
 
     FOR_NSCREENS_BACKWARD(j){
@@ -2195,7 +2195,7 @@ int PanoramiXUninstallColormap(ClientPtr client)
     client->errorValue = stuff->id;
 
     if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
-                client, stuff->id, XRT_COLORMAP, SecurityReadAccess)))
+                client, stuff->id, XRT_COLORMAP, DixReadAccess)))
         return BadColor;
 
     FOR_NSCREENS_BACKWARD(j) {
@@ -2218,7 +2218,7 @@ int PanoramiXAllocColor(ClientPtr client)
     client->errorValue = stuff->cmap;
 
     if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
-                client, stuff->cmap, XRT_COLORMAP, SecurityWriteAccess)))
+                client, stuff->cmap, XRT_COLORMAP, DixWriteAccess)))
 	return BadColor;
 
     FOR_NSCREENS_BACKWARD(j){
@@ -2241,7 +2241,7 @@ int PanoramiXAllocNamedColor(ClientPtr client)
     client->errorValue = stuff->cmap;
 
     if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
-                client, stuff->cmap, XRT_COLORMAP, SecurityWriteAccess)))
+                client, stuff->cmap, XRT_COLORMAP, DixWriteAccess)))
         return BadColor;
 
     FOR_NSCREENS_BACKWARD(j){
@@ -2264,7 +2264,7 @@ int PanoramiXAllocColorCells(ClientPtr client)
     client->errorValue = stuff->cmap;
 
     if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
-                client, stuff->cmap, XRT_COLORMAP, SecurityWriteAccess)))
+                client, stuff->cmap, XRT_COLORMAP, DixWriteAccess)))
 	return BadColor;
 	
     FOR_NSCREENS_BACKWARD(j){
@@ -2287,7 +2287,7 @@ int PanoramiXAllocColorPlanes(ClientPtr client)
     client->errorValue = stuff->cmap;
 
     if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
-                client, stuff->cmap, XRT_COLORMAP, SecurityWriteAccess)))
+                client, stuff->cmap, XRT_COLORMAP, DixWriteAccess)))
 	return BadColor;
 	
     FOR_NSCREENS_BACKWARD(j){
@@ -2311,7 +2311,7 @@ int PanoramiXFreeColors(ClientPtr client)
     client->errorValue = stuff->cmap;
 
     if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
-                client, stuff->cmap, XRT_COLORMAP, SecurityWriteAccess)))
+                client, stuff->cmap, XRT_COLORMAP, DixWriteAccess)))
         return BadColor;
 
     FOR_NSCREENS_BACKWARD(j) {
@@ -2333,7 +2333,7 @@ int PanoramiXStoreColors(ClientPtr client)
     client->errorValue = stuff->cmap;
 
     if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
-                client, stuff->cmap, XRT_COLORMAP, SecurityWriteAccess)))
+                client, stuff->cmap, XRT_COLORMAP, DixWriteAccess)))
         return BadColor;
 
     FOR_NSCREENS_BACKWARD(j){
@@ -2356,7 +2356,7 @@ int PanoramiXStoreNamedColor(ClientPtr client)
     client->errorValue = stuff->cmap;
 
     if(!(cmap = (PanoramiXRes *)SecurityLookupIDByType(
-                client, stuff->cmap, XRT_COLORMAP, SecurityWriteAccess)))
+                client, stuff->cmap, XRT_COLORMAP, DixWriteAccess)))
         return BadColor;
 
     FOR_NSCREENS_BACKWARD(j){
diff --git a/nx-X11/programs/Xserver/Xext/saver.c b/nx-X11/programs/Xserver/Xext/saver.c
index 3e4fd8a95..06a967eb4 100644
--- a/nx-X11/programs/Xserver/Xext/saver.c
+++ b/nx-X11/programs/Xserver/Xext/saver.c
@@ -1199,7 +1199,7 @@ ProcScreenSaverSetAttributes (ClientPtr client)
        REQUEST_AT_LEAST_SIZE (xScreenSaverSetAttributesReq);
 
        if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-                   client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+                   client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
            return BadDrawable;
 
        len = stuff->length -  (sizeof(xScreenSaverSetAttributesReq) >> 2);
@@ -1211,7 +1211,7 @@ ProcScreenSaverSetAttributes (ClientPtr client)
           tmp = *((CARD32 *) &stuff[1] + pback_offset);
           if ((tmp != None) && (tmp != ParentRelative)) {
              if(!(backPix = (PanoramiXRes*) SecurityLookupIDByType(
-                  client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+                  client, tmp, XRT_PIXMAP, DixReadAccess)))
                 return BadPixmap;
           }
        }
@@ -1221,7 +1221,7 @@ ProcScreenSaverSetAttributes (ClientPtr client)
           tmp = *((CARD32 *) &stuff[1] + pbord_offset);
           if (tmp != CopyFromParent) {
              if(!(bordPix = (PanoramiXRes*) SecurityLookupIDByType(
-                  client, tmp, XRT_PIXMAP, SecurityReadAccess)))
+                  client, tmp, XRT_PIXMAP, DixReadAccess)))
                 return BadPixmap;
           }
        }
@@ -1231,7 +1231,7 @@ ProcScreenSaverSetAttributes (ClientPtr client)
            tmp = *((CARD32 *) &stuff[1] + cmap_offset);
            if ((tmp != CopyFromParent) && (tmp != None)) {
              if(!(cmap = (PanoramiXRes*) SecurityLookupIDByType(
-                  client, tmp, XRT_COLORMAP, SecurityReadAccess)))
+                  client, tmp, XRT_COLORMAP, DixReadAccess)))
                  return BadColor;
            }
        }
@@ -1271,7 +1271,7 @@ ProcScreenSaverUnsetAttributes (ClientPtr client)
        int i;
 
        if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-                   client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+                   client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
            return BadDrawable;
 
        for(i = PanoramiXNumScreens - 1; i > 0; i--) {
diff --git a/nx-X11/programs/Xserver/Xext/security.c b/nx-X11/programs/Xserver/Xext/security.c
index 3a638460e..55a805aea 100644
--- a/nx-X11/programs/Xserver/Xext/security.c
+++ b/nx-X11/programs/Xserver/Xext/security.c
@@ -750,7 +750,7 @@ ProcSecurityRevokeAuthorization(
     REQUEST_SIZE_MATCH(xSecurityRevokeAuthorizationReq);
 
     pAuth = (SecurityAuthorizationPtr)SecurityLookupIDByType(client,
-	stuff->authId, SecurityAuthorizationResType, SecurityDestroyAccess);
+	stuff->authId, SecurityAuthorizationResType, DixDestroyAccess);
     if (!pAuth)
 	return SecurityErrorBase + XSecurityBadAuthorization;
 
@@ -1115,7 +1115,7 @@ SecurityCheckResourceIDAccess(
     int cid = CLIENT_ID(id);
     int reqtype = ((xReq *)client->requestBuffer)->reqType;
 
-    if (SecurityUnknownAccess == access_mode)
+    if (DixUnknownAccess == access_mode)
 	return rval;  /* for compatibility, we have to allow access */
 
     switch (reqtype)
@@ -2051,11 +2051,11 @@ SecurityCheckPropertyAccess(client, pWin, propertyName, access_mode)
 	     * executed a continue, which will skip the follwing code.
 	     */
 	    action = SecurityAllowOperation;
-	    if (access_mode & SecurityReadAccess)
+	    if (access_mode & DixReadAccess)
 		action = max(action, pacl->readAction);
-	    if (access_mode & SecurityWriteAccess)
+	    if (access_mode & DixWriteAccess)
 		action = max(action, pacl->writeAction);
-	    if (access_mode & SecurityDestroyAccess)
+	    if (access_mode & DixDestroyAccess)
 		action = max(action, pacl->destroyAction);
 	    break;
 	} /* end for each pacl */
diff --git a/nx-X11/programs/Xserver/Xext/shape.c b/nx-X11/programs/Xserver/Xext/shape.c
index de597dead..cd29ec721 100644
--- a/nx-X11/programs/Xserver/Xext/shape.c
+++ b/nx-X11/programs/Xserver/Xext/shape.c
@@ -385,7 +385,7 @@ ProcPanoramiXShapeRectangles(
     REQUEST_AT_LEAST_SIZE (xShapeRectanglesReq);
 
     if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->dest, XRT_WINDOW, SecurityWriteAccess)))
+		client, stuff->dest, XRT_WINDOW, DixWriteAccess)))
 	return BadWindow;
 
     FOR_NSCREENS(j) {
@@ -417,7 +417,7 @@ ProcShapeMask (client)
 
     REQUEST_SIZE_MATCH (xShapeMaskReq);
     UpdateCurrentTime();
-    pWin = SecurityLookupWindow (stuff->dest, client, SecurityWriteAccess);
+    pWin = SecurityLookupWindow (stuff->dest, client, DixWriteAccess);
     if (!pWin)
 	return BadWindow;
     switch (stuff->destKind) {
@@ -439,7 +439,7 @@ ProcShapeMask (client)
 	srcRgn = 0;
     else {
         pPixmap = (PixmapPtr) SecurityLookupIDByType(client, stuff->src,
-						RT_PIXMAP, SecurityReadAccess);
+						RT_PIXMAP, DixReadAccess);
         if (!pPixmap)
 	    return BadPixmap;
 	if (pPixmap->drawable.pScreen != pScreen ||
@@ -483,12 +483,12 @@ ProcPanoramiXShapeMask(
     REQUEST_SIZE_MATCH (xShapeMaskReq);
 
     if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->dest, XRT_WINDOW, SecurityWriteAccess)))
+		client, stuff->dest, XRT_WINDOW, DixWriteAccess)))
 	return BadWindow;
 
     if(stuff->src != None) {
 	if(!(pmap = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->src, XRT_PIXMAP, SecurityReadAccess)))
+		client, stuff->src, XRT_PIXMAP, DixReadAccess)))
 	    return BadPixmap;
     } else
 	pmap = NULL;
@@ -611,11 +611,11 @@ ProcPanoramiXShapeCombine(
     REQUEST_AT_LEAST_SIZE (xShapeCombineReq);
 
     if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->dest, XRT_WINDOW, SecurityWriteAccess)))
+		client, stuff->dest, XRT_WINDOW, DixWriteAccess)))
 	return BadWindow;
 
     if(!(win2 = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->src, XRT_WINDOW, SecurityReadAccess)))
+		client, stuff->src, XRT_WINDOW, DixReadAccess)))
 	return BadWindow;
 
     FOR_NSCREENS(j) {
@@ -683,7 +683,7 @@ ProcPanoramiXShapeOffset(
     REQUEST_AT_LEAST_SIZE (xShapeOffsetReq);
    
     if(!(win = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->dest, XRT_WINDOW, SecurityWriteAccess)))
+		client, stuff->dest, XRT_WINDOW, DixWriteAccess)))
 	return BadWindow;
 
     FOR_NSCREENS(j) {
@@ -817,11 +817,11 @@ ProcShapeSelectInput (client)
     XID			clientResource;
 
     REQUEST_SIZE_MATCH (xShapeSelectInputReq);
-    pWin = SecurityLookupWindow (stuff->window, client, SecurityWriteAccess);
+    pWin = SecurityLookupWindow (stuff->window, client, DixWriteAccess);
     if (!pWin)
 	return BadWindow;
     pHead = (ShapeEventPtr *)SecurityLookupIDByType(client,
-			pWin->drawable.id, EventType, SecurityWriteAccess);
+			pWin->drawable.id, EventType, DixWriteAccess);
     switch (stuff->enable) {
     case xTrue:
 	if (pHead) {
@@ -988,7 +988,7 @@ ProcShapeInputSelected (client)
     if (!pWin)
 	return BadWindow;
     pHead = (ShapeEventPtr *) SecurityLookupIDByType(client,
-			pWin->drawable.id, EventType, SecurityReadAccess);
+			pWin->drawable.id, EventType, DixReadAccess);
     enabled = xFalse;
     if (pHead) {
     	for (pShapeEvent = *pHead;
diff --git a/nx-X11/programs/Xserver/Xext/shm.c b/nx-X11/programs/Xserver/Xext/shm.c
index dc8bbf97b..e3fa3a24e 100644
--- a/nx-X11/programs/Xserver/Xext/shm.c
+++ b/nx-X11/programs/Xserver/Xext/shm.c
@@ -568,11 +568,11 @@ ProcPanoramiXShmPutImage(register ClientPtr client)
     REQUEST_SIZE_MATCH(xShmPutImageReq);
 
     if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-                client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+                client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
         return BadDrawable;
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-                client, stuff->gc, XRT_GC, SecurityReadAccess)))
+                client, stuff->gc, XRT_GC, DixReadAccess)))
         return BadGC;
 
     isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
@@ -618,7 +618,7 @@ ProcPanoramiXShmGetImage(ClientPtr client)
     }
 
     if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+		client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
 	return BadDrawable;
 
     if (draw->type == XRT_PIXMAP)
diff --git a/nx-X11/programs/Xserver/Xext/sync.c b/nx-X11/programs/Xserver/Xext/sync.c
index e1580b3a3..8cf6af562 100644
--- a/nx-X11/programs/Xserver/Xext/sync.c
+++ b/nx-X11/programs/Xserver/Xext/sync.c
@@ -425,7 +425,7 @@ SyncInitTrigger(client, pTrigger, counter, changes)
 	if (counter == None)
 	    pCounter = NULL;
 	else if (!(pCounter = (SyncCounter *)SecurityLookupIDByType(
-			client, counter, RTCounter, SecurityReadAccess)))
+			client, counter, RTCounter, DixReadAccess)))
 	{
 	    client->errorValue = counter;
 	    return SyncErrorBase + XSyncBadCounter;
@@ -1527,7 +1527,7 @@ ProcSyncSetCounter(client)
     REQUEST_SIZE_MATCH(xSyncSetCounterReq);
 
     pCounter = (SyncCounter *)SecurityLookupIDByType(client, stuff->cid,
-					   RTCounter, SecurityWriteAccess);
+					   RTCounter, DixWriteAccess);
     if (pCounter == NULL)
     {
 	client->errorValue = stuff->cid;
@@ -1560,7 +1560,7 @@ ProcSyncChangeCounter(client)
     REQUEST_SIZE_MATCH(xSyncChangeCounterReq);
 
     pCounter = (SyncCounter *) SecurityLookupIDByType(client, stuff->cid,
-					    RTCounter, SecurityWriteAccess);
+					    RTCounter, DixWriteAccess);
     if (pCounter == NULL)
     {
 	client->errorValue = stuff->cid;
@@ -1598,7 +1598,7 @@ ProcSyncDestroyCounter(client)
     REQUEST_SIZE_MATCH(xSyncDestroyCounterReq);
 
     pCounter = (SyncCounter *)SecurityLookupIDByType(client, stuff->counter,
-					   RTCounter, SecurityDestroyAccess);
+					   RTCounter, DixDestroyAccess);
     if (pCounter == NULL)
     {
 	client->errorValue = stuff->counter;
@@ -1744,7 +1744,7 @@ ProcSyncQueryCounter(client)
     REQUEST_SIZE_MATCH(xSyncQueryCounterReq);
 
     pCounter = (SyncCounter *)SecurityLookupIDByType(client, stuff->counter,
-					    RTCounter, SecurityReadAccess);
+					    RTCounter, DixReadAccess);
     if (pCounter == NULL)
     {
 	client->errorValue = stuff->counter;
@@ -1872,7 +1872,7 @@ ProcSyncChangeAlarm(client)
     REQUEST_AT_LEAST_SIZE(xSyncChangeAlarmReq);
 
     if (!(pAlarm = (SyncAlarm *)SecurityLookupIDByType(client, stuff->alarm,
-					      RTAlarm, SecurityWriteAccess)))
+					      RTAlarm, DixWriteAccess)))
     {
 	client->errorValue = stuff->alarm;
 	return SyncErrorBase + XSyncBadAlarm;
@@ -1913,7 +1913,7 @@ ProcSyncQueryAlarm(client)
     REQUEST_SIZE_MATCH(xSyncQueryAlarmReq);
 
     pAlarm = (SyncAlarm *)SecurityLookupIDByType(client, stuff->alarm,
-						RTAlarm, SecurityReadAccess);
+						RTAlarm, DixReadAccess);
     if (!pAlarm)
     {
 	client->errorValue = stuff->alarm;
@@ -1972,7 +1972,7 @@ ProcSyncDestroyAlarm(client)
     REQUEST_SIZE_MATCH(xSyncDestroyAlarmReq);
 
     if (!((SyncAlarm *)SecurityLookupIDByType(client, stuff->alarm,
-					      RTAlarm, SecurityDestroyAccess)))
+					      RTAlarm, DixDestroyAccess)))
     {
 	client->errorValue = stuff->alarm;
 	return SyncErrorBase + XSyncBadAlarm;
diff --git a/nx-X11/programs/Xserver/Xext/xf86bigfont.c b/nx-X11/programs/Xserver/Xext/xf86bigfont.c
index 67a09f77b..6ec47c4f4 100644
--- a/nx-X11/programs/Xserver/Xext/xf86bigfont.c
+++ b/nx-X11/programs/Xserver/Xext/xf86bigfont.c
@@ -443,11 +443,11 @@ ProcXF86BigfontQueryFont(
 #endif
     client->errorValue = stuff->id;		/* EITHER font or gc */
     pFont = (FontPtr)SecurityLookupIDByType(client, stuff->id, RT_FONT,
-					    SecurityReadAccess);
+					    DixReadAccess);
     if (!pFont) {
 	/* can't use VERIFY_GC because it might return BadGC */
 	GC *pGC = (GC *) SecurityLookupIDByType(client, stuff->id, RT_GC,
-						SecurityReadAccess);
+						DixReadAccess);
         if (!pGC) {
 	    client->errorValue = stuff->id;
             return BadFont;    /* procotol spec says only error is BadFont */
diff --git a/nx-X11/programs/Xserver/Xext/xvdisp.c b/nx-X11/programs/Xserver/Xext/xvdisp.c
index 34f4537f2..b33bfa493 100644
--- a/nx-X11/programs/Xserver/Xext/xvdisp.c
+++ b/nx-X11/programs/Xserver/Xext/xvdisp.c
@@ -1854,11 +1854,11 @@ XineramaXvStopVideo(ClientPtr client)
    REQUEST_SIZE_MATCH(xvStopVideoReq);
 
    if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-                client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+                client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
         return BadDrawable;
 
    if(!(port = (PanoramiXRes *)SecurityLookupIDByType(
-                client, stuff->port, XvXRTPort, SecurityReadAccess)))
+                client, stuff->port, XvXRTPort, DixReadAccess)))
         return _XvBadPort;
 
    FOR_NSCREENS_BACKWARD(i) {
@@ -1882,7 +1882,7 @@ XineramaXvSetPortAttribute(ClientPtr client)
     REQUEST_SIZE_MATCH(xvSetPortAttributeReq);
 
     if(!(port = (PanoramiXRes *)SecurityLookupIDByType(
-                client, stuff->port, XvXRTPort, SecurityReadAccess)))
+                client, stuff->port, XvXRTPort, DixReadAccess)))
         return _XvBadPort;
 
     FOR_NSCREENS_BACKWARD(i) {
@@ -1908,15 +1908,15 @@ XineramaXvShmPutImage(ClientPtr client)
     REQUEST_SIZE_MATCH(xvShmPutImageReq);
 
     if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-                client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+                client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
         return BadDrawable;
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-                client, stuff->gc, XRT_GC, SecurityReadAccess)))
+                client, stuff->gc, XRT_GC, DixReadAccess)))
         return BadGC;    
 
     if(!(port = (PanoramiXRes *)SecurityLookupIDByType(
-                client, stuff->port, XvXRTPort, SecurityReadAccess)))
+                client, stuff->port, XvXRTPort, DixReadAccess)))
         return _XvBadPort;
  
     isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
@@ -1955,15 +1955,15 @@ XineramaXvPutImage(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xvPutImageReq);
 
     if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-                client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+                client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
         return BadDrawable;
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-                client, stuff->gc, XRT_GC, SecurityReadAccess)))
+                client, stuff->gc, XRT_GC, DixReadAccess)))
         return BadGC;    
 
     if(!(port = (PanoramiXRes *)SecurityLookupIDByType(
-		client, stuff->port, XvXRTPort, SecurityReadAccess)))
+		client, stuff->port, XvXRTPort, DixReadAccess)))
 	return _XvBadPort;
  
     isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
@@ -2000,15 +2000,15 @@ XineramaXvPutVideo(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xvPutVideoReq);
 
     if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-                client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+                client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
         return BadDrawable;
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-                client, stuff->gc, XRT_GC, SecurityReadAccess)))
+                client, stuff->gc, XRT_GC, DixReadAccess)))
         return BadGC;
 
     if(!(port = (PanoramiXRes *)SecurityLookupIDByType(
-                client, stuff->port, XvXRTPort, SecurityReadAccess)))
+                client, stuff->port, XvXRTPort, DixReadAccess)))
         return _XvBadPort;
 
     isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
@@ -2045,15 +2045,15 @@ XineramaXvPutStill(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xvPutImageReq);
 
     if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
-                client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+                client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
         return BadDrawable;
 
     if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
-                client, stuff->gc, XRT_GC, SecurityReadAccess)))
+                client, stuff->gc, XRT_GC, DixReadAccess)))
         return BadGC;
 
     if(!(port = (PanoramiXRes *)SecurityLookupIDByType(
-                client, stuff->port, XvXRTPort, SecurityReadAccess)))
+                client, stuff->port, XvXRTPort, DixReadAccess)))
         return _XvBadPort;
 
     isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
diff --git a/nx-X11/programs/Xserver/composite/compwindow.c b/nx-X11/programs/Xserver/composite/compwindow.c
index 799aad023..e9bb39827 100644
--- a/nx-X11/programs/Xserver/composite/compwindow.c
+++ b/nx-X11/programs/Xserver/composite/compwindow.c
@@ -83,7 +83,7 @@ compRepaintBorder (ClientPtr pClient, void * closure)
         dixLookupWindow(&pWindow, (XID) (intptr_t) closure, pClient,
                         DixWriteAccess);
 #else
-    pWindow = SecurityLookupWindow((XID) (intptr_t) closure, pClient, SecurityWriteAccess);
+    pWindow = SecurityLookupWindow((XID) (intptr_t) closure, pClient, DixWriteAccess);
     int rc = pWindow ? Success : BadWindow;
 #endif
 
diff --git a/nx-X11/programs/Xserver/damageext/damageext.c b/nx-X11/programs/Xserver/damageext/damageext.c
index 38a624be7..6ade82f84 100644
--- a/nx-X11/programs/Xserver/damageext/damageext.c
+++ b/nx-X11/programs/Xserver/damageext/damageext.c
@@ -175,7 +175,7 @@ ProcDamageCreate (ClientPtr client)
     REQUEST_SIZE_MATCH(xDamageCreateReq);
     LEGAL_NEW_RESOURCE(stuff->damage, client);
     SECURITY_VERIFY_DRAWABLE (pDrawable, stuff->drawable, client,
-			      SecurityReadAccess);
+			      DixReadAccess);
     switch (stuff->level) {
     case XDamageReportRawRectangles:
 	level = DamageReportRawRegion;
@@ -233,7 +233,7 @@ ProcDamageDestroy (ClientPtr client)
     DamageExtPtr    pDamageExt;
 
     REQUEST_SIZE_MATCH(xDamageDestroyReq);
-    VERIFY_DAMAGEEXT(pDamageExt, stuff->damage, client, SecurityWriteAccess);
+    VERIFY_DAMAGEEXT(pDamageExt, stuff->damage, client, DixWriteAccess);
     FreeResource (stuff->damage, RT_NONE);
     return (client->noClientException);
 }
@@ -247,9 +247,9 @@ ProcDamageSubtract (ClientPtr client)
     RegionPtr	    pParts;
 
     REQUEST_SIZE_MATCH(xDamageSubtractReq);
-    VERIFY_DAMAGEEXT(pDamageExt, stuff->damage, client, SecurityWriteAccess);
-    VERIFY_REGION_OR_NONE(pRepair, stuff->repair, client, SecurityWriteAccess);
-    VERIFY_REGION_OR_NONE(pParts, stuff->parts, client, SecurityWriteAccess);
+    VERIFY_DAMAGEEXT(pDamageExt, stuff->damage, client, DixWriteAccess);
+    VERIFY_REGION_OR_NONE(pRepair, stuff->repair, client, DixWriteAccess);
+    VERIFY_REGION_OR_NONE(pParts, stuff->parts, client, DixWriteAccess);
 
     if (pDamageExt->level != DamageReportRawRegion)
     {
diff --git a/nx-X11/programs/Xserver/dbe/dbe.c b/nx-X11/programs/Xserver/dbe/dbe.c
index d0487ba63..95740871a 100644
--- a/nx-X11/programs/Xserver/dbe/dbe.c
+++ b/nx-X11/programs/Xserver/dbe/dbe.c
@@ -420,7 +420,7 @@ ProcDbeAllocateBackBufferName(client)
 
     /* The window must be valid. */
     if (!(pWin = SecurityLookupWindow(stuff->window, client,
-				      SecurityWriteAccess)))
+				      DixWriteAccess)))
     {
 	return(BadWindow);
     }
@@ -648,9 +648,9 @@ ProcDbeDeallocateBackBufferName(client)
 
     /* Buffer name must be valid */
     if (!(pDbeWindowPriv = (DbeWindowPrivPtr)SecurityLookupIDByType(client,
-		stuff->buffer, dbeWindowPrivResType, SecurityDestroyAccess)) ||
+		stuff->buffer, dbeWindowPrivResType, DixDestroyAccess)) ||
         !(SecurityLookupIDByType(client, stuff->buffer, dbeDrawableResType,
-				 SecurityDestroyAccess)))
+				 DixDestroyAccess)))
     {
         client->errorValue = stuff->buffer;
         return(dbeErrorBase + DbeBadBuffer);
@@ -751,7 +751,7 @@ ProcDbeSwapBuffers(client)
 
         /* Each window must be a valid window - BadWindow. */
         if (!(pWin = SecurityLookupWindow(dbeSwapInfo[i].window, client,
-					  SecurityWriteAccess)))
+					  DixWriteAccess)))
         {
             free(swapInfo);
 	    return(BadWindow);
@@ -916,7 +916,7 @@ ProcDbeGetVisualInfo(client)
         for (i = 0; i < stuff->n; i++)
         {
             if (!(pDrawables[i] = (DrawablePtr)SecurityLookupDrawable(
-				drawables[i], client, SecurityReadAccess)))
+				drawables[i], client, DixReadAccess)))
             {
                 free(pDrawables);
                 return(BadDrawable);
@@ -1072,7 +1072,7 @@ ProcDbeGetBackBufferAttributes(client)
     REQUEST_SIZE_MATCH(xDbeGetBackBufferAttributesReq);
 
     if (!(pDbeWindowPriv = (DbeWindowPrivPtr)SecurityLookupIDByType(client,
-		stuff->buffer, dbeWindowPrivResType, SecurityReadAccess)))
+		stuff->buffer, dbeWindowPrivResType, DixReadAccess)))
     {
         rep.attributes = None;
     }
diff --git a/nx-X11/programs/Xserver/dix/colormap.c b/nx-X11/programs/Xserver/dix/colormap.c
index b8361a9cf..8b0e1e421 100644
--- a/nx-X11/programs/Xserver/dix/colormap.c
+++ b/nx-X11/programs/Xserver/dix/colormap.c
@@ -892,7 +892,7 @@ AllocColor (ColormapPtr pmap,
 	{
 	    ColormapPtr prootmap = (ColormapPtr)
 		SecurityLookupIDByType (clients[client], pmap->pScreen->defColormap,
-					 RT_COLORMAP, SecurityReadAccess);
+					 RT_COLORMAP, DixReadAccess);
 
 	    if (pmap->class == prootmap->class)
 		FindColorInRootCmap (prootmap, prootmap->red, entries, &rgb, 
@@ -909,7 +909,7 @@ AllocColor (ColormapPtr pmap,
 	{
 	    ColormapPtr prootmap = (ColormapPtr)
 		SecurityLookupIDByType (clients[client], pmap->pScreen->defColormap,
-					 RT_COLORMAP, SecurityReadAccess);
+					 RT_COLORMAP, DixReadAccess);
 
 	    if (pmap->class == prootmap->class)
 	    {
diff --git a/nx-X11/programs/Xserver/dix/cursor.c b/nx-X11/programs/Xserver/dix/cursor.c
index 093464298..a1bf6a7ed 100644
--- a/nx-X11/programs/Xserver/dix/cursor.c
+++ b/nx-X11/programs/Xserver/dix/cursor.c
@@ -262,9 +262,9 @@ AllocGlyphCursor(Font source, unsigned sourceChar, Font mask, unsigned maskChar,
     GlyphSharePtr pShare;
 
     sourcefont = (FontPtr) SecurityLookupIDByType(client, source, RT_FONT,
-						  SecurityReadAccess);
+						  DixReadAccess);
     maskfont = (FontPtr) SecurityLookupIDByType(client, mask, RT_FONT,
-						SecurityReadAccess);
+						DixReadAccess);
 
     if (!sourcefont)
     {
diff --git a/nx-X11/programs/Xserver/dix/dispatch.c b/nx-X11/programs/Xserver/dix/dispatch.c
index 2c7550371..02d5170fb 100644
--- a/nx-X11/programs/Xserver/dix/dispatch.c
+++ b/nx-X11/programs/Xserver/dix/dispatch.c
@@ -491,7 +491,7 @@ ProcCreateWindow(ClientPtr client)
     
     LEGAL_NEW_RESOURCE(stuff->wid, client);
     if (!(pParent = (WindowPtr)SecurityLookupWindow(stuff->parent, client,
-						    SecurityWriteAccess)))
+						    DixWriteAccess)))
         return BadWindow;
     len = client->req_len - (sizeof(xCreateWindowReq) >> 2);
     if (Ones(stuff->mask) != len)
@@ -532,7 +532,7 @@ ProcChangeWindowAttributes(register ClientPtr client)
 
     REQUEST_AT_LEAST_SIZE(xChangeWindowAttributesReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityWriteAccess);
+					   DixWriteAccess);
     if (!pWin)
         return(BadWindow);
     len = client->req_len - (sizeof(xChangeWindowAttributesReq) >> 2);
@@ -557,7 +557,7 @@ ProcGetWindowAttributes(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xResourceReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->id, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
     if (!pWin)
         return(BadWindow);
     memset(&wa, 0, sizeof(xGetWindowAttributesReply));
@@ -574,7 +574,7 @@ ProcDestroyWindow(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xResourceReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->id, client,
-					   SecurityDestroyAccess);
+					   DixDestroyAccess);
     if (!pWin)
         return(BadWindow);
     if (pWin->parent)
@@ -590,7 +590,7 @@ ProcDestroySubwindows(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xResourceReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->id, client,
-					   SecurityDestroyAccess);
+					   DixDestroyAccess);
     if (!pWin)
         return(BadWindow);
     DestroySubwindows(pWin, client);
@@ -606,7 +606,7 @@ ProcChangeSaveSet(register ClientPtr client)
 		  
     REQUEST_SIZE_MATCH(xChangeSaveSetReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
     if (!pWin)
         return(BadWindow);
     if (client->clientAsMask == (CLIENT_BITS(pWin->drawable.id)))
@@ -636,11 +636,11 @@ ProcReparentWindow(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xReparentWindowReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityWriteAccess);
+					   DixWriteAccess);
     if (!pWin)
         return(BadWindow);
     pParent = (WindowPtr)SecurityLookupWindow(stuff->parent, client,
-					      SecurityWriteAccess);
+					      DixWriteAccess);
     if (!pParent)
         return(BadWindow);
     if (SAME_SCREENS(pWin->drawable, pParent->drawable))
@@ -671,7 +671,7 @@ ProcMapWindow(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xResourceReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->id, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
     if (!pWin)
         return(BadWindow);
     MapWindow(pWin, client);
@@ -687,7 +687,7 @@ ProcMapSubwindows(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xResourceReq);
     pWin = (WindowPtr)SecurityLookupWindow( stuff->id, client,
-					    SecurityReadAccess);
+					    DixReadAccess);
     if (!pWin)
         return(BadWindow);
     MapSubwindows(pWin, client);
@@ -703,7 +703,7 @@ ProcUnmapWindow(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xResourceReq);
     pWin = (WindowPtr)SecurityLookupWindow( stuff->id, client,
-					    SecurityReadAccess);
+					    DixReadAccess);
     if (!pWin)
         return(BadWindow);
     UnmapWindow(pWin, FALSE);
@@ -719,7 +719,7 @@ ProcUnmapSubwindows(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xResourceReq);
     pWin = (WindowPtr)SecurityLookupWindow( stuff->id, client,
-					    SecurityReadAccess);
+					    DixReadAccess);
     if (!pWin)
         return(BadWindow);
     UnmapSubwindows(pWin);
@@ -736,7 +736,7 @@ ProcConfigureWindow(register ClientPtr client)
 
     REQUEST_AT_LEAST_SIZE(xConfigureWindowReq);
     pWin = (WindowPtr)SecurityLookupWindow( stuff->window, client,
-					    SecurityWriteAccess);
+					    DixWriteAccess);
     if (!pWin)
         return(BadWindow);
     len = client->req_len - (sizeof(xConfigureWindowReq) >> 2);
@@ -764,7 +764,7 @@ ProcCirculateWindow(register ClientPtr client)
         return BadValue;
     }
     pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityWriteAccess);
+					   DixWriteAccess);
     if (!pWin)
         return(BadWindow);
     CirculateWindow(pWin, (int)stuff->direction, client);
@@ -778,7 +778,7 @@ GetGeometry(register ClientPtr client, xGetGeometryReply *rep)
     REQUEST(xResourceReq);
 
     REQUEST_SIZE_MATCH(xResourceReq);
-    SECURITY_VERIFY_GEOMETRABLE (pDraw, stuff->id, client, SecurityReadAccess);
+    SECURITY_VERIFY_GEOMETRABLE (pDraw, stuff->id, client, DixReadAccess);
     memset(rep, 0, sizeof(xGetGeometryReply));
     rep->type = X_Reply;
     rep->length = 0;
@@ -839,7 +839,7 @@ ProcQueryTree(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xResourceReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->id, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
     if (!pWin)
         return(BadWindow);
     memset(&reply, 0, sizeof(xQueryTreeReply));
@@ -957,7 +957,7 @@ ProcSetSelectionOwner(register ClientPtr client)
     if (stuff->window != None)
     {
         pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					       SecurityReadAccess);
+					       DixReadAccess);
         if (!pWin)
             return(BadWindow);
     }
@@ -1079,7 +1079,7 @@ ProcConvertSelection(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xConvertSelectionReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->requestor, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
     if (!pWin)
         return(BadWindow);
 
@@ -1098,7 +1098,7 @@ ProcConvertSelection(register ClientPtr client)
 #ifdef XCSECURITY
 	    && (!client->CheckAccess ||
 		(* client->CheckAccess)(client, CurrentSelections[i].window,
-					RT_WINDOW, SecurityReadAccess,
+					RT_WINDOW, DixReadAccess,
 					CurrentSelections[i].pWin))
 #endif
 	    )
@@ -1208,11 +1208,11 @@ ProcTranslateCoords(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xTranslateCoordsReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->srcWid, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
     if (!pWin)
         return(BadWindow);
     pDst = (WindowPtr)SecurityLookupWindow(stuff->dstWid, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
     if (!pDst)
         return(BadWindow);
     memset(&rep, 0, sizeof(xTranslateCoordsReply));
@@ -1305,7 +1305,7 @@ ProcCloseFont(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xResourceReq);
     pFont = (FontPtr)SecurityLookupIDByType(client, stuff->id, RT_FONT,
-					    SecurityDestroyAccess);
+					    DixDestroyAccess);
     if ( pFont != (FontPtr)NULL)	/* id was valid */
     {
         FreeResource(stuff->id, RT_NONE);
@@ -1331,12 +1331,12 @@ ProcQueryFont(register ClientPtr client)
     client->errorValue = stuff->id;		/* EITHER font or gc */
 
     pFont = (FontPtr)SecurityLookupIDByType(client, stuff->id, RT_FONT,
-					    SecurityReadAccess);
+					    DixReadAccess);
     if (!pFont)
     {
 	  /* can't use VERIFY_GC because it might return BadGC */
 	pGC = (GC *) SecurityLookupIDByType(client, stuff->id, RT_GC,
-					    SecurityReadAccess);
+					    DixReadAccess);
         if (!pGC)
 	{
 	    client->errorValue = stuff->id;
@@ -1394,11 +1394,11 @@ ProcQueryTextExtents(register ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xQueryTextExtentsReq);
         
     pFont = (FontPtr)SecurityLookupIDByType(client, stuff->fid, RT_FONT,
-					    SecurityReadAccess);
+					    DixReadAccess);
     if (!pFont)
     {
         pGC = (GC *)SecurityLookupIDByType(client, stuff->fid, RT_GC,
-					   SecurityReadAccess);
+					   DixReadAccess);
         if (!pGC)
 	{
 	    client->errorValue = stuff->fid;
@@ -1479,7 +1479,7 @@ ProcCreatePixmap(register ClientPtr client)
     client->errorValue = stuff->pid;
     LEGAL_NEW_RESOURCE(stuff->pid, client);
     SECURITY_VERIFY_GEOMETRABLE (pDraw, stuff->drawable, client,
-				 SecurityReadAccess);
+				 DixReadAccess);
     if (!stuff->width || !stuff->height)
     {
 	client->errorValue = 0;
@@ -1535,7 +1535,7 @@ ProcFreePixmap(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xResourceReq);
     pMap = (PixmapPtr)SecurityLookupIDByType(client, stuff->id, RT_PIXMAP,
-					     SecurityDestroyAccess);
+					     DixDestroyAccess);
     if (pMap) 
     {
 	FreeResource(stuff->id, RT_NONE);
@@ -1562,7 +1562,7 @@ ProcCreateGC(register ClientPtr client)
     client->errorValue = stuff->gc;
     LEGAL_NEW_RESOURCE(stuff->gc, client);
     SECURITY_VERIFY_DRAWABLE (pDraw, stuff->drawable, client,
-			      SecurityReadAccess);
+			      DixReadAccess);
     len = client->req_len -  (sizeof(xCreateGCReq) >> 2);
     if (len != Ones(stuff->mask))
         return BadLength;
@@ -1584,7 +1584,7 @@ ProcChangeGC(register ClientPtr client)
     unsigned len;
 		
     REQUEST_AT_LEAST_SIZE(xChangeGCReq);
-    SECURITY_VERIFY_GC(pGC, stuff->gc, client, SecurityWriteAccess);
+    SECURITY_VERIFY_GC(pGC, stuff->gc, client, DixWriteAccess);
     len = client->req_len -  (sizeof(xChangeGCReq) >> 2);
     if (len != Ones(stuff->mask))
         return BadLength;
@@ -1608,8 +1608,8 @@ ProcCopyGC(register ClientPtr client)
     REQUEST(xCopyGCReq);
 
     REQUEST_SIZE_MATCH(xCopyGCReq);
-    SECURITY_VERIFY_GC( pGC, stuff->srcGC, client, SecurityReadAccess);
-    SECURITY_VERIFY_GC( dstGC, stuff->dstGC, client, SecurityWriteAccess);
+    SECURITY_VERIFY_GC( pGC, stuff->srcGC, client, DixReadAccess);
+    SECURITY_VERIFY_GC( dstGC, stuff->dstGC, client, DixWriteAccess);
     if ((dstGC->pScreen != pGC->pScreen) || (dstGC->depth != pGC->depth))
         return (BadMatch);    
     result = CopyGC(pGC, dstGC, stuff->mask);
@@ -1636,7 +1636,7 @@ ProcSetDashes(register ClientPtr client)
          return BadValue;
     }
 
-    SECURITY_VERIFY_GC(pGC,stuff->gc, client, SecurityWriteAccess);
+    SECURITY_VERIFY_GC(pGC,stuff->gc, client, DixWriteAccess);
 
     result = SetDashes(pGC, stuff->dashOffset, stuff->nDashes,
 		       (unsigned char *)&stuff[1]);
@@ -1664,7 +1664,7 @@ ProcSetClipRectangles(register ClientPtr client)
 	client->errorValue = stuff->ordering;
         return BadValue;
     }
-    SECURITY_VERIFY_GC(pGC,stuff->gc, client, SecurityWriteAccess);
+    SECURITY_VERIFY_GC(pGC,stuff->gc, client, DixWriteAccess);
 		 
     nr = (client->req_len << 2) - sizeof(xSetClipRectanglesReq);
     if (nr & 4)
@@ -1685,7 +1685,7 @@ ProcFreeGC(register ClientPtr client)
     REQUEST(xResourceReq);
 
     REQUEST_SIZE_MATCH(xResourceReq);
-    SECURITY_VERIFY_GC(pGC, stuff->id, client, SecurityDestroyAccess);
+    SECURITY_VERIFY_GC(pGC, stuff->id, client, DixDestroyAccess);
     FreeResource(stuff->id, RT_NONE);
     return(client->noClientException);
 }
@@ -1698,7 +1698,7 @@ ProcClearToBackground(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xClearAreaReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityWriteAccess);
+					   DixWriteAccess);
     if (!pWin)
         return(BadWindow);
     if (pWin->drawable.class == InputOnly)
@@ -1732,7 +1732,7 @@ ProcCopyArea(register ClientPtr client)
     if (stuff->dstDrawable != stuff->srcDrawable)
     {
 	SECURITY_VERIFY_DRAWABLE(pSrc, stuff->srcDrawable, client,
-				 SecurityReadAccess);
+				 DixReadAccess);
 	if ((pDst->pScreen != pSrc->pScreen) || (pDst->depth != pSrc->depth))
 	{
 	    client->errorValue = stuff->dstDrawable;
@@ -1772,7 +1772,7 @@ ProcCopyPlane(register ClientPtr client)
     if (stuff->dstDrawable != stuff->srcDrawable)
     {
 	SECURITY_VERIFY_DRAWABLE(psrcDraw, stuff->srcDrawable, client,
-				 SecurityReadAccess);
+				 DixReadAccess);
 	if (pdstDraw->pScreen != psrcDraw->pScreen)
 	{
 	    client->errorValue = stuff->dstDrawable;
@@ -2115,7 +2115,7 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
 	client->errorValue = format;
         return(BadValue);
     }
-    SECURITY_VERIFY_DRAWABLE(pDraw, drawable, client, SecurityReadAccess);
+    SECURITY_VERIFY_DRAWABLE(pDraw, drawable, client, DixReadAccess);
 
     memset(&xgi, 0, sizeof(xGetImageReply));
     if(pDraw->type == DRAWABLE_WINDOW)
@@ -2447,7 +2447,7 @@ ProcCreateColormap(register ClientPtr client)
     mid = stuff->mid;
     LEGAL_NEW_RESOURCE(mid, client);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
     if (!pWin)
         return(BadWindow);
 
@@ -2477,7 +2477,7 @@ ProcFreeColormap(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xResourceReq);
     pmap = (ColormapPtr )SecurityLookupIDByType(client, stuff->id, RT_COLORMAP,
-						SecurityDestroyAccess);
+						DixDestroyAccess);
     if (pmap) 
     {
 	/* Freeing a default colormap is a no-op */
@@ -2505,7 +2505,7 @@ ProcCopyColormapAndFree(register ClientPtr client)
     mid = stuff->mid;
     LEGAL_NEW_RESOURCE(mid, client);
     if( (pSrcMap = (ColormapPtr )SecurityLookupIDByType(client,	stuff->srcCmap,
-		RT_COLORMAP, SecurityReadAccess|SecurityWriteAccess)) )
+		RT_COLORMAP, DixReadAccess|DixWriteAccess)) )
     {
 	result = CopyColormapAndFree(mid, pSrcMap, client->index);
 	if (client->noClientException != Success)
@@ -2528,7 +2528,7 @@ ProcInstallColormap(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xResourceReq);
     pcmp = (ColormapPtr)SecurityLookupIDByType(client, stuff->id,
-					    RT_COLORMAP, SecurityReadAccess);
+					    RT_COLORMAP, DixReadAccess);
     if (pcmp)
     {
         (*(pcmp->pScreen->InstallColormap)) (pcmp);
@@ -2549,7 +2549,7 @@ ProcUninstallColormap(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xResourceReq);
     pcmp = (ColormapPtr)SecurityLookupIDByType(client, stuff->id,
-					RT_COLORMAP, SecurityReadAccess);
+					RT_COLORMAP, DixReadAccess);
     if (pcmp)
     {
 	if(pcmp->mid != pcmp->pScreen->defColormap)
@@ -2573,7 +2573,7 @@ ProcListInstalledColormaps(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xResourceReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->id, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
 
     if (!pWin)
         return(BadWindow);
@@ -2608,7 +2608,7 @@ ProcAllocColor (register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xAllocColorReq);
     pmap = (ColormapPtr)SecurityLookupIDByType(client, stuff->cmap,
-					RT_COLORMAP, SecurityWriteAccess);
+					RT_COLORMAP, DixWriteAccess);
     if (pmap)
     {
 	acr.type = X_Reply;
@@ -2648,7 +2648,7 @@ ProcAllocNamedColor (register ClientPtr client)
 
     REQUEST_FIXED_SIZE(xAllocNamedColorReq, stuff->nbytes);
     pcmp = (ColormapPtr)SecurityLookupIDByType(client, stuff->cmap,
-					    RT_COLORMAP, SecurityWriteAccess);
+					    RT_COLORMAP, DixWriteAccess);
     if (pcmp)
     {
 	int		retval;
@@ -2700,7 +2700,7 @@ ProcAllocColorCells (register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xAllocColorCellsReq);
     pcmp = (ColormapPtr)SecurityLookupIDByType(client, stuff->cmap,
-					RT_COLORMAP, SecurityWriteAccess);
+					RT_COLORMAP, DixWriteAccess);
     if (pcmp)
     {
 	xAllocColorCellsReply	accr;
@@ -2766,7 +2766,7 @@ ProcAllocColorPlanes(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xAllocColorPlanesReq);
     pcmp = (ColormapPtr)SecurityLookupIDByType(client, stuff->cmap,
-					RT_COLORMAP, SecurityWriteAccess);
+					RT_COLORMAP, DixWriteAccess);
     if (pcmp)
     {
 	xAllocColorPlanesReply	acpr;
@@ -2830,7 +2830,7 @@ ProcFreeColors(register ClientPtr client)
 
     REQUEST_AT_LEAST_SIZE(xFreeColorsReq);
     pcmp = (ColormapPtr)SecurityLookupIDByType(client, stuff->cmap,
-					RT_COLORMAP, SecurityWriteAccess);
+					RT_COLORMAP, DixWriteAccess);
     if (pcmp)
     {
 	int	count;
@@ -2865,7 +2865,7 @@ ProcStoreColors (ClientPtr client)
 
     REQUEST_AT_LEAST_SIZE(xStoreColorsReq);
     pcmp = (ColormapPtr)SecurityLookupIDByType(client, stuff->cmap,
-					RT_COLORMAP, SecurityWriteAccess);
+					RT_COLORMAP, DixWriteAccess);
     if (pcmp)
     {
 	int	count;
@@ -2899,7 +2899,7 @@ ProcStoreNamedColor (register ClientPtr client)
 
     REQUEST_FIXED_SIZE(xStoreNamedColorReq, stuff->nbytes);
     pcmp = (ColormapPtr)SecurityLookupIDByType(client, stuff->cmap,
-					RT_COLORMAP, SecurityWriteAccess);
+					RT_COLORMAP, DixWriteAccess);
     if (pcmp)
     {
 	xColorItem	def;
@@ -2933,7 +2933,7 @@ ProcQueryColors(register ClientPtr client)
 
     REQUEST_AT_LEAST_SIZE(xQueryColorsReq);
     pcmp = (ColormapPtr)SecurityLookupIDByType(client, stuff->cmap,
-					RT_COLORMAP, SecurityReadAccess);
+					RT_COLORMAP, DixReadAccess);
     if (pcmp)
     {
 	int			count, retval;
@@ -2987,7 +2987,7 @@ ProcLookupColor(register ClientPtr client)
 
     REQUEST_FIXED_SIZE(xLookupColorReq, stuff->nbytes);
     pcmp = (ColormapPtr)SecurityLookupIDByType(client, stuff->cmap,
-					RT_COLORMAP, SecurityReadAccess);
+					RT_COLORMAP, DixReadAccess);
     if (pcmp)
     {
 	xLookupColorReply lcr;
@@ -3037,9 +3037,9 @@ ProcCreateCursor (register ClientPtr client)
     LEGAL_NEW_RESOURCE(stuff->cid, client);
 
     src = (PixmapPtr)SecurityLookupIDByType(client, stuff->source,
-					      RT_PIXMAP, SecurityReadAccess);
+					      RT_PIXMAP, DixReadAccess);
     msk = (PixmapPtr)SecurityLookupIDByType(client, stuff->mask,
-					      RT_PIXMAP, SecurityReadAccess);
+					      RT_PIXMAP, DixReadAccess);
     if (   src == (PixmapPtr)NULL)
     {
 	client->errorValue = stuff->source;
@@ -3139,7 +3139,7 @@ ProcFreeCursor (register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xResourceReq);
     pCursor = (CursorPtr)SecurityLookupIDByType(client, stuff->id,
-					RT_CURSOR, SecurityDestroyAccess);
+					RT_CURSOR, DixDestroyAccess);
     if (pCursor) 
     {
 	FreeResource(stuff->id, RT_NONE);
@@ -3169,7 +3169,7 @@ ProcQueryBestSize (register ClientPtr client)
         return(BadValue);
     }
     SECURITY_VERIFY_GEOMETRABLE (pDraw, stuff->drawable, client,
-				 SecurityReadAccess);
+				 DixReadAccess);
     if (stuff->class != CursorShape && pDraw->type == UNDRAWABLE_WINDOW)
 	return (BadMatch);
     pScreen = pDraw->pScreen;
diff --git a/nx-X11/programs/Xserver/dix/dixfonts.c b/nx-X11/programs/Xserver/dix/dixfonts.c
index aa90b8769..f7d047c2d 100644
--- a/nx-X11/programs/Xserver/dix/dixfonts.c
+++ b/nx-X11/programs/Xserver/dix/dixfonts.c
@@ -1197,7 +1197,7 @@ doPolyText(ClientPtr client, register PTclosurePtr c)
     if (c->slept &&
 	c->pDraw &&
 	c->pDraw != (DrawablePtr)SecurityLookupIDByClass(client, c->did,
-					RC_DRAWABLE, SecurityWriteAccess))
+					RC_DRAWABLE, DixWriteAccess))
     {
 	/* Our drawable has disappeared.  Treat like client died... ask
 	   the FPE code to clean up after client and avoid further
@@ -1227,7 +1227,7 @@ doPolyText(ClientPtr client, register PTclosurePtr c)
 		 | ((Font)*(c->pElt+2)) << 16
 		 | ((Font)*(c->pElt+1)) << 24;
 	    pFont = (FontPtr)SecurityLookupIDByType(client, fid, RT_FONT,
-						    SecurityReadAccess);
+						    DixReadAccess);
 	    if (!pFont)
 	    {
 		client->errorValue = fid;
@@ -1489,7 +1489,7 @@ doImageText(ClientPtr client, register ITclosurePtr c)
     if (c->slept &&
 	c->pDraw &&
 	c->pDraw != (DrawablePtr)SecurityLookupIDByClass(client, c->did,
-					RC_DRAWABLE, SecurityWriteAccess))
+					RC_DRAWABLE, DixWriteAccess))
     {
 	/* Our drawable has disappeared.  Treat like client died... ask
 	   the FPE code to clean up after client. */
@@ -2044,7 +2044,7 @@ FontPtr
 find_old_font(XID id)
 {
     return (FontPtr) SecurityLookupIDByType(NullClient, id, RT_NONE,
-					    SecurityUnknownAccess);
+					    DixUnknownAccess);
 }
 
 Font
diff --git a/nx-X11/programs/Xserver/dix/dixutils.c b/nx-X11/programs/Xserver/dix/dixutils.c
index bd7439d89..bf925f748 100644
--- a/nx-X11/programs/Xserver/dix/dixutils.c
+++ b/nx-X11/programs/Xserver/dix/dixutils.c
@@ -260,13 +260,13 @@ SecurityLookupDrawable(XID rid, ClientPtr client, Mask access_mode)
 WindowPtr
 LookupWindow(XID rid, ClientPtr client)
 {
-    return SecurityLookupWindow(rid, client, SecurityUnknownAccess);
+    return SecurityLookupWindow(rid, client, DixUnknownAccess);
 }
 
 void *
 LookupDrawable(XID rid, ClientPtr client)
 {
-    return SecurityLookupDrawable(rid, client, SecurityUnknownAccess);
+    return SecurityLookupDrawable(rid, client, DixUnknownAccess);
 }
 
 #else /* not XCSECURITY */
@@ -317,7 +317,7 @@ ClientPtr
 LookupClient(XID rid, ClientPtr client)
 {
     void * pRes = (void *)SecurityLookupIDByClass(client, rid, RC_ANY,
-						    SecurityReadAccess);
+						    DixReadAccess);
     int clientIndex = CLIENT_ID(rid);
 
     if (clientIndex && pRes && clients[clientIndex] && !(rid & SERVER_BIT))
diff --git a/nx-X11/programs/Xserver/dix/events.c b/nx-X11/programs/Xserver/dix/events.c
index fa8bfc92d..fde3e91dd 100644
--- a/nx-X11/programs/Xserver/dix/events.c
+++ b/nx-X11/programs/Xserver/dix/events.c
@@ -2201,7 +2201,7 @@ XineramaWarpPointer(ClientPtr client)
 
     if (stuff->dstWid != None)
     {
-	dest = SecurityLookupWindow(stuff->dstWid, client, SecurityReadAccess);
+	dest = SecurityLookupWindow(stuff->dstWid, client, DixReadAccess);
 	if (!dest)
 	    return BadWindow;
     }
@@ -2214,7 +2214,7 @@ XineramaWarpPointer(ClientPtr client)
  	XID 	winID = stuff->srcWid;
         WindowPtr source;
 	
-	source = SecurityLookupWindow(winID, client, SecurityReadAccess);
+	source = SecurityLookupWindow(winID, client, DixReadAccess);
 	if (!source) return BadWindow;
 
 	winX = source->drawable.x;
@@ -2281,7 +2281,7 @@ ProcWarpPointer(ClientPtr client)
 
     if (stuff->dstWid != None)
     {
-	dest = SecurityLookupWindow(stuff->dstWid, client, SecurityReadAccess);
+	dest = SecurityLookupWindow(stuff->dstWid, client, DixReadAccess);
 	if (!dest)
 	    return BadWindow;
     }
@@ -2294,7 +2294,7 @@ ProcWarpPointer(ClientPtr client)
  	XID 	winID = stuff->srcWid;
         WindowPtr source;
 	
-	source = SecurityLookupWindow(winID, client, SecurityReadAccess);
+	source = SecurityLookupWindow(winID, client, DixReadAccess);
 	if (!source) return BadWindow;
 
 	winX = source->drawable.x;
@@ -3469,7 +3469,7 @@ SetInputFocus(
     else if ((focusID == FollowKeyboard) && followOK)
 	focusWin = inputInfo.keyboard->focus->win;
     else if (!(focusWin = SecurityLookupWindow(focusID, client,
-					       SecurityReadAccess)))
+					       DixReadAccess)))
 	return BadWindow;
     else
     {
@@ -3590,7 +3590,7 @@ ProcGrabPointer(ClientPtr client)
 	client->errorValue = stuff->eventMask;
         return BadValue;
     }
-    pWin = SecurityLookupWindow(stuff->grabWindow, client, SecurityReadAccess);
+    pWin = SecurityLookupWindow(stuff->grabWindow, client, DixReadAccess);
     if (!pWin)
 	return BadWindow;
     if (stuff->confineTo == None)
@@ -3598,7 +3598,7 @@ ProcGrabPointer(ClientPtr client)
     else 
     {
 	confineTo = SecurityLookupWindow(stuff->confineTo, client,
-					 SecurityReadAccess);
+					 DixReadAccess);
 	if (!confineTo)
 	    return BadWindow;
     }
@@ -3607,7 +3607,7 @@ ProcGrabPointer(ClientPtr client)
     else
     {
 	cursor = (CursorPtr)SecurityLookupIDByType(client, stuff->cursor,
-						RT_CURSOR, SecurityReadAccess);
+						RT_CURSOR, DixReadAccess);
 	if (!cursor)
 	{
 	    client->errorValue = stuff->cursor;
@@ -3682,7 +3682,7 @@ ProcChangeActivePointerGrab(ClientPtr client)
     else
     {
 	newCursor = (CursorPtr)SecurityLookupIDByType(client, stuff->cursor,
-						RT_CURSOR, SecurityReadAccess);
+						RT_CURSOR, DixReadAccess);
 	if (!newCursor)
 	{
 	    client->errorValue = stuff->cursor;
@@ -3752,7 +3752,7 @@ GrabDevice(register ClientPtr client, register DeviceIntPtr dev,
 	client->errorValue = ownerEvents;
         return BadValue;
     }
-    pWin = SecurityLookupWindow(grabWindow, client, SecurityReadAccess);
+    pWin = SecurityLookupWindow(grabWindow, client, DixReadAccess);
     if (!pWin)
 	return BadWindow;
     time = ClientTimeToServerTime(ctime);
@@ -3842,7 +3842,7 @@ ProcQueryPointer(ClientPtr client)
     DeviceIntPtr mouse = inputInfo.pointer;
 
     REQUEST_SIZE_MATCH(xResourceReq);
-    pWin = SecurityLookupWindow(stuff->id, client, SecurityReadAccess);
+    pWin = SecurityLookupWindow(stuff->id, client, DixReadAccess);
     if (!pWin)
 	return BadWindow;
     if (mouse->valuator->motionHintWindow)
@@ -4009,7 +4009,7 @@ ProcSendEvent(ClientPtr client)
     }
     else
 	pWin = SecurityLookupWindow(stuff->destination, client,
-				    SecurityReadAccess);
+				    DixReadAccess);
     if (!pWin)
 	return BadWindow;
     if ((stuff->propagate != xFalse) && (stuff->propagate != xTrue))
@@ -4048,7 +4048,7 @@ ProcUngrabKey(ClientPtr client)
     DeviceIntPtr keybd = inputInfo.keyboard;
 
     REQUEST_SIZE_MATCH(xUngrabKeyReq);
-    pWin = SecurityLookupWindow(stuff->grabWindow, client, SecurityReadAccess);
+    pWin = SecurityLookupWindow(stuff->grabWindow, client, DixReadAccess);
     if (!pWin)
 	return BadWindow;
 
@@ -4119,7 +4119,7 @@ ProcGrabKey(ClientPtr client)
 	client->errorValue = stuff->modifiers;
 	return BadValue;
     }
-    pWin = SecurityLookupWindow(stuff->grabWindow, client, SecurityReadAccess);
+    pWin = SecurityLookupWindow(stuff->grabWindow, client, DixReadAccess);
     if (!pWin)
 	return BadWindow;
 
@@ -4171,14 +4171,14 @@ ProcGrabButton(ClientPtr client)
 	client->errorValue = stuff->eventMask;
         return BadValue;
     }
-    pWin = SecurityLookupWindow(stuff->grabWindow, client, SecurityReadAccess);
+    pWin = SecurityLookupWindow(stuff->grabWindow, client, DixReadAccess);
     if (!pWin)
 	return BadWindow;
     if (stuff->confineTo == None)
        confineTo = NullWindow;
     else {
 	confineTo = SecurityLookupWindow(stuff->confineTo, client,
-					 SecurityReadAccess);
+					 DixReadAccess);
 	if (!confineTo)
 	    return BadWindow;
     }
@@ -4187,7 +4187,7 @@ ProcGrabButton(ClientPtr client)
     else
     {
 	cursor = (CursorPtr)SecurityLookupIDByType(client, stuff->cursor,
-						RT_CURSOR, SecurityReadAccess);
+						RT_CURSOR, DixReadAccess);
 	if (!cursor)
 	{
 	    client->errorValue = stuff->cursor;
@@ -4222,7 +4222,7 @@ ProcUngrabButton(ClientPtr client)
 	client->errorValue = stuff->modifiers;
 	return BadValue;
     }
-    pWin = SecurityLookupWindow(stuff->grabWindow, client, SecurityReadAccess);
+    pWin = SecurityLookupWindow(stuff->grabWindow, client, DixReadAccess);
     if (!pWin)
 	return BadWindow;
     tempGrab.resource = client->clientAsMask;
@@ -4376,7 +4376,7 @@ ProcRecolorCursor(ClientPtr client)
 
     REQUEST_SIZE_MATCH(xRecolorCursorReq);
     pCursor = (CursorPtr)SecurityLookupIDByType(client, stuff->cursor,
-					RT_CURSOR, SecurityWriteAccess);
+					RT_CURSOR, DixWriteAccess);
     if ( !pCursor) 
     {
 	client->errorValue = stuff->cursor;
diff --git a/nx-X11/programs/Xserver/dix/gc.c b/nx-X11/programs/Xserver/dix/gc.c
index 29f14de43..b3a4edf4d 100644
--- a/nx-X11/programs/Xserver/dix/gc.c
+++ b/nx-X11/programs/Xserver/dix/gc.c
@@ -271,7 +271,7 @@ dixChangeGC(ClientPtr client, register GC *pGC, register BITS32 mask, CARD32 *pC
 		{
 		    NEXTVAL(XID, newpix);
 		    pPixmap = (PixmapPtr)SecurityLookupIDByType(client,
-					newpix, RT_PIXMAP, SecurityReadAccess);
+					newpix, RT_PIXMAP, DixReadAccess);
 		}
 		if (pPixmap)
 		{
@@ -307,7 +307,7 @@ dixChangeGC(ClientPtr client, register GC *pGC, register BITS32 mask, CARD32 *pC
 		{
 		    NEXTVAL(XID, newstipple)
 		    pPixmap = (PixmapPtr)SecurityLookupIDByType(client,
-				newstipple, RT_PIXMAP, SecurityReadAccess);
+				newstipple, RT_PIXMAP, DixReadAccess);
 		}
 		if (pPixmap)
 		{
@@ -349,7 +349,7 @@ dixChangeGC(ClientPtr client, register GC *pGC, register BITS32 mask, CARD32 *pC
 		{
 		    NEXTVAL(XID, newfont)
 		    pFont = (FontPtr)SecurityLookupIDByType(client, newfont,
-						RT_FONT, SecurityReadAccess);
+						RT_FONT, DixReadAccess);
 		}
 		if (pFont)
 		{
@@ -416,7 +416,7 @@ dixChangeGC(ClientPtr client, register GC *pGC, register BITS32 mask, CARD32 *pC
 		    }
 		    else
 		        pPixmap = (PixmapPtr)SecurityLookupIDByType(client,
-					pid, RT_PIXMAP, SecurityReadAccess);
+					pid, RT_PIXMAP, DixReadAccess);
 		}
 
 		if (pPixmap)
diff --git a/nx-X11/programs/Xserver/dix/property.c b/nx-X11/programs/Xserver/dix/property.c
index 2e5569367..f5713cf5e 100644
--- a/nx-X11/programs/Xserver/dix/property.c
+++ b/nx-X11/programs/Xserver/dix/property.c
@@ -106,7 +106,7 @@ ProcRotateProperties(ClientPtr client)
     REQUEST_FIXED_SIZE(xRotatePropertiesReq, stuff->nAtoms << 2);
     UpdateCurrentTime();
     pWin = (WindowPtr) SecurityLookupWindow(stuff->window, client,
-					    SecurityWriteAccess);
+					    DixWriteAccess);
     if (!pWin)
         return(BadWindow);
     if (!stuff->nAtoms)
@@ -119,7 +119,7 @@ ProcRotateProperties(ClientPtr client)
     {
 #ifdef XCSECURITY
 	char action = SecurityCheckPropertyAccess(client, pWin, atoms[i],
-				SecurityReadAccess|SecurityWriteAccess);
+				DixReadAccess|DixWriteAccess);
 #endif
         if (!ValidAtom(atoms[i])
 #ifdef XCSECURITY
@@ -219,7 +219,7 @@ ProcChangeProperty(ClientPtr client)
     REQUEST_FIXED_SIZE(xChangePropertyReq, totalSize);
 
     pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityWriteAccess);
+					   DixWriteAccess);
     if (!pWin)
 	return(BadWindow);
     if (!ValidAtom(stuff->property))
@@ -235,7 +235,7 @@ ProcChangeProperty(ClientPtr client)
 
 #ifdef XCSECURITY
     switch (SecurityCheckPropertyAccess(client, pWin, stuff->property,
-					SecurityWriteAccess))
+					DixWriteAccess))
     {
 	case SecurityErrorOperation:
 	    client->errorValue = stuff->property;
@@ -469,7 +469,7 @@ ProcGetProperty(ClientPtr client)
     if (stuff->delete)
 	UpdateCurrentTime();
     pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
     if (!pWin)
 	return BadWindow;
 
@@ -507,10 +507,10 @@ ProcGetProperty(ClientPtr client)
 
 #ifdef XCSECURITY
     {
-	Mask access_mode = SecurityReadAccess;
+	Mask access_mode = DixReadAccess;
 
 	if (stuff->delete)
-	    access_mode |= SecurityDestroyAccess;
+	    access_mode |= DixDestroyAccess;
 	switch(SecurityCheckPropertyAccess(client, pWin, stuff->property,
 					   access_mode))
 	{
@@ -614,7 +614,7 @@ ProcListProperties(ClientPtr client)
 
     REQUEST_SIZE_MATCH(xResourceReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->id, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
     if (!pWin)
         return(BadWindow);
 
@@ -659,7 +659,7 @@ ProcDeleteProperty(register ClientPtr client)
     REQUEST_SIZE_MATCH(xDeletePropertyReq);
     UpdateCurrentTime();
     pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityWriteAccess);
+					   DixWriteAccess);
     if (!pWin)
         return(BadWindow);
     if (!ValidAtom(stuff->property))
@@ -670,7 +670,7 @@ ProcDeleteProperty(register ClientPtr client)
 
 #ifdef XCSECURITY
     switch(SecurityCheckPropertyAccess(client, pWin, stuff->property,
-				       SecurityDestroyAccess))
+				       DixDestroyAccess))
     {
 	case SecurityErrorOperation:
 	    client->errorValue = stuff->property;
diff --git a/nx-X11/programs/Xserver/dix/resource.c b/nx-X11/programs/Xserver/dix/resource.c
index ca7da1601..d22b0cdd0 100644
--- a/nx-X11/programs/Xserver/dix/resource.c
+++ b/nx-X11/programs/Xserver/dix/resource.c
@@ -878,14 +878,14 @@ void *
 LookupIDByType(XID id, RESTYPE rtype)
 {
     return SecurityLookupIDByType(NullClient, id, rtype,
-				  SecurityUnknownAccess);
+				  DixUnknownAccess);
 }
 
 void *
 LookupIDByClass(XID id, RESTYPE classes)
 {
     return SecurityLookupIDByClass(NullClient, id, classes,
-				   SecurityUnknownAccess);
+				   DixUnknownAccess);
 }
 
 #else /* not XCSECURITY */
diff --git a/nx-X11/programs/Xserver/dix/window.c b/nx-X11/programs/Xserver/dix/window.c
index 1239ab9f7..a7346e778 100644
--- a/nx-X11/programs/Xserver/dix/window.c
+++ b/nx-X11/programs/Xserver/dix/window.c
@@ -1028,7 +1028,7 @@ ChangeWindowAttributes(register WindowPtr pWin, Mask vmask, XID *vlist, ClientPt
 	    else
 	    {	
 		pPixmap = (PixmapPtr)SecurityLookupIDByType(client, pixID,
-						RT_PIXMAP, SecurityReadAccess);
+						RT_PIXMAP, DixReadAccess);
 		if (pPixmap != (PixmapPtr) NULL)
 		{
 		    if	((pPixmap->drawable.depth != pWin->drawable.depth) ||
@@ -1089,7 +1089,7 @@ ChangeWindowAttributes(register WindowPtr pWin, Mask vmask, XID *vlist, ClientPt
 	    else
 	    {	
 		pPixmap = (PixmapPtr)SecurityLookupIDByType(client, pixID,
-					RT_PIXMAP, SecurityReadAccess);
+					RT_PIXMAP, DixReadAccess);
 		if (pPixmap)
 		{
 		    if	((pPixmap->drawable.depth != pWin->drawable.depth) ||
@@ -1302,7 +1302,7 @@ ChangeWindowAttributes(register WindowPtr pWin, Mask vmask, XID *vlist, ClientPt
 		goto PatchUp;
 	    }
 	    pCmap = (ColormapPtr)SecurityLookupIDByType(client, cmap,
-					      RT_COLORMAP, SecurityReadAccess);
+					      RT_COLORMAP, DixReadAccess);
 	    if (!pCmap)
 	    {
 		error = BadColor;
@@ -1378,7 +1378,7 @@ ChangeWindowAttributes(register WindowPtr pWin, Mask vmask, XID *vlist, ClientPt
 	    else
 	    {
 		pCursor = (CursorPtr)SecurityLookupIDByType(client, cursorID,
-						RT_CURSOR, SecurityReadAccess);
+						RT_CURSOR, DixReadAccess);
 		if (!pCursor)
 		{
 		    error = BadCursor;
@@ -2252,7 +2252,7 @@ ConfigureWindow(register WindowPtr pWin, register Mask mask, XID *vlist, ClientP
 	    sibwid = (Window ) *pVlist;
 	    pVlist++;
 	    pSib = (WindowPtr )SecurityLookupIDByType(client, sibwid,
-						RT_WINDOW, SecurityReadAccess);
+						RT_WINDOW, DixReadAccess);
 	    if (!pSib)
 	    {
 		client->errorValue = sibwid;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c b/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c
index 8fc6cf5fd..a46434bf1 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXdispatch.c
@@ -586,7 +586,7 @@ ProcReparentWindow(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xReparentWindowReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityWriteAccess);
+					   DixWriteAccess);
     if (!pWin)
         return(BadWindow);
 
@@ -596,7 +596,7 @@ ProcReparentWindow(register ClientPtr client)
     }
 
     pParent = (WindowPtr)SecurityLookupWindow(stuff->parent, client,
-					      SecurityWriteAccess);
+					      DixWriteAccess);
     if (!pParent)
         return(BadWindow);
     if (SAME_SCREENS(pWin->drawable, pParent->drawable))
@@ -630,7 +630,7 @@ ProcQueryTree(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xResourceReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->id, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
     if (!pWin)
         return(BadWindow);
     memset(&reply, 0, sizeof(xQueryTreeReply));
@@ -698,7 +698,7 @@ ProcSetSelectionOwner(register ClientPtr client)
     if (stuff->window != None)
     {
         pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					       SecurityReadAccess);
+					       DixReadAccess);
         if (!pWin)
             return(BadWindow);
     }
@@ -797,7 +797,7 @@ ProcConvertSelection(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xConvertSelectionReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->requestor, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
     if (!pWin)
         return(BadWindow);
 
@@ -837,7 +837,7 @@ ProcConvertSelection(register ClientPtr client)
 #ifdef XCSECURITY
 	    && (!client->CheckAccess ||
 		(* client->CheckAccess)(client, CurrentSelections[i].window,
-					RT_WINDOW, SecurityReadAccess,
+					RT_WINDOW, DixReadAccess,
 					CurrentSelections[i].pWin))
 #endif
 	    )
@@ -918,7 +918,7 @@ ProcCloseFont(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xResourceReq);
     pFont = (FontPtr)SecurityLookupIDByType(client, stuff->id, RT_FONT,
-					    SecurityDestroyAccess);
+					    DixDestroyAccess);
     if (pFont != (FontPtr)NULL)
     {
         #ifdef NXAGENT_SERVER
@@ -1015,7 +1015,7 @@ ProcFreePixmap(register ClientPtr client)
 
     REQUEST_SIZE_MATCH(xResourceReq);
     pMap = (PixmapPtr)SecurityLookupIDByType(client, stuff->id, RT_PIXMAP,
-					     SecurityDestroyAccess);
+					     DixDestroyAccess);
     if (pMap) 
     {
         #ifdef NXAGENT_SERVER
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXevents.c b/nx-X11/programs/Xserver/hw/nxagent/NXevents.c
index f507e5f71..43cb806e7 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXevents.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXevents.c
@@ -583,7 +583,7 @@ ProcSendEvent(ClientPtr client)
     }
     else
 	pWin = SecurityLookupWindow(stuff->destination, client,
-				    SecurityReadAccess);
+				    DixReadAccess);
     if (!pWin)
 	return BadWindow;
     if ((stuff->propagate != xFalse) && (stuff->propagate != xTrue))
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXproperty.c b/nx-X11/programs/Xserver/hw/nxagent/NXproperty.c
index 881d2e2d0..28fdd19f5 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXproperty.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXproperty.c
@@ -131,7 +131,7 @@ ProcChangeProperty(ClientPtr client)
     if (pWin == NULL)
 #endif
     pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityWriteAccess);
+					   DixWriteAccess);
     if (!pWin)
 	return(BadWindow);
     if (!ValidAtom(stuff->property))
@@ -147,7 +147,7 @@ ProcChangeProperty(ClientPtr client)
 
 #ifdef XCSECURITY
     switch (SecurityCheckPropertyAccess(client, pWin, stuff->property,
-					SecurityWriteAccess))
+					DixWriteAccess))
     {
 	case SecurityErrorOperation:
 	    client->errorValue = stuff->property;
@@ -348,7 +348,7 @@ ProcGetProperty(ClientPtr client)
     if (stuff->delete)
 	UpdateCurrentTime();
     pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
     if (!pWin)
 	return BadWindow;
 
@@ -439,10 +439,10 @@ ProcGetProperty(ClientPtr client)
 
 #ifdef XCSECURITY
     {
-	Mask access_mode = SecurityReadAccess;
+	Mask access_mode = DixReadAccess;
 
 	if (stuff->delete)
-	    access_mode |= SecurityDestroyAccess;
+	    access_mode |= DixDestroyAccess;
 	switch(SecurityCheckPropertyAccess(client, pWin, stuff->property,
 					   access_mode))
 	{
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXrender.c b/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
index b8c5cdbd2..8d55516fb 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXrender.c
@@ -385,11 +385,11 @@ ProcRenderCreatePicture (ClientPtr client)
 
     LEGAL_NEW_RESOURCE(stuff->pid, client);
     SECURITY_VERIFY_DRAWABLE(pDrawable, stuff->drawable, client,
-			     SecurityWriteAccess);
+			     DixWriteAccess);
     pFormat = (PictFormatPtr) SecurityLookupIDByType (client, 
 						      stuff->format,
 						      PictFormatType,
-						      SecurityReadAccess);
+						      DixReadAccess);
     if (!pFormat)
     {
 	client->errorValue = stuff->format;
@@ -426,7 +426,7 @@ ProcRenderChangePicture (ClientPtr client)
     int error;
 
     REQUEST_AT_LEAST_SIZE(xRenderChangePictureReq);
-    VERIFY_PICTURE (pPicture, stuff->picture, client, SecurityWriteAccess,
+    VERIFY_PICTURE (pPicture, stuff->picture, client, DixWriteAccess,
 		    RenderErrBase + BadPicture);
 
     len = client->req_len - (sizeof(xRenderChangePictureReq) >> 2);
@@ -450,7 +450,7 @@ ProcRenderSetPictureClipRectangles (ClientPtr client)
     int		    result;
 
     REQUEST_AT_LEAST_SIZE(xRenderSetPictureClipRectanglesReq);
-    VERIFY_PICTURE (pPicture, stuff->picture, client, SecurityWriteAccess,
+    VERIFY_PICTURE (pPicture, stuff->picture, client, DixWriteAccess,
 		    RenderErrBase + BadPicture);
     if (!pPicture->pDrawable)
         return BadDrawable;
@@ -558,13 +558,13 @@ ProcRenderComposite (ClientPtr client)
 	client->errorValue = stuff->op;
 	return BadValue;
     }
-    VERIFY_PICTURE (pDst, stuff->dst, client, SecurityWriteAccess,
+    VERIFY_PICTURE (pDst, stuff->dst, client, DixWriteAccess,
 		    RenderErrBase + BadPicture);
     if (!pDst->pDrawable)
         return BadDrawable;
-    VERIFY_PICTURE (pSrc, stuff->src, client, SecurityReadAccess, 
+    VERIFY_PICTURE (pSrc, stuff->src, client, DixReadAccess,
 		    RenderErrBase + BadPicture);
-    VERIFY_ALPHA (pMask, stuff->mask, client, SecurityReadAccess, 
+    VERIFY_ALPHA (pMask, stuff->mask, client, DixReadAccess,
 		  RenderErrBase + BadPicture);
 
     if ((pSrc->pDrawable && pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen) ||
@@ -687,9 +687,9 @@ ProcRenderTrapezoids (ClientPtr client)
 	client->errorValue = stuff->op;
 	return BadValue;
     }
-    VERIFY_PICTURE (pSrc, stuff->src, client, SecurityReadAccess, 
+    VERIFY_PICTURE (pSrc, stuff->src, client, DixReadAccess,
 		    RenderErrBase + BadPicture);
-    VERIFY_PICTURE (pDst, stuff->dst, client, SecurityWriteAccess, 
+    VERIFY_PICTURE (pDst, stuff->dst, client, DixWriteAccess,
 		    RenderErrBase + BadPicture);
     if (!pDst->pDrawable)
         return BadDrawable;
@@ -700,7 +700,7 @@ ProcRenderTrapezoids (ClientPtr client)
 	pFormat = (PictFormatPtr) SecurityLookupIDByType (client,
 							  stuff->maskFormat,
 							  PictFormatType,
-							  SecurityReadAccess);
+							  DixReadAccess);
 	if (!pFormat)
 	{
 	    client->errorValue = stuff->maskFormat;
@@ -758,7 +758,7 @@ ProcRenderCreateGlyphSet (ClientPtr client)
     format = (PictFormatPtr) SecurityLookupIDByType (client,
 						     stuff->format,
 						     PictFormatType,
-						     SecurityReadAccess);
+						     DixReadAccess);
     if (!format)
     {
 	client->errorValue = stuff->format;
@@ -809,7 +809,7 @@ ProcRenderReferenceGlyphSet (ClientPtr client)
     glyphSet = (GlyphSetPtr) SecurityLookupIDByType (client,
 						     stuff->existing,
 						     GlyphSetType,
-						     SecurityWriteAccess);
+						     DixWriteAccess);
     if (!glyphSet)
     {
 	client->errorValue = stuff->existing;
@@ -834,7 +834,7 @@ ProcRenderFreeGlyphSet (ClientPtr client)
     glyphSet = (GlyphSetPtr) SecurityLookupIDByType (client,
 						     stuff->glyphset,
 						     GlyphSetType,
-						     SecurityDestroyAccess);
+						     DixDestroyAccess);
     if (!glyphSet)
     {
 	client->errorValue = stuff->glyphset;
@@ -860,7 +860,7 @@ ProcRenderFreeGlyphs (ClientPtr client)
     glyphSet = (GlyphSetPtr) SecurityLookupIDByType (client,
 						     stuff->glyphset,
 						     GlyphSetType,
-						     SecurityWriteAccess);
+						     DixWriteAccess);
     if (!glyphSet)
     {
 	client->errorValue = stuff->glyphset;
@@ -928,9 +928,9 @@ ProcRenderCompositeGlyphs (ClientPtr client)
 	client->errorValue = stuff->op;
 	return BadValue;
     }
-    VERIFY_PICTURE (pSrc, stuff->src, client, SecurityReadAccess,
+    VERIFY_PICTURE (pSrc, stuff->src, client, DixReadAccess,
 		    RenderErrBase + BadPicture);
-    VERIFY_PICTURE (pDst, stuff->dst, client, SecurityWriteAccess,
+    VERIFY_PICTURE (pDst, stuff->dst, client, DixWriteAccess,
 		    RenderErrBase + BadPicture);
     if (!pDst->pDrawable)
         return BadDrawable;
@@ -941,7 +941,7 @@ ProcRenderCompositeGlyphs (ClientPtr client)
 	pFormat = (PictFormatPtr) SecurityLookupIDByType (client,
 							  stuff->maskFormat,
 							  PictFormatType,
-							  SecurityReadAccess);
+							  DixReadAccess);
 	if (!pFormat)
 	{
 	    client->errorValue = stuff->maskFormat;
@@ -954,7 +954,7 @@ ProcRenderCompositeGlyphs (ClientPtr client)
     glyphSet = (GlyphSetPtr) SecurityLookupIDByType (client,
 						     stuff->glyphset,
 						     GlyphSetType,
-						     SecurityReadAccess);
+						     DixReadAccess);
     if (!glyphSet)
     {
 	client->errorValue = stuff->glyphset;
@@ -1027,7 +1027,7 @@ ProcRenderCompositeGlyphs (ClientPtr client)
 		glyphSet = (GlyphSetPtr) SecurityLookupIDByType (client,
 								 gs,
 								 GlyphSetType,
-								 SecurityReadAccess);
+								 DixReadAccess);
 		if (!glyphSet)
 		{
 		    client->errorValue = gs;
@@ -1163,7 +1163,7 @@ ProcRenderFillRectangles (ClientPtr client)
 	client->errorValue = stuff->op;
 	return BadValue;
     }
-    VERIFY_PICTURE (pDst, stuff->dst, client, SecurityWriteAccess, 
+    VERIFY_PICTURE (pDst, stuff->dst, client, DixWriteAccess,
 		    RenderErrBase + BadPicture);
     if (!pDst->pDrawable)
         return BadDrawable;
@@ -1212,7 +1212,7 @@ ProcRenderCreateCursor (ClientPtr client)
     REQUEST_SIZE_MATCH (xRenderCreateCursorReq);
     LEGAL_NEW_RESOURCE(stuff->cid, client);
     
-    VERIFY_PICTURE (pSrc, stuff->src, client, SecurityReadAccess, 
+    VERIFY_PICTURE (pSrc, stuff->src, client, DixReadAccess,
 		    RenderErrBase + BadPicture);
     if (!pSrc->pDrawable)
         return BadDrawable;
@@ -1430,7 +1430,7 @@ ProcRenderSetPictureTransform (ClientPtr client)
     int		result;
 
     REQUEST_SIZE_MATCH(xRenderSetPictureTransformReq);
-    VERIFY_PICTURE (pPicture, stuff->picture, client, SecurityWriteAccess,
+    VERIFY_PICTURE (pPicture, stuff->picture, client, DixWriteAccess,
 		    RenderErrBase + BadPicture);
     result = SetPictureTransform (pPicture, (PictTransform *) &stuff->transform);
 
@@ -1453,7 +1453,7 @@ ProcRenderSetPictureFilter (ClientPtr client)
     char	*name;
     
     REQUEST_AT_LEAST_SIZE (xRenderSetPictureFilterReq);
-    VERIFY_PICTURE (pPicture, stuff->picture, client, SecurityWriteAccess,
+    VERIFY_PICTURE (pPicture, stuff->picture, client, DixWriteAccess,
 		    RenderErrBase + BadPicture);
     name = (char *) (stuff + 1);
     params = (xFixed *) (name + ((stuff->nbytes + 3) & ~3));
@@ -1490,7 +1490,7 @@ ProcRenderCreateAnimCursor (ClientPtr client)
     for (i = 0; i < ncursor; i++)
     {
 	cursors[i] = (CursorPtr)SecurityLookupIDByType(client, elt->cursor,
-						       RT_CURSOR, SecurityReadAccess);
+						       RT_CURSOR, DixReadAccess);
 	if (!cursors[i])
 	{
 	    free (cursors);
diff --git a/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c b/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c
index 7cb29bde5..adff36569 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/NXwindow.c
@@ -503,7 +503,7 @@ ConfigureWindow(register WindowPtr pWin, register Mask mask, XID *vlist, ClientP
 	    sibwid = (Window ) *pVlist;
 	    pVlist++;
 	    pSib = (WindowPtr )SecurityLookupIDByType(client, sibwid,
-						RT_WINDOW, SecurityReadAccess);
+						RT_WINDOW, DixReadAccess);
 	    if (!pSib)
 	    {
 		client->errorValue = sibwid;
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Rootless.c b/nx-X11/programs/Xserver/hw/nxagent/Rootless.c
index bb961e5a8..bb19b3458 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Rootless.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Rootless.c
@@ -540,7 +540,7 @@ int nxagentExportProperty(pWin, property, type, format, mode, nUnits, value)
     if ((wmHints.flags & IconPixmapHint) && (wmHints.icon_pixmap != None))
     {
       PixmapPtr icon = (PixmapPtr)SecurityLookupIDByType(pClient, wmHints.icon_pixmap,
-                                                             RT_PIXMAP, SecurityDestroyAccess);
+                                                             RT_PIXMAP, DixDestroyAccess);
 
       if (icon)
       {
@@ -567,7 +567,7 @@ int nxagentExportProperty(pWin, property, type, format, mode, nUnits, value)
     if ((wmHints.flags & IconWindowHint) && (wmHints.icon_window != None))
     {
       WindowPtr icon = (WindowPtr)SecurityLookupWindow(wmHints.icon_window, pClient,
-                                                  SecurityDestroyAccess);
+                                                  DixDestroyAccess);
 
       if (icon)
       {
@@ -589,7 +589,7 @@ int nxagentExportProperty(pWin, property, type, format, mode, nUnits, value)
     if ((wmHints.flags & IconMaskHint) && (wmHints.icon_mask != None))
     {
       PixmapPtr icon = (PixmapPtr)SecurityLookupIDByType(pClient, wmHints.icon_mask,
-                                                             RT_PIXMAP, SecurityDestroyAccess);
+                                                             RT_PIXMAP, DixDestroyAccess);
 
       if (icon)
       {
@@ -611,7 +611,7 @@ int nxagentExportProperty(pWin, property, type, format, mode, nUnits, value)
     if ((wmHints.flags & WindowGroupHint) && (wmHints.window_group != None))
     {
       WindowPtr window = (WindowPtr)SecurityLookupWindow(wmHints.window_group, pClient,
-                                                  SecurityDestroyAccess);
+                                                  DixDestroyAccess);
 
       if (window)
       {
@@ -695,7 +695,7 @@ int nxagentExportProperty(pWin, property, type, format, mode, nUnits, value)
     for (i = 0; i < nUnits; i++)
     {
       pWindow = (WindowPtr)SecurityLookupWindow(input[i], pClient,
-                                                    SecurityDestroyAccess);
+                                                    DixDestroyAccess);
       if ((input[i] != None) && pWindow)
       {
         wind[i] = nxagentWindow(pWindow);
diff --git a/nx-X11/programs/Xserver/include/dix.h b/nx-X11/programs/Xserver/include/dix.h
index 4b9c7749c..0b08b46a9 100644
--- a/nx-X11/programs/Xserver/include/dix.h
+++ b/nx-X11/programs/Xserver/include/dix.h
@@ -138,13 +138,13 @@ SOFTWARE.
     }
 
 #define VERIFY_DRAWABLE(pDraw, did, client)\
-	SECURITY_VERIFY_DRAWABLE(pDraw, did, client, SecurityUnknownAccess)
+	SECURITY_VERIFY_DRAWABLE(pDraw, did, client, DixUnknownAccess)
 
 #define VERIFY_GEOMETRABLE(pDraw, did, client)\
-	SECURITY_VERIFY_GEOMETRABLE(pDraw, did, client, SecurityUnknownAccess)
+	SECURITY_VERIFY_GEOMETRABLE(pDraw, did, client, DixUnknownAccess)
 
 #define VERIFY_GC(pGC, rid, client)\
-	SECURITY_VERIFY_GC(pGC, rid, client, SecurityUnknownAccess)
+	SECURITY_VERIFY_GC(pGC, rid, client, DixUnknownAccess)
 
 #else /* not XCSECURITY */
 
@@ -255,8 +255,8 @@ SOFTWARE.
     if ((stuff->gc == INVALID) || (client->lastGCID != stuff->gc) ||\
 	(client->lastDrawableID != drawID))\
     {\
-	SECURITY_VERIFY_GEOMETRABLE(pDraw, drawID, client, SecurityWriteAccess);\
-	SECURITY_VERIFY_GC(pGC, stuff->gc, client, SecurityReadAccess);\
+	SECURITY_VERIFY_GEOMETRABLE(pDraw, drawID, client, DixWriteAccess);\
+	SECURITY_VERIFY_GC(pGC, stuff->gc, client, DixReadAccess);\
 	if ((pGC->depth != pDraw->depth) ||\
 	    (pGC->pScreen != pDraw->pScreen))\
 	    return (BadMatch);\
diff --git a/nx-X11/programs/Xserver/include/resource.h b/nx-X11/programs/Xserver/include/resource.h
index 5e169e093..164e7ccfc 100644
--- a/nx-X11/programs/Xserver/include/resource.h
+++ b/nx-X11/programs/Xserver/include/resource.h
@@ -220,10 +220,10 @@ extern void * LookupClientResourceComplex(
  * simultaneously.
  */
 
-#define SecurityUnknownAccess	0	/* don't know intentions */
-#define SecurityReadAccess	(1<<0)	/* inspecting the object */
-#define SecurityWriteAccess	(1<<1)	/* changing the object */
-#define SecurityDestroyAccess	(1<<2)	/* destroying the object */
+#define DixUnknownAccess	0	/* don't know intentions */
+#define DixReadAccess	(1<<0)	/* inspecting the object */
+#define DixWriteAccess	(1<<1)	/* changing the object */
+#define DixDestroyAccess	(1<<2)	/* destroying the object */
 
 #ifdef XCSECURITY
 
diff --git a/nx-X11/programs/Xserver/randr/randrstr.h b/nx-X11/programs/Xserver/randr/randrstr.h
index 459a47383..4b497f82d 100644
--- a/nx-X11/programs/Xserver/randr/randrstr.h
+++ b/nx-X11/programs/Xserver/randr/randrstr.h
@@ -443,12 +443,8 @@ extern _X_EXPORT RESTYPE RRCrtcType, RRModeType, RROutputType, RRProviderType;
                                 (SecurityLookupIDByType (client, id, \
                                                          RRProviderType, a)))
 
-#define DixUnknownAccess     SecurityUnknownAccess
-#define DixReadAccess        SecurityReadAccess
-#define DixWriteAccess       SecurityWriteAccess
-#define DixSetAttrAccess     SecurityWriteAccess
-#define DixUseAccess         SecurityWriteAccess
-#define DixDestroyAccess     SecurityDestroyAccess
+#define DixSetAttrAccess     DixWriteAccess
+#define DixUseAccess         DixWriteAccess
 
 #endif
 
diff --git a/nx-X11/programs/Xserver/randr/rrdispatch.c b/nx-X11/programs/Xserver/randr/rrdispatch.c
index 14f74d771..68d3b97e6 100644
--- a/nx-X11/programs/Xserver/randr/rrdispatch.c
+++ b/nx-X11/programs/Xserver/randr/rrdispatch.c
@@ -87,7 +87,7 @@ ProcRRSelectInput(ClientPtr client)
 #ifndef NXAGENT_SERVER
     rc = dixLookupWindow(&pWin, stuff->window, client, DixReceiveAccess);
 #else
-    pWin = SecurityLookupWindow(stuff->window, client, SecurityWriteAccess);
+    pWin = SecurityLookupWindow(stuff->window, client, DixWriteAccess);
     rc = pWin ? Success : BadWindow;
 #endif
     if (rc != Success)
diff --git a/nx-X11/programs/Xserver/randr/rrmode.c b/nx-X11/programs/Xserver/randr/rrmode.c
index a2bbec7d9..9f8277a55 100644
--- a/nx-X11/programs/Xserver/randr/rrmode.c
+++ b/nx-X11/programs/Xserver/randr/rrmode.c
@@ -357,7 +357,7 @@ ProcRRCreateMode(ClientPtr client)
 #ifndef NXAGENT_SERVER
     rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
 #else
-    pWin = SecurityLookupWindow(stuff->window, client, SecurityReadAccess);
+    pWin = SecurityLookupWindow(stuff->window, client, DixReadAccess);
     rc = pWin ? Success : BadWindow;
 #endif
     if (rc != Success)
diff --git a/nx-X11/programs/Xserver/randr/rrmonitor.c b/nx-X11/programs/Xserver/randr/rrmonitor.c
index 8829caf2f..13b061c35 100644
--- a/nx-X11/programs/Xserver/randr/rrmonitor.c
+++ b/nx-X11/programs/Xserver/randr/rrmonitor.c
@@ -636,7 +636,7 @@ ProcRRGetMonitors(ClientPtr client)
 #ifndef NXAGENT_SERVER
     r = dixLookupWindow(&window, stuff->window, client, DixGetAttrAccess);
 #else
-    window = SecurityLookupWindow(stuff->window, client, SecurityReadAccess);
+    window = SecurityLookupWindow(stuff->window, client, DixReadAccess);
     r = window ? Success : BadWindow;
 #endif
 
@@ -723,7 +723,7 @@ ProcRRSetMonitor(ClientPtr client)
 #ifndef NXAGENT_SERVER
     r = dixLookupWindow(&window, stuff->window, client, DixGetAttrAccess);
 #else
-    window = SecurityLookupWindow(stuff->window, client, SecurityReadAccess);
+    window = SecurityLookupWindow(stuff->window, client, DixReadAccess);
     r = window ? Success : BadWindow;
 #endif
 
@@ -772,7 +772,7 @@ ProcRRDeleteMonitor(ClientPtr client)
 #ifndef NXAGENT_SERVER
     r = dixLookupWindow(&window, stuff->window, client, DixGetAttrAccess);
 #else
-    window = SecurityLookupWindow(stuff->window, client, SecurityReadAccess);
+    window = SecurityLookupWindow(stuff->window, client, DixReadAccess);
     r = window ? Success : BadWindow;
 #endif
 
diff --git a/nx-X11/programs/Xserver/randr/rroutput.c b/nx-X11/programs/Xserver/randr/rroutput.c
index 07fda36b5..9e31a423b 100644
--- a/nx-X11/programs/Xserver/randr/rroutput.c
+++ b/nx-X11/programs/Xserver/randr/rroutput.c
@@ -583,7 +583,7 @@ ProcRRSetOutputPrimary(ClientPtr client)
 #ifndef NXAGENT_SERVER
     ret = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
 #else
-    pWin = SecurityLookupWindow(stuff->window, client, SecurityReadAccess);
+    pWin = SecurityLookupWindow(stuff->window, client, DixReadAccess);
     ret = pWin ? Success : BadWindow;
 #endif
 
@@ -641,7 +641,7 @@ ProcRRGetOutputPrimary(ClientPtr client)
 #ifndef NXAGENT_SERVER
     rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
 #else
-    pWin = SecurityLookupWindow(stuff->window, client, SecurityReadAccess);
+    pWin = SecurityLookupWindow(stuff->window, client, DixReadAccess);
     rc = pWin ? Success : BadWindow;
 #endif
 
diff --git a/nx-X11/programs/Xserver/randr/rrprovider.c b/nx-X11/programs/Xserver/randr/rrprovider.c
index fe99fa04d..a56d1ca1a 100644
--- a/nx-X11/programs/Xserver/randr/rrprovider.c
+++ b/nx-X11/programs/Xserver/randr/rrprovider.c
@@ -69,7 +69,7 @@ ProcRRGetProviders(ClientPtr client)
 #ifndef NXAGENT_SERVER
     rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
 #else
-    pWin = SecurityLookupWindow(stuff->window, client, SecurityReadAccess);
+    pWin = SecurityLookupWindow(stuff->window, client, DixReadAccess);
     rc = pWin ? Success : BadWindow;
 #endif
 
diff --git a/nx-X11/programs/Xserver/randr/rrscreen.c b/nx-X11/programs/Xserver/randr/rrscreen.c
index bdb8b6dd3..1a30b29d4 100644
--- a/nx-X11/programs/Xserver/randr/rrscreen.c
+++ b/nx-X11/programs/Xserver/randr/rrscreen.c
@@ -222,7 +222,7 @@ ProcRRGetScreenSizeRange(ClientPtr client)
 #ifndef NXAGENT_SERVER
     rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
 #else
-    pWin = SecurityLookupWindow(stuff->window, client, SecurityReadAccess);
+    pWin = SecurityLookupWindow(stuff->window, client, DixReadAccess);
     rc = pWin ? Success : BadWindow;
 #endif
 
@@ -276,7 +276,7 @@ ProcRRSetScreenSize(ClientPtr client)
 #ifndef NXAGENT_SERVER
     rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
 #else
-    pWin = SecurityLookupWindow(stuff->window, client, SecurityReadAccess);
+    pWin = SecurityLookupWindow(stuff->window, client, DixReadAccess);
     rc = pWin ? Success : BadWindow;
 #endif
     if (rc != Success)
@@ -532,7 +532,7 @@ rrGetScreenResources(ClientPtr client, Bool query)
 #ifndef NXAGENT_SERVER
     rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
 #else
-    pWin = SecurityLookupWindow(stuff->window, client, SecurityReadAccess);
+    pWin = SecurityLookupWindow(stuff->window, client, DixReadAccess);
     rc = pWin ? Success : BadWindow;
 #endif
     if (rc != Success)
@@ -806,7 +806,7 @@ ProcRRGetScreenInfo(ClientPtr client)
 #ifndef NXAGENT_SERVER
     rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
 #else
-    pWin = SecurityLookupWindow(stuff->window, client, SecurityReadAccess);
+    pWin = SecurityLookupWindow(stuff->window, client, DixReadAccess);
     rc = pWin ? Success : BadWindow;
 #endif
 
@@ -980,7 +980,7 @@ ProcRRSetScreenConfig(ClientPtr client)
     rc = dixLookupDrawable(&pDraw, stuff->drawable, client, 0, DixWriteAccess);
 #else                           /* !defined(NXAGENT_SERVER) */
     pDraw =
-        SecurityLookupDrawable(stuff->drawable, client, SecurityWriteAccess);
+        SecurityLookupDrawable(stuff->drawable, client, DixWriteAccess);
     rc = pDraw ? Success : BadDrawable;
 #endif                          /* !defined(NXAGENT_SERVER) */
 
diff --git a/nx-X11/programs/Xserver/randr/rrxinerama.c b/nx-X11/programs/Xserver/randr/rrxinerama.c
index 5c80e52db..d863897a7 100644
--- a/nx-X11/programs/Xserver/randr/rrxinerama.c
+++ b/nx-X11/programs/Xserver/randr/rrxinerama.c
@@ -150,7 +150,7 @@ ProcRRXineramaGetState(ClientPtr client)
 #ifndef NXAGENT_SERVER
     rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
 #else
-    pWin = SecurityLookupWindow(stuff->window, client, SecurityReadAccess);
+    pWin = SecurityLookupWindow(stuff->window, client, DixReadAccess);
     rc = pWin ? Success : BadWindow;
 #endif
 
@@ -205,7 +205,7 @@ ProcRRXineramaGetScreenCount(ClientPtr client)
 #ifndef NXAGENT_SERVER
     rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
 #else
-    pWin = SecurityLookupWindow(stuff->window, client, SecurityReadAccess);
+    pWin = SecurityLookupWindow(stuff->window, client, DixReadAccess);
     rc = pWin ? Success : BadWindow;
 #endif
     if (rc != Success)
@@ -240,7 +240,7 @@ ProcRRXineramaGetScreenSize(ClientPtr client)
 #ifndef NXAGENT_SERVER
     rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
 #else
-    pWin = SecurityLookupWindow(stuff->window, client, SecurityReadAccess);
+    pWin = SecurityLookupWindow(stuff->window, client, DixReadAccess);
     rc = pWin ? Success : BadWindow;
 #endif
 
diff --git a/nx-X11/programs/Xserver/render/picture.c b/nx-X11/programs/Xserver/render/picture.c
index 4a1cd98f5..862ae0031 100644
--- a/nx-X11/programs/Xserver/render/picture.c
+++ b/nx-X11/programs/Xserver/render/picture.c
@@ -1210,7 +1210,7 @@ ChangePicture (PicturePtr	pPicture,
 			pAlpha = (PicturePtr) SecurityLookupIDByType(client,
 								     pid, 
 								     PictureType, 
-								     SecurityWriteAccess|SecurityReadAccess);
+								     DixWriteAccess|DixReadAccess);
 			if (!pAlpha)
 			{
 			    client->errorValue = pid;
@@ -1271,7 +1271,7 @@ ChangePicture (PicturePtr	pPicture,
 			pPixmap = (PixmapPtr)SecurityLookupIDByType(client,
 								    pid, 
 								    RT_PIXMAP,
-								    SecurityReadAccess);
+								    DixReadAccess);
 			if (!pPixmap)
 			{
 			    client->errorValue = pid;
diff --git a/nx-X11/programs/Xserver/render/render.c b/nx-X11/programs/Xserver/render/render.c
index 774dcc8ec..abc26b5d9 100644
--- a/nx-X11/programs/Xserver/render/render.c
+++ b/nx-X11/programs/Xserver/render/render.c
@@ -567,7 +567,7 @@ ProcRenderQueryPictIndexValues (ClientPtr client)
     pFormat = (PictFormatPtr) SecurityLookupIDByType (client, 
 						      stuff->format,
 						      PictFormatType,
-						      SecurityReadAccess);
+						      DixReadAccess);
 
     if (!pFormat)
     {
@@ -636,11 +636,11 @@ ProcRenderCreatePicture (ClientPtr client)
 
     LEGAL_NEW_RESOURCE(stuff->pid, client);
     SECURITY_VERIFY_DRAWABLE(pDrawable, stuff->drawable, client,
-			     SecurityWriteAccess);
+			     DixWriteAccess);
     pFormat = (PictFormatPtr) SecurityLookupIDByType (client, 
 						      stuff->format,
 						      PictFormatType,
-						      SecurityReadAccess);
+						      DixReadAccess);
     if (!pFormat)
     {
 	client->errorValue = stuff->format;
@@ -674,7 +674,7 @@ ProcRenderChangePicture (ClientPtr client)
     int len;
 
     REQUEST_AT_LEAST_SIZE(xRenderChangePictureReq);
-    VERIFY_PICTURE (pPicture, stuff->picture, client, SecurityWriteAccess,
+    VERIFY_PICTURE (pPicture, stuff->picture, client, DixWriteAccess,
 		    RenderErrBase + BadPicture);
 
     len = client->req_len - (sizeof(xRenderChangePictureReq) >> 2);
@@ -694,7 +694,7 @@ ProcRenderSetPictureClipRectangles (ClientPtr client)
     int		    result;
 
     REQUEST_AT_LEAST_SIZE(xRenderSetPictureClipRectanglesReq);
-    VERIFY_PICTURE (pPicture, stuff->picture, client, SecurityWriteAccess,
+    VERIFY_PICTURE (pPicture, stuff->picture, client, DixWriteAccess,
 		    RenderErrBase + BadPicture);
     if (!pPicture->pDrawable)
         return BadDrawable;
@@ -721,7 +721,7 @@ ProcRenderFreePicture (ClientPtr client)
 
     REQUEST_SIZE_MATCH(xRenderFreePictureReq);
 
-    VERIFY_PICTURE (pPicture, stuff->picture, client, SecurityDestroyAccess,
+    VERIFY_PICTURE (pPicture, stuff->picture, client, DixDestroyAccess,
 		    RenderErrBase + BadPicture);
     FreeResource (stuff->picture, RT_NONE);
     return(client->noClientException);
@@ -752,13 +752,13 @@ ProcRenderComposite (ClientPtr client)
 	client->errorValue = stuff->op;
 	return BadValue;
     }
-    VERIFY_PICTURE (pDst, stuff->dst, client, SecurityWriteAccess,
+    VERIFY_PICTURE (pDst, stuff->dst, client, DixWriteAccess,
 		    RenderErrBase + BadPicture);
     if (!pDst->pDrawable)
         return BadDrawable;
-    VERIFY_PICTURE (pSrc, stuff->src, client, SecurityReadAccess, 
+    VERIFY_PICTURE (pSrc, stuff->src, client, DixReadAccess,
 		    RenderErrBase + BadPicture);
-    VERIFY_ALPHA (pMask, stuff->mask, client, SecurityReadAccess, 
+    VERIFY_ALPHA (pMask, stuff->mask, client, DixReadAccess,
 		  RenderErrBase + BadPicture);
     if ((pSrc->pDrawable && pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen) ||
 	(pMask && pMask->pDrawable && pSrc->pDrawable->pScreen != pMask->pDrawable->pScreen))
@@ -800,9 +800,9 @@ ProcRenderTrapezoids (ClientPtr client)
 	client->errorValue = stuff->op;
 	return BadValue;
     }
-    VERIFY_PICTURE (pSrc, stuff->src, client, SecurityReadAccess, 
+    VERIFY_PICTURE (pSrc, stuff->src, client, DixReadAccess,
 		    RenderErrBase + BadPicture);
-    VERIFY_PICTURE (pDst, stuff->dst, client, SecurityWriteAccess, 
+    VERIFY_PICTURE (pDst, stuff->dst, client, DixWriteAccess,
 		    RenderErrBase + BadPicture);
     if (!pDst->pDrawable)
         return BadDrawable;
@@ -813,7 +813,7 @@ ProcRenderTrapezoids (ClientPtr client)
 	pFormat = (PictFormatPtr) SecurityLookupIDByType (client,
 							  stuff->maskFormat,
 							  PictFormatType,
-							  SecurityReadAccess);
+							  DixReadAccess);
 	if (!pFormat)
 	{
 	    client->errorValue = stuff->maskFormat;
@@ -848,9 +848,9 @@ ProcRenderTriangles (ClientPtr client)
 	client->errorValue = stuff->op;
 	return BadValue;
     }
-    VERIFY_PICTURE (pSrc, stuff->src, client, SecurityReadAccess, 
+    VERIFY_PICTURE (pSrc, stuff->src, client, DixReadAccess,
 		    RenderErrBase + BadPicture);
-    VERIFY_PICTURE (pDst, stuff->dst, client, SecurityWriteAccess, 
+    VERIFY_PICTURE (pDst, stuff->dst, client, DixWriteAccess,
 		    RenderErrBase + BadPicture);
     if (!pDst->pDrawable)
         return BadDrawable;
@@ -861,7 +861,7 @@ ProcRenderTriangles (ClientPtr client)
 	pFormat = (PictFormatPtr) SecurityLookupIDByType (client,
 							  stuff->maskFormat,
 							  PictFormatType,
-							  SecurityReadAccess);
+							  DixReadAccess);
 	if (!pFormat)
 	{
 	    client->errorValue = stuff->maskFormat;
@@ -895,9 +895,9 @@ ProcRenderTriStrip (ClientPtr client)
 	client->errorValue = stuff->op;
 	return BadValue;
     }
-    VERIFY_PICTURE (pSrc, stuff->src, client, SecurityReadAccess, 
+    VERIFY_PICTURE (pSrc, stuff->src, client, DixReadAccess,
 		    RenderErrBase + BadPicture);
-    VERIFY_PICTURE (pDst, stuff->dst, client, SecurityWriteAccess, 
+    VERIFY_PICTURE (pDst, stuff->dst, client, DixWriteAccess,
 		    RenderErrBase + BadPicture);
     if (!pDst->pDrawable)
         return BadDrawable;
@@ -908,7 +908,7 @@ ProcRenderTriStrip (ClientPtr client)
 	pFormat = (PictFormatPtr) SecurityLookupIDByType (client,
 							  stuff->maskFormat,
 							  PictFormatType,
-							  SecurityReadAccess);
+							  DixReadAccess);
 	if (!pFormat)
 	{
 	    client->errorValue = stuff->maskFormat;
@@ -942,9 +942,9 @@ ProcRenderTriFan (ClientPtr client)
 	client->errorValue = stuff->op;
 	return BadValue;
     }
-    VERIFY_PICTURE (pSrc, stuff->src, client, SecurityReadAccess, 
+    VERIFY_PICTURE (pSrc, stuff->src, client, DixReadAccess,
 		    RenderErrBase + BadPicture);
-    VERIFY_PICTURE (pDst, stuff->dst, client, SecurityWriteAccess, 
+    VERIFY_PICTURE (pDst, stuff->dst, client, DixWriteAccess,
 		    RenderErrBase + BadPicture);
     if (!pDst->pDrawable)
         return BadDrawable;
@@ -955,7 +955,7 @@ ProcRenderTriFan (ClientPtr client)
 	pFormat = (PictFormatPtr) SecurityLookupIDByType (client,
 							  stuff->maskFormat,
 							  PictFormatType,
-							  SecurityReadAccess);
+							  DixReadAccess);
 	if (!pFormat)
 	{
 	    client->errorValue = stuff->maskFormat;
@@ -1008,7 +1008,7 @@ ProcRenderCreateGlyphSet (ClientPtr client)
     format = (PictFormatPtr) SecurityLookupIDByType (client,
 						     stuff->format,
 						     PictFormatType,
-						     SecurityReadAccess);
+						     DixReadAccess);
     if (!format)
     {
 	client->errorValue = stuff->format;
@@ -1056,7 +1056,7 @@ ProcRenderReferenceGlyphSet (ClientPtr client)
     glyphSet = (GlyphSetPtr) SecurityLookupIDByType (client,
 						     stuff->existing,
 						     GlyphSetType,
-						     SecurityWriteAccess);
+						     DixWriteAccess);
     if (!glyphSet)
     {
 	client->errorValue = stuff->existing;
@@ -1083,7 +1083,7 @@ ProcRenderFreeGlyphSet (ClientPtr client)
     glyphSet = (GlyphSetPtr) SecurityLookupIDByType (client,
 						     stuff->glyphset,
 						     GlyphSetType,
-						     SecurityDestroyAccess);
+						     DixDestroyAccess);
     if (!glyphSet)
     {
 	client->errorValue = stuff->glyphset;
@@ -1118,7 +1118,7 @@ ProcRenderAddGlyphs (ClientPtr client)
     glyphSet = (GlyphSetPtr) SecurityLookupIDByType (client,
 						     stuff->glyphset,
 						     GlyphSetType,
-						     SecurityWriteAccess);
+						     DixWriteAccess);
     if (!glyphSet)
     {
 	client->errorValue = stuff->glyphset;
@@ -1223,7 +1223,7 @@ ProcRenderFreeGlyphs (ClientPtr client)
     glyphSet = (GlyphSetPtr) SecurityLookupIDByType (client,
 						     stuff->glyphset,
 						     GlyphSetType,
-						     SecurityWriteAccess);
+						     DixWriteAccess);
     if (!glyphSet)
     {
 	client->errorValue = stuff->glyphset;
@@ -1278,9 +1278,9 @@ ProcRenderCompositeGlyphs (ClientPtr client)
 	client->errorValue = stuff->op;
 	return BadValue;
     }
-    VERIFY_PICTURE (pSrc, stuff->src, client, SecurityReadAccess,
+    VERIFY_PICTURE (pSrc, stuff->src, client, DixReadAccess,
 		    RenderErrBase + BadPicture);
-    VERIFY_PICTURE (pDst, stuff->dst, client, SecurityWriteAccess,
+    VERIFY_PICTURE (pDst, stuff->dst, client, DixWriteAccess,
 		    RenderErrBase + BadPicture);
     if (!pDst->pDrawable)
         return BadDrawable;
@@ -1291,7 +1291,7 @@ ProcRenderCompositeGlyphs (ClientPtr client)
 	pFormat = (PictFormatPtr) SecurityLookupIDByType (client,
 							  stuff->maskFormat,
 							  PictFormatType,
-							  SecurityReadAccess);
+							  DixReadAccess);
 	if (!pFormat)
 	{
 	    client->errorValue = stuff->maskFormat;
@@ -1304,7 +1304,7 @@ ProcRenderCompositeGlyphs (ClientPtr client)
     glyphSet = (GlyphSetPtr) SecurityLookupIDByType (client,
 						     stuff->glyphset,
 						     GlyphSetType,
-						     SecurityReadAccess);
+						     DixReadAccess);
     if (!glyphSet)
     {
 	client->errorValue = stuff->glyphset;
@@ -1366,7 +1366,7 @@ ProcRenderCompositeGlyphs (ClientPtr client)
 		glyphSet = (GlyphSetPtr) SecurityLookupIDByType (client,
 								 gs,
 								 GlyphSetType,
-								 SecurityReadAccess);
+								 DixReadAccess);
 		if (!glyphSet)
 		{
 		    client->errorValue = gs;
@@ -1447,7 +1447,7 @@ ProcRenderFillRectangles (ClientPtr client)
 	client->errorValue = stuff->op;
 	return BadValue;
     }
-    VERIFY_PICTURE (pDst, stuff->dst, client, SecurityWriteAccess, 
+    VERIFY_PICTURE (pDst, stuff->dst, client, DixWriteAccess,
 		    RenderErrBase + BadPicture);
     if (!pDst->pDrawable)
         return BadDrawable;
@@ -1515,7 +1515,7 @@ ProcRenderCreateCursor (ClientPtr client)
     REQUEST_SIZE_MATCH (xRenderCreateCursorReq);
     LEGAL_NEW_RESOURCE(stuff->cid, client);
     
-    VERIFY_PICTURE (pSrc, stuff->src, client, SecurityReadAccess, 
+    VERIFY_PICTURE (pSrc, stuff->src, client, DixReadAccess,
 		    RenderErrBase + BadPicture);
     if (!pSrc->pDrawable)
         return BadDrawable;
@@ -1699,7 +1699,7 @@ ProcRenderSetPictureTransform (ClientPtr client)
     int		result;
 
     REQUEST_SIZE_MATCH(xRenderSetPictureTransformReq);
-    VERIFY_PICTURE (pPicture, stuff->picture, client, SecurityWriteAccess,
+    VERIFY_PICTURE (pPicture, stuff->picture, client, DixWriteAccess,
 		    RenderErrBase + BadPicture);
     result = SetPictureTransform (pPicture, (PictTransform *) &stuff->transform);
     if (client->noClientException != Success)
@@ -1726,7 +1726,7 @@ ProcRenderQueryFilters (ClientPtr client)
     char			*names;
 
     REQUEST_SIZE_MATCH(xRenderQueryFiltersReq);
-    SECURITY_VERIFY_DRAWABLE(pDrawable, stuff->drawable, client, SecurityReadAccess);
+    SECURITY_VERIFY_DRAWABLE(pDrawable, stuff->drawable, client, DixReadAccess);
     
     pScreen = pDrawable->pScreen;
     nbytesName = 0;
@@ -1828,7 +1828,7 @@ ProcRenderSetPictureFilter (ClientPtr client)
     char	*name;
     
     REQUEST_AT_LEAST_SIZE (xRenderSetPictureFilterReq);
-    VERIFY_PICTURE (pPicture, stuff->picture, client, SecurityWriteAccess,
+    VERIFY_PICTURE (pPicture, stuff->picture, client, DixWriteAccess,
 		    RenderErrBase + BadPicture);
     name = (char *) (stuff + 1);
     params = (xFixed *) (name + ((stuff->nbytes + 3) & ~3));
@@ -1862,7 +1862,7 @@ ProcRenderCreateAnimCursor (ClientPtr client)
     for (i = 0; i < ncursor; i++)
     {
 	cursors[i] = (CursorPtr)SecurityLookupIDByType(client, elt->cursor,
-						       RT_CURSOR, SecurityReadAccess);
+						       RT_CURSOR, DixReadAccess);
 	if (!cursors[i])
 	{
 	    free (cursors);
@@ -1891,7 +1891,7 @@ ProcRenderAddTraps (ClientPtr client)
     REQUEST(xRenderAddTrapsReq);
 
     REQUEST_AT_LEAST_SIZE(xRenderAddTrapsReq);
-    VERIFY_PICTURE (pPicture, stuff->picture, client, SecurityWriteAccess, 
+    VERIFY_PICTURE (pPicture, stuff->picture, client, DixWriteAccess,
 		    RenderErrBase + BadPicture);
     if (!pPicture->pDrawable)
         return BadDrawable;
@@ -2644,7 +2644,7 @@ PanoramiXRenderCreatePicture (ClientPtr client)
 
     REQUEST_AT_LEAST_SIZE(xRenderCreatePictureReq);
     if(!(refDraw = (PanoramiXRes *)SecurityLookupIDByClass(
-		client, stuff->drawable, XRC_DRAWABLE, SecurityWriteAccess)))
+		client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
 	return BadDrawable;
     if(!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
 	return BadAlloc;
@@ -2686,7 +2686,7 @@ PanoramiXRenderChangePicture (ClientPtr client)
 
     REQUEST_AT_LEAST_SIZE(xChangeWindowAttributesReq);
     
-    VERIFY_XIN_PICTURE(pict, stuff->picture, client, SecurityWriteAccess,
+    VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess,
 		       RenderErrBase + BadPicture);
     
     FOR_NSCREENS_BACKWARD(j) {
@@ -2707,7 +2707,7 @@ PanoramiXRenderSetPictureClipRectangles (ClientPtr client)
 
     REQUEST_AT_LEAST_SIZE(xRenderSetPictureClipRectanglesReq);
     
-    VERIFY_XIN_PICTURE(pict, stuff->picture, client, SecurityWriteAccess,
+    VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess,
 		       RenderErrBase + BadPicture);
     
     FOR_NSCREENS_BACKWARD(j) {
@@ -2728,7 +2728,7 @@ PanoramiXRenderSetPictureTransform (ClientPtr client)
 
     REQUEST_AT_LEAST_SIZE(xRenderSetPictureTransformReq);
     
-    VERIFY_XIN_PICTURE(pict, stuff->picture, client, SecurityWriteAccess,
+    VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess,
 		       RenderErrBase + BadPicture);
     
     FOR_NSCREENS_BACKWARD(j) {
@@ -2749,7 +2749,7 @@ PanoramiXRenderSetPictureFilter (ClientPtr client)
 
     REQUEST_AT_LEAST_SIZE(xRenderSetPictureFilterReq);
     
-    VERIFY_XIN_PICTURE(pict, stuff->picture, client, SecurityWriteAccess,
+    VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess,
 		       RenderErrBase + BadPicture);
     
     FOR_NSCREENS_BACKWARD(j) {
@@ -2772,7 +2772,7 @@ PanoramiXRenderFreePicture (ClientPtr client)
 
     client->errorValue = stuff->picture;
 
-    VERIFY_XIN_PICTURE(pict, stuff->picture, client, SecurityDestroyAccess,
+    VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixDestroyAccess,
 		       RenderErrBase + BadPicture);
     
 
@@ -2798,11 +2798,11 @@ PanoramiXRenderComposite (ClientPtr client)
 
     REQUEST_SIZE_MATCH(xRenderCompositeReq);
     
-    VERIFY_XIN_PICTURE (src, stuff->src, client, SecurityReadAccess, 
+    VERIFY_XIN_PICTURE (src, stuff->src, client, DixReadAccess,
 			RenderErrBase + BadPicture);
-    VERIFY_XIN_ALPHA (msk, stuff->mask, client, SecurityReadAccess, 
+    VERIFY_XIN_ALPHA (msk, stuff->mask, client, DixReadAccess,
 		      RenderErrBase + BadPicture);
-    VERIFY_XIN_PICTURE (dst, stuff->dst, client, SecurityWriteAccess, 
+    VERIFY_XIN_PICTURE (dst, stuff->dst, client, DixWriteAccess,
 			RenderErrBase + BadPicture);
     
     orig = *stuff;
@@ -2846,9 +2846,9 @@ PanoramiXRenderCompositeGlyphs (ClientPtr client)
     INT16	    xSrc, ySrc;
 
     REQUEST_AT_LEAST_SIZE(xRenderCompositeGlyphsReq);
-    VERIFY_XIN_PICTURE (src, stuff->src, client, SecurityReadAccess,
+    VERIFY_XIN_PICTURE (src, stuff->src, client, DixReadAccess,
 			RenderErrBase + BadPicture);
-    VERIFY_XIN_PICTURE (dst, stuff->dst, client, SecurityWriteAccess,
+    VERIFY_XIN_PICTURE (dst, stuff->dst, client, DixWriteAccess,
 			RenderErrBase + BadPicture);
 
     if (client->req_len << 2 >= (sizeof (xRenderCompositeGlyphsReq) +
@@ -2889,7 +2889,7 @@ PanoramiXRenderFillRectangles (ClientPtr client)
     int		    extra_len;
 
     REQUEST_AT_LEAST_SIZE (xRenderFillRectanglesReq);
-    VERIFY_XIN_PICTURE (dst, stuff->dst, client, SecurityWriteAccess, 
+    VERIFY_XIN_PICTURE (dst, stuff->dst, client, DixWriteAccess,
 			RenderErrBase + BadPicture);
     extra_len = (client->req_len << 2) - sizeof (xRenderFillRectanglesReq);
     if (extra_len &&
@@ -2936,9 +2936,9 @@ PanoramiXRenderTrapezoids(ClientPtr client)
     
     REQUEST_AT_LEAST_SIZE (xRenderTrapezoidsReq);
     
-    VERIFY_XIN_PICTURE (src, stuff->src, client, SecurityReadAccess,
+    VERIFY_XIN_PICTURE (src, stuff->src, client, DixReadAccess,
 			RenderErrBase + BadPicture);
-    VERIFY_XIN_PICTURE (dst, stuff->dst, client, SecurityWriteAccess,
+    VERIFY_XIN_PICTURE (dst, stuff->dst, client, DixWriteAccess,
 			RenderErrBase + BadPicture);
 
     extra_len = (client->req_len << 2) - sizeof (xRenderTrapezoidsReq);
@@ -2998,9 +2998,9 @@ PanoramiXRenderTriangles(ClientPtr client)
     
     REQUEST_AT_LEAST_SIZE (xRenderTrianglesReq);
     
-    VERIFY_XIN_PICTURE (src, stuff->src, client, SecurityReadAccess,
+    VERIFY_XIN_PICTURE (src, stuff->src, client, DixReadAccess,
 			RenderErrBase + BadPicture);
-    VERIFY_XIN_PICTURE (dst, stuff->dst, client, SecurityWriteAccess,
+    VERIFY_XIN_PICTURE (dst, stuff->dst, client, DixWriteAccess,
 			RenderErrBase + BadPicture);
 
     extra_len = (client->req_len << 2) - sizeof (xRenderTrianglesReq);
@@ -3056,9 +3056,9 @@ PanoramiXRenderTriStrip(ClientPtr client)
     
     REQUEST_AT_LEAST_SIZE (xRenderTriStripReq);
     
-    VERIFY_XIN_PICTURE (src, stuff->src, client, SecurityReadAccess,
+    VERIFY_XIN_PICTURE (src, stuff->src, client, DixReadAccess,
 			RenderErrBase + BadPicture);
-    VERIFY_XIN_PICTURE (dst, stuff->dst, client, SecurityWriteAccess,
+    VERIFY_XIN_PICTURE (dst, stuff->dst, client, DixWriteAccess,
 			RenderErrBase + BadPicture);
 
     extra_len = (client->req_len << 2) - sizeof (xRenderTriStripReq);
@@ -3110,9 +3110,9 @@ PanoramiXRenderTriFan(ClientPtr client)
     
     REQUEST_AT_LEAST_SIZE (xRenderTriFanReq);
     
-    VERIFY_XIN_PICTURE (src, stuff->src, client, SecurityReadAccess,
+    VERIFY_XIN_PICTURE (src, stuff->src, client, DixReadAccess,
 			RenderErrBase + BadPicture);
-    VERIFY_XIN_PICTURE (dst, stuff->dst, client, SecurityWriteAccess,
+    VERIFY_XIN_PICTURE (dst, stuff->dst, client, DixWriteAccess,
 			RenderErrBase + BadPicture);
 
     extra_len = (client->req_len << 2) - sizeof (xRenderTriFanReq);
@@ -3166,7 +3166,7 @@ PanoramiXRenderColorTrapezoids(ClientPtr client)
     
     REQUEST_AT_LEAST_SIZE (xRenderColorTrapezoidsReq);
     
-    VERIFY_XIN_PICTURE (dst, stuff->dst, client, SecurityWriteAccess,
+    VERIFY_XIN_PICTURE (dst, stuff->dst, client, DixWriteAccess,
 			RenderErrBase + BadPicture);
 
     extra_len = (client->req_len << 2) - sizeof (xRenderColorTrapezoidsReq);
@@ -3210,7 +3210,7 @@ PanoramiXRenderColorTriangles(ClientPtr client)
     
     REQUEST_AT_LEAST_SIZE (xRenderColorTrianglesReq);
     
-    VERIFY_XIN_PICTURE (dst, stuff->dst, client, SecurityWriteAccess,
+    VERIFY_XIN_PICTURE (dst, stuff->dst, client, DixWriteAccess,
 			RenderErrBase + BadPicture);
 
     extra_len = (client->req_len << 2) - sizeof (xRenderColorTrianglesReq);
@@ -3256,7 +3256,7 @@ PanoramiXRenderAddTraps (ClientPtr client)
     INT16    	    x_off, y_off;
 
     REQUEST_AT_LEAST_SIZE (xRenderAddTrapsReq);
-    VERIFY_XIN_PICTURE (picture, stuff->picture, client, SecurityWriteAccess, 
+    VERIFY_XIN_PICTURE (picture, stuff->picture, client, DixWriteAccess,
 			RenderErrBase + BadPicture);
     extra_len = (client->req_len << 2) - sizeof (xRenderAddTrapsReq);
     if (extra_len &&
diff --git a/nx-X11/programs/Xserver/xfixes/cursor.c b/nx-X11/programs/Xserver/xfixes/cursor.c
index 61822aab7..67f46f55e 100644
--- a/nx-X11/programs/Xserver/xfixes/cursor.c
+++ b/nx-X11/programs/Xserver/xfixes/cursor.c
@@ -193,7 +193,7 @@ ProcXFixesSelectCursorInput (ClientPtr client)
 
     REQUEST_SIZE_MATCH (xXFixesSelectCursorInputReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
     if (!pWin)
         return(BadWindow);
     if (stuff->eventMask & ~CursorAllEvents)
@@ -362,7 +362,7 @@ ProcXFixesSetCursorName (ClientPtr client)
     Atom atom;
 
     REQUEST_AT_LEAST_SIZE(xXFixesSetCursorNameReq);
-    VERIFY_CURSOR(pCursor, stuff->cursor, client, SecurityWriteAccess);
+    VERIFY_CURSOR(pCursor, stuff->cursor, client, DixWriteAccess);
     tchar = (char *) &stuff[1];
     atom = MakeAtom (tchar, stuff->nbytes, TRUE);
     if (atom == BAD_RESOURCE)
@@ -394,7 +394,7 @@ ProcXFixesGetCursorName (ClientPtr client)
     int len;
 
     REQUEST_SIZE_MATCH(xXFixesGetCursorNameReq);
-    VERIFY_CURSOR(pCursor, stuff->cursor, client, SecurityReadAccess);
+    VERIFY_CURSOR(pCursor, stuff->cursor, client, DixReadAccess);
     if (pCursor->name)
 	str = NameForAtom (pCursor->name);
     else
@@ -619,8 +619,8 @@ ProcXFixesChangeCursor (ClientPtr client)
     REQUEST(xXFixesChangeCursorReq);
 
     REQUEST_SIZE_MATCH(xXFixesChangeCursorReq);
-    VERIFY_CURSOR (pSource, stuff->source, client, SecurityReadAccess);
-    VERIFY_CURSOR (pDestination, stuff->destination, client, SecurityWriteAccess);
+    VERIFY_CURSOR (pSource, stuff->source, client, DixReadAccess);
+    VERIFY_CURSOR (pDestination, stuff->destination, client, DixWriteAccess);
 
     ReplaceCursor (pSource, TestForCursor, (void *) pDestination);
     return (client->noClientException);
@@ -653,7 +653,7 @@ ProcXFixesChangeCursorByName (ClientPtr client)
     REQUEST(xXFixesChangeCursorByNameReq);
 
     REQUEST_FIXED_SIZE(xXFixesChangeCursorByNameReq, stuff->nbytes);
-    VERIFY_CURSOR(pSource, stuff->source, client, SecurityReadAccess);
+    VERIFY_CURSOR(pSource, stuff->source, client, DixReadAccess);
     tchar = (char *) &stuff[1];
     name = MakeAtom (tchar, stuff->nbytes, FALSE);
     if (name)
diff --git a/nx-X11/programs/Xserver/xfixes/region.c b/nx-X11/programs/Xserver/xfixes/region.c
index 6759b4bfe..31d19b5ff 100644
--- a/nx-X11/programs/Xserver/xfixes/region.c
+++ b/nx-X11/programs/Xserver/xfixes/region.c
@@ -117,7 +117,7 @@ ProcXFixesCreateRegionFromBitmap (ClientPtr client)
 
     pPixmap = (PixmapPtr) SecurityLookupIDByType (client, stuff->bitmap,
 						  RT_PIXMAP,
-						  SecurityReadAccess);
+						  DixReadAccess);
     if (!pPixmap)
     {
 	client->errorValue = stuff->bitmap;
@@ -222,7 +222,7 @@ ProcXFixesCreateRegionFromGC (ClientPtr client)
     REQUEST_SIZE_MATCH (xXFixesCreateRegionFromGCReq);
     LEGAL_NEW_RESOURCE (stuff->region, client);
 
-    SECURITY_VERIFY_GC(pGC, stuff->gc, client, SecurityReadAccess);
+    SECURITY_VERIFY_GC(pGC, stuff->gc, client, DixReadAccess);
     
     switch (pGC->clientClipType) {
     case CT_PIXMAP:
@@ -269,7 +269,7 @@ ProcXFixesCreateRegionFromPicture (ClientPtr client)
     REQUEST_SIZE_MATCH (xXFixesCreateRegionFromPictureReq);
     LEGAL_NEW_RESOURCE (stuff->region, client);
 
-    VERIFY_PICTURE(pPicture, stuff->picture, client, SecurityReadAccess,
+    VERIFY_PICTURE(pPicture, stuff->picture, client, DixReadAccess,
 		   RenderErrBase + BadPicture);
     
     switch (pPicture->clientClipType) {
@@ -316,7 +316,7 @@ ProcXFixesDestroyRegion (ClientPtr client)
     RegionPtr	pRegion;
 
     REQUEST_SIZE_MATCH(xXFixesDestroyRegionReq);
-    VERIFY_REGION(pRegion, stuff->region, client, SecurityWriteAccess);
+    VERIFY_REGION(pRegion, stuff->region, client, DixWriteAccess);
     FreeResource (stuff->region, RT_NONE);
     return(client->noClientException);
 }
@@ -340,7 +340,7 @@ ProcXFixesSetRegion (ClientPtr client)
     REQUEST (xXFixesSetRegionReq);
 
     REQUEST_AT_LEAST_SIZE(xXFixesSetRegionReq);
-    VERIFY_REGION(pRegion, stuff->region, client, SecurityWriteAccess);
+    VERIFY_REGION(pRegion, stuff->region, client, DixWriteAccess);
     
     things = (client->req_len << 2) - sizeof (xXFixesCreateRegionReq);
     if (things & 4)
@@ -377,8 +377,8 @@ ProcXFixesCopyRegion (ClientPtr client)
     RegionPtr	pSource, pDestination;
     REQUEST (xXFixesCopyRegionReq);
     
-    VERIFY_REGION(pSource, stuff->source, client, SecurityReadAccess);
-    VERIFY_REGION(pDestination, stuff->destination, client, SecurityWriteAccess);
+    VERIFY_REGION(pSource, stuff->source, client, DixReadAccess);
+    VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
     
     if (!RegionCopy(pDestination, pSource))
 	return BadAlloc;
@@ -406,9 +406,9 @@ ProcXFixesCombineRegion (ClientPtr client)
     REQUEST (xXFixesCombineRegionReq);
 
     REQUEST_SIZE_MATCH (xXFixesCombineRegionReq);
-    VERIFY_REGION(pSource1, stuff->source1, client, SecurityReadAccess);
-    VERIFY_REGION(pSource2, stuff->source2, client, SecurityReadAccess);
-    VERIFY_REGION(pDestination, stuff->destination, client, SecurityWriteAccess);
+    VERIFY_REGION(pSource1, stuff->source1, client, DixReadAccess);
+    VERIFY_REGION(pSource2, stuff->source2, client, DixReadAccess);
+    VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
     
     switch (stuff->xfixesReqType) {
     case X_XFixesUnionRegion:
@@ -452,8 +452,8 @@ ProcXFixesInvertRegion (ClientPtr client)
     REQUEST(xXFixesInvertRegionReq);
 
     REQUEST_SIZE_MATCH(xXFixesInvertRegionReq);
-    VERIFY_REGION(pSource, stuff->source, client, SecurityReadAccess);
-    VERIFY_REGION(pDestination, stuff->destination, client, SecurityWriteAccess);
+    VERIFY_REGION(pSource, stuff->source, client, DixReadAccess);
+    VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
 
     /* Compute bounds, limit to 16 bits */
     bounds.x1 = stuff->x;
@@ -499,7 +499,7 @@ ProcXFixesTranslateRegion (ClientPtr client)
     REQUEST(xXFixesTranslateRegionReq);
 
     REQUEST_SIZE_MATCH(xXFixesTranslateRegionReq);
-    VERIFY_REGION(pRegion, stuff->region, client, SecurityWriteAccess);
+    VERIFY_REGION(pRegion, stuff->region, client, DixWriteAccess);
 
     RegionTranslate(pRegion, stuff->dx, stuff->dy);
     return (client->noClientException);
@@ -525,8 +525,8 @@ ProcXFixesRegionExtents (ClientPtr client)
     REQUEST(xXFixesRegionExtentsReq);
 
     REQUEST_SIZE_MATCH(xXFixesRegionExtentsReq);
-    VERIFY_REGION(pSource, stuff->source, client, SecurityReadAccess);
-    VERIFY_REGION(pDestination, stuff->destination, client, SecurityWriteAccess);
+    VERIFY_REGION(pSource, stuff->source, client, DixReadAccess);
+    VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
 
     RegionReset(pDestination, RegionExtents(pSource));
 
@@ -557,7 +557,7 @@ ProcXFixesFetchRegion (ClientPtr client)
     REQUEST(xXFixesFetchRegionReq);
 
     REQUEST_SIZE_MATCH(xXFixesFetchRegionReq);
-    VERIFY_REGION(pRegion, stuff->region, client, SecurityReadAccess);
+    VERIFY_REGION(pRegion, stuff->region, client, DixReadAccess);
 
     pExtent = RegionExtents(pRegion);
     pBox = RegionRects (pRegion);
@@ -618,8 +618,8 @@ ProcXFixesSetGCClipRegion (ClientPtr client)
     REQUEST(xXFixesSetGCClipRegionReq);
 
     REQUEST_SIZE_MATCH(xXFixesSetGCClipRegionReq);
-    SECURITY_VERIFY_GC(pGC, stuff->gc, client, SecurityWriteAccess);
-    VERIFY_REGION_OR_NONE (pRegion, stuff->region, client, SecurityReadAccess);
+    SECURITY_VERIFY_GC(pGC, stuff->gc, client, DixWriteAccess);
+    VERIFY_REGION_OR_NONE (pRegion, stuff->region, client, DixReadAccess);
 
     if (pRegion)
     {
@@ -669,7 +669,7 @@ ProcXFixesSetWindowShapeRegion (ClientPtr client)
 	client->errorValue = stuff->dest;
 	return BadWindow;
     }
-    VERIFY_REGION_OR_NONE(pRegion, stuff->region, client, SecurityWriteAccess);
+    VERIFY_REGION_OR_NONE(pRegion, stuff->region, client, DixWriteAccess);
     pScreen = pWin->drawable.pScreen;
     switch (stuff->destKind) {
     case ShapeBounding:
@@ -756,9 +756,9 @@ ProcXFixesSetPictureClipRegion (ClientPtr client)
     REQUEST(xXFixesSetPictureClipRegionReq);
     
     REQUEST_SIZE_MATCH (xXFixesSetPictureClipRegionReq);
-    VERIFY_PICTURE(pPicture, stuff->picture, client, SecurityWriteAccess,
+    VERIFY_PICTURE(pPicture, stuff->picture, client, DixWriteAccess,
 		   RenderErrBase + BadPicture);
-    VERIFY_REGION_OR_NONE(pRegion, stuff->region, client, SecurityReadAccess);
+    VERIFY_REGION_OR_NONE(pRegion, stuff->region, client, DixReadAccess);
     
     return SetPictureClipRegion (pPicture, stuff->xOrigin, stuff->yOrigin,
 				 pRegion);
@@ -793,8 +793,8 @@ ProcXFixesExpandRegion (ClientPtr client)
     int		i;
 
     REQUEST_SIZE_MATCH (xXFixesExpandRegionReq);
-    VERIFY_REGION(pSource, stuff->source, client, SecurityReadAccess);
-    VERIFY_REGION(pDestination, stuff->destination, client, SecurityWriteAccess);
+    VERIFY_REGION(pSource, stuff->source, client, DixReadAccess);
+    VERIFY_REGION(pDestination, stuff->destination, client, DixWriteAccess);
     
     nBoxes = RegionNumRects(pSource);
     pSrc = RegionRects(pSource);
diff --git a/nx-X11/programs/Xserver/xfixes/saveset.c b/nx-X11/programs/Xserver/xfixes/saveset.c
index a81c0ca1b..0a5b2b8da 100644
--- a/nx-X11/programs/Xserver/xfixes/saveset.c
+++ b/nx-X11/programs/Xserver/xfixes/saveset.c
@@ -38,7 +38,7 @@ ProcXFixesChangeSaveSet(ClientPtr client)
 		  
     REQUEST_SIZE_MATCH(xXFixesChangeSaveSetReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
     if (!pWin)
         return(BadWindow);
     if (client->clientAsMask == (CLIENT_BITS(pWin->drawable.id)))
diff --git a/nx-X11/programs/Xserver/xfixes/select.c b/nx-X11/programs/Xserver/xfixes/select.c
index 600abc660..b21301d1c 100644
--- a/nx-X11/programs/Xserver/xfixes/select.c
+++ b/nx-X11/programs/Xserver/xfixes/select.c
@@ -198,7 +198,7 @@ ProcXFixesSelectSelectionInput (ClientPtr client)
 
     REQUEST_SIZE_MATCH (xXFixesSelectSelectionInputReq);
     pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
-					   SecurityReadAccess);
+					   DixReadAccess);
     if (!pWin)
         return(BadWindow);
     if (stuff->eventMask & ~SelectionAllEvents)
-- 
cgit v1.2.3