Check for glproto when building GLX and make sure we have at least 1.4.6.

Drop glx_ansic.h wrapper and call xalloc, xrealloc, xfree and str-funcs
    directly.

13 files changed, 125 insertions, 201 deletions

diff --git a/GL/glx/Makefile.am b/GL/glx/Makefile.am
index 7892dd9e5..4e850798d 100644
--- a/GL/glx/Makefile.am
+++ b/GL/glx/Makefile.am
@@ -22,7 +22,6 @@ AM_CFLAGS = \
 #sdk_HEADERS =
 
 INCLUDES = \
-	-I$(top_srcdir)/GL/include \
 	-I$(top_srcdir)/hw/xfree86/os-support \
 	-I$(top_srcdir)/hw/xfree86/os-support/bus \
 	-I$(top_srcdir)/hw/xfree86/common \
diff --git a/GL/glx/glxcmds.c b/GL/glx/glxcmds.c
index dd1d9494d..ef4992446 100644
--- a/GL/glx/glxcmds.c
+++ b/GL/glx/glxcmds.c
@@ -41,6 +41,7 @@
 #endif
 
 #include <string.h>
+#include <assert.h>
 
 #include "glxserver.h"
 #include <GL/glxtokens.h>
@@ -51,7 +52,6 @@
 #include "g_disptab_EXT.h"
 #include "glxutil.h"
 #include "glxext.h"
-#include "GL/glx_ansic.h"
 #include "glcontextmodes.h"
 #include "glapitable.h"
 #include "glapi.h"
@@ -99,7 +99,7 @@ __glXContextDestroy(__GLXcontext *context)
 static void __glXdirectContextDestroy(__GLXcontext *context)
 {
     __glXContextDestroy(context);
-    __glXFree(context);
+    xfree(context);
 }
 
 static __GLXcontext *__glXdirectContextCreate(__GLXscreen *screen,
@@ -108,7 +108,7 @@ static __GLXcontext *__glXdirectContextCreate(__GLXscreen *screen,
 {
     __GLXcontext *context;
 
-    context = __glXMalloc (sizeof (__GLXcontext));
+    context = xalloc (sizeof (__GLXcontext));
     if (context == NULL)
 	return NULL;
 
@@ -344,9 +344,9 @@ static int AddCurrentContext(__GLXclientState *cl, __GLXcontext *glxc)
     ** Didn't find a free slot, so we'll have to grow the table.
     */
     if (!num) {
-	table = (__GLXcontext **) __glXMalloc(sizeof(__GLXcontext *));
+	table = (__GLXcontext **) xalloc(sizeof(__GLXcontext *));
     } else {
-	table = (__GLXcontext **) __glXRealloc(table,
+	table = (__GLXcontext **) xrealloc(table,
 					   (num+1)*sizeof(__GLXcontext *));
     }
     table[num] = glxc;
@@ -688,7 +688,7 @@ int DoMakeCurrent( __GLXclientState *cl,
 		    ** refcount of the X pixmap and free only if it's zero.
 		    */
 		    (*prevglxc->readPixmap->pScreen->DestroyPixmap)(pPixmap);
-		    __glXFree(prevglxc->readPixmap);
+		    xfree(prevglxc->readPixmap);
 		}
 	    }
 
@@ -704,7 +704,7 @@ int DoMakeCurrent( __GLXclientState *cl,
 		** refcount of the X pixmap and free only if it's zero.
 		*/
 		(*prevglxc->drawPixmap->pScreen->DestroyPixmap)(pPixmap);
-		__glXFree(prevglxc->drawPixmap);
+		xfree(prevglxc->drawPixmap);
 	    }
 
 	    prevglxc->drawPixmap = NULL;
@@ -1257,7 +1257,7 @@ int DoCreateGLXPixmap(__GLXclientState *cl, VisualID visual,
 	return BadValue;
     }
 
-    pGlxPixmap = (__GLXpixmap *) __glXMalloc(sizeof(__GLXpixmap));
+    pGlxPixmap = (__GLXpixmap *) xalloc(sizeof(__GLXpixmap));
     if (!pGlxPixmap) {
 	return BadAlloc;
     }
@@ -1447,7 +1447,7 @@ int __glXQueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc)
     reply.n = nProps;
 
     nReplyBytes = reply.length << 2;
-    sendBuf = (int *)__glXMalloc((size_t)nReplyBytes);
+    sendBuf = (int *)xalloc((size_t)nReplyBytes);
     if (sendBuf == NULL) {
 	return __glXBadContext;	/* XXX: Is this correct? */
     }
@@ -1465,7 +1465,7 @@ int __glXQueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc)
 	WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, (char *)&reply);
 	WriteToClient(client, nReplyBytes, (char *)sendBuf);
     }
-    __glXFree((char *)sendBuf);
+    xfree((char *)sendBuf);
 
     return Success;
 }
@@ -1805,17 +1805,17 @@ int __glXRenderLarge(__GLXclientState *cl, GLbyte *pc)
 	*/
 	if (cl->largeCmdBufSize < cmdlen) {
 	    if (!cl->largeCmdBuf) {
-		cl->largeCmdBuf = (GLbyte *) __glXMalloc((size_t)cmdlen);
+		cl->largeCmdBuf = (GLbyte *) xalloc((size_t)cmdlen);
 	    } else {
-		cl->largeCmdBuf = (GLbyte *) __glXRealloc(cl->largeCmdBuf, 
-							  (size_t)cmdlen);
+		cl->largeCmdBuf = (GLbyte *) xrealloc(cl->largeCmdBuf, 
+						      (size_t)cmdlen);
 	    }
 	    if (!cl->largeCmdBuf) {
 		return BadAlloc;
 	    }
 	    cl->largeCmdBufSize = cmdlen;
 	}
-	__glXMemcpy(cl->largeCmdBuf, pc, dataBytes);
+	memcpy(cl->largeCmdBuf, pc, dataBytes);
 
 	cl->largeCmdBytesSoFar = dataBytes;
 	cl->largeCmdBytesTotal = cmdlen;
@@ -1851,7 +1851,7 @@ int __glXRenderLarge(__GLXclientState *cl, GLbyte *pc)
 	    __glXResetLargeCommandStatus(cl);
 	    return __glXBadLargeRequest;
 	}
-	__glXMemcpy(cl->largeCmdBuf + cl->largeCmdBytesSoFar, pc, dataBytes);
+	memcpy(cl->largeCmdBuf + cl->largeCmdBytesSoFar, pc, dataBytes);
 	cl->largeCmdBytesSoFar += dataBytes;
 	cl->largeCmdRequestsSoFar++;
 
@@ -2267,17 +2267,18 @@ int __glXQueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
 
     ptr = __glXActiveScreens[screen]->GLXextensions;
 
-    n = __glXStrlen(ptr) + 1;
+    n = strlen(ptr) + 1;
     length = __GLX_PAD(n) >> 2;
     reply.type = X_Reply;
     reply.sequenceNumber = client->sequence;
     reply.length = length;
     reply.n = n;
 
-    if ((buf = (char *) __glXMalloc(length << 2)) == NULL) {
+    /* Allocate buffer to make sure it's a multiple of 4 bytes big.*/
+    buf = (char *) xalloc(length << 2);
+    if (buf == NULL)
         return BadAlloc;
-    }
-    __glXStrncpy(buf, ptr, n);
+    memcpy(buf, ptr, n);
 
     if (client->swapped) {
         glxSwapQueryExtensionsStringReply(client, &reply, buf);
@@ -2286,7 +2287,7 @@ int __glXQueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
         WriteToClient(client, (int)(length << 2), (char *)buf);
     }
 
-    __glXFree(buf);
+    xfree(buf);
     return Success;
 }
 
@@ -2324,17 +2325,18 @@ int __glXQueryServerString(__GLXclientState *cl, GLbyte *pc)
 	    return BadValue; 
     }
 
-    n = __glXStrlen(ptr) + 1;
+    n = strlen(ptr) + 1;
     length = __GLX_PAD(n) >> 2;
     reply.type = X_Reply;
     reply.sequenceNumber = client->sequence;
     reply.length = length;
     reply.n = n;
 
-    if ((buf = (char *) Xalloc(length << 2)) == NULL) {
+    buf = (char *) xalloc(length << 2);
+    if (buf == NULL) {
         return BadAlloc;
     }
-    __glXStrncpy(buf, ptr, n);
+    memcpy(buf, ptr, n);
 
     if (client->swapped) {
         glxSwapQueryServerStringReply(client, &reply, buf);
@@ -2343,7 +2345,7 @@ int __glXQueryServerString(__GLXclientState *cl, GLbyte *pc)
         WriteToClient(client, (int)(length << 2), buf);
     }
 
-    __glXFree(buf);
+    xfree(buf);
     return Success;
 }
 
@@ -2354,9 +2356,10 @@ int __glXClientInfo(__GLXclientState *cl, GLbyte *pc)
    
     cl->GLClientmajorVersion = req->major;
     cl->GLClientminorVersion = req->minor;
-    if (cl->GLClientextensions) __glXFree(cl->GLClientextensions);
+    if (cl->GLClientextensions)
+	xfree(cl->GLClientextensions);
     buf = (const char *)(req+1);
-    cl->GLClientextensions = __glXStrdup(buf);
+    cl->GLClientextensions = xstrdup(buf);
 
     return Success;
 }
diff --git a/GL/glx/glxcmdsswap.c b/GL/glx/glxcmdsswap.c
index 2953c9577..ca708a9a7 100644
--- a/GL/glx/glxcmdsswap.c
+++ b/GL/glx/glxcmdsswap.c
@@ -50,7 +50,6 @@
 #include <pixmapstr.h>
 #include <windowstr.h>
 #include "glxext.h"
-#include "GL/glx_ansic.h"
 #include "glapitable.h"
 #include "glapi.h"
 #include "glthread.h"
@@ -752,16 +751,16 @@ int __glXSwapRenderLarge(__GLXclientState *cl, GLbyte *pc)
 	*/
 	if (cl->largeCmdBufSize < cmdlen) {
 	    if (!cl->largeCmdBuf) {
-		cl->largeCmdBuf = (GLbyte *) __glXMalloc(cmdlen);
+		cl->largeCmdBuf = (GLbyte *) xalloc(cmdlen);
 	    } else {
-		cl->largeCmdBuf = (GLbyte *) __glXRealloc(cl->largeCmdBuf, cmdlen);
+		cl->largeCmdBuf = (GLbyte *) xrealloc(cl->largeCmdBuf, cmdlen);
 	    }
 	    if (!cl->largeCmdBuf) {
 		return BadAlloc;
 	    }
 	    cl->largeCmdBufSize = cmdlen;
 	}
-	__glXMemcpy(cl->largeCmdBuf, pc, dataBytes);
+	memcpy(cl->largeCmdBuf, pc, dataBytes);
 
 	cl->largeCmdBytesSoFar = dataBytes;
 	cl->largeCmdBytesTotal = cmdlen;
@@ -797,7 +796,7 @@ int __glXSwapRenderLarge(__GLXclientState *cl, GLbyte *pc)
 	    __glXResetLargeCommandStatus(cl);
 	    return __glXBadLargeRequest;
 	}
-	__glXMemcpy(cl->largeCmdBuf + cl->largeCmdBytesSoFar, pc, dataBytes);
+	memcpy(cl->largeCmdBuf + cl->largeCmdBytesSoFar, pc, dataBytes);
 	cl->largeCmdBytesSoFar += dataBytes;
 	cl->largeCmdRequestsSoFar++;
 
diff --git a/GL/glx/glxdri.c b/GL/glx/glxdri.c
index 9cbb51873..40f137864 100644
--- a/GL/glx/glxdri.c
+++ b/GL/glx/glxdri.c
@@ -144,7 +144,7 @@ __glXDRIdrawableDestroy(__GLXdrawable *private)
 					    glxPriv->driDrawable.private);
 #endif
 
-    __glXFree(private);
+    xfree(private);
 }
 
 static GLboolean
@@ -184,14 +184,14 @@ __glXDRIcontextCreateDrawable(__GLXcontext *context,
 {
     __GLXDRIdrawable *private;
 
-    private = __glXMalloc(sizeof *private);
+    private = xalloc(sizeof *private);
     if (private == NULL)
 	return NULL;
 
     memset(private, 0, sizeof *private);
 
     if (!__glXDrawableInit(&private->base, context, pDraw, drawId)) {
-        __glXFree(private);
+        xfree(private);
 	return NULL;
     }
 
@@ -228,7 +228,7 @@ __glXDRIcontextDestroy(__GLXcontext *baseContext)
 				       context->base.pScreen->myNum,
 				       context->driContext.private);
     __glXContextDestroy(context);
-    __glXFree(context);
+    xfree(context);
 }
 
 static int
@@ -397,7 +397,7 @@ __glXDRIscreenDestroy(__GLXscreen *baseScreen)
 
     __glXScreenDestroy(baseScreen);
 
-    __glXFree(screen);
+    xfree(screen);
 }
 
 static __GLXcontext *
@@ -415,7 +415,7 @@ __glXDRIscreenCreateContext(__GLXscreen *baseScreen,
     else
 	sharePrivate = NULL;
 
-    context = __glXMalloc(sizeof *context);
+    context = xalloc(sizeof *context);
     if (context == NULL)
 	return NULL;
 
@@ -639,7 +639,7 @@ getDrawableInfo(__DRInativeDisplay *dpy, int screen,
 
     if (*numClipRects > 0) {
 	size = sizeof (drm_clip_rect_t) * *numClipRects;
-	*ppClipRects = __glXMalloc (size);
+	*ppClipRects = xalloc (size);
 	if (*ppClipRects != NULL)
 	    memcpy (*ppClipRects, pClipRects, size);
     }
@@ -649,7 +649,7 @@ getDrawableInfo(__DRInativeDisplay *dpy, int screen,
       
     if (*numBackClipRects > 0) {
 	size = sizeof (drm_clip_rect_t) * *numBackClipRects;
-	*ppBackClipRects = __glXMalloc (size);
+	*ppBackClipRects = xalloc (size);
 	if (*ppBackClipRects != NULL)
 	    memcpy (*ppBackClipRects, pBackClipRects, size);
     }
@@ -732,7 +732,7 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
 	return NULL;
     }
 
-    screen = __glXMalloc(sizeof *screen);
+    screen = xalloc(sizeof *screen);
     if (screen == NULL)
       return NULL;
     memset(screen, 0, sizeof *screen);
@@ -833,7 +833,7 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
      * but we can't use _mesa_malloc() here.  In fact, the DRI driver
      * shouldn't free data it didn't allocate itself, but what can you
      * do... */
-    dev_priv = __glXMalloc(framebuffer.dev_priv_size);
+    dev_priv = xalloc(framebuffer.dev_priv_size);
     if (dev_priv == NULL) {
 	err_msg = "dev_priv allocation";
 	goto handle_error;
@@ -904,7 +904,7 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
 	drmUnmap((drmAddress)framebuffer.base, framebuffer.size);
 
     if (dev_priv != NULL)
-	__glXFree(dev_priv);
+	xfree(dev_priv);
 
     if (fd >= 0)
 	drmClose(fd);
diff --git a/GL/glx/glxext.c b/GL/glx/glxext.c
index e4ad47803..c2a165efe 100644
--- a/GL/glx/glxext.c
+++ b/GL/glx/glxext.c
@@ -56,17 +56,18 @@ static void ResetClientState(int clientIndex)
 {
     __GLXclientState *cl = __glXClients[clientIndex];
 
-    if (cl->returnBuf) __glXFree(cl->returnBuf);
-    if (cl->largeCmdBuf) __glXFree(cl->largeCmdBuf);
-    if (cl->currentContexts) __glXFree(cl->currentContexts);
-    __glXMemset(cl, 0, sizeof(__GLXclientState));
+    if (cl->returnBuf) xfree(cl->returnBuf);
+    if (cl->largeCmdBuf) xfree(cl->largeCmdBuf);
+    if (cl->currentContexts) xfree(cl->currentContexts);
+    memset(cl, 0, sizeof(__GLXclientState));
     /*
     ** By default, assume that the client supports
     ** GLX major version 1 minor version 0 protocol.
     */
     cl->GLClientmajorVersion = 1;
     cl->GLClientminorVersion = 0;
-    if (cl->GLClientextensions) __glXFree(cl->GLClientextensions);
+    if (cl->GLClientextensions)
+	xfree(cl->GLClientextensions);
 
 }
 
@@ -145,7 +146,7 @@ static int PixmapGone(__GLXpixmap *pGlxPixmap, XID id)
 	** only if it's zero.
 	*/
 	(*pGlxPixmap->pScreen->DestroyPixmap)(pPixmap);
-	__glXFree(pGlxPixmap);
+	xfree(pGlxPixmap);
     }
 
     return True;
@@ -192,8 +193,8 @@ GLboolean __glXFreeContext(__GLXcontext *cx)
 {
     if (cx->idExists || cx->isCurrent) return GL_FALSE;
     
-    if (cx->feedbackBuf) __glXFree(cx->feedbackBuf);
-    if (cx->selectBuf) __glXFree(cx->selectBuf);
+    if (cx->feedbackBuf) xfree(cx->feedbackBuf);
+    if (cx->selectBuf) xfree(cx->selectBuf);
     if (cx == __glXLastContext) {
 	__glXFlushContextCache();
     }
@@ -430,12 +431,12 @@ static int __glXDispatch(ClientPtr client)
     opcode = stuff->glxCode;
     cl = __glXClients[client->index];
     if (!cl) {
-	cl = (__GLXclientState *) __glXMalloc(sizeof(__GLXclientState));
+	cl = (__GLXclientState *) xalloc(sizeof(__GLXclientState));
 	 __glXClients[client->index] = cl;
 	if (!cl) {
 	    return BadAlloc;
 	}
-	__glXMemset(cl, 0, sizeof(__GLXclientState));
+	memset(cl, 0, sizeof(__GLXclientState));
     }
     
     if (!cl->inUse) {
diff --git a/GL/glx/glxscreens.c b/GL/glx/glxscreens.c
index 33bb0fe09..bf580a1ed 100644
--- a/GL/glx/glxscreens.c
+++ b/GL/glx/glxscreens.c
@@ -262,10 +262,10 @@ void GlxPushProvider(__GLXprovider *provider)
 void __glXScreenInit(__GLXscreen *screen, ScreenPtr pScreen)
 {
     screen->pScreen       = pScreen;
-    screen->GLextensions  = __glXStrdup(GLServerExtensions);
-    screen->GLXvendor     = __glXStrdup(GLXServerVendorName);
-    screen->GLXversion    = __glXStrdup(GLXServerVersion);
-    screen->GLXextensions = __glXStrdup(GLXServerExtensions);
+    screen->GLextensions  = xstrdup(GLServerExtensions);
+    screen->GLXvendor     = xstrdup(GLXServerVendorName);
+    screen->GLXversion    = xstrdup(GLXServerVersion);
+    screen->GLXextensions = xstrdup(GLXServerExtensions);
 
     screen->WrappedPositionWindow = pScreen->PositionWindow;
     pScreen->PositionWindow = PositionWindow;
@@ -276,10 +276,10 @@ void __glXScreenInit(__GLXscreen *screen, ScreenPtr pScreen)
 void
 __glXScreenDestroy(__GLXscreen *screen)
 {
-    __glXFree(screen->GLXvendor);
-    __glXFree(screen->GLXversion);
-    __glXFree(screen->GLXextensions);
-    __glXFree(screen->GLextensions);
+    xfree(screen->GLXvendor);
+    xfree(screen->GLXversion);
+    xfree(screen->GLXextensions);
+    xfree(screen->GLextensions);
 }
 
 void __glXInitScreens(void)
@@ -293,8 +293,8 @@ void __glXInitScreens(void)
     ** This alloc has to work or else the server might as well core dump.
     */
     size = screenInfo.numScreens * sizeof(__GLXscreen *);
-    __glXActiveScreens =__glXMalloc(size);
-    __glXMemset(__glXActiveScreens, 0, size);
+    __glXActiveScreens = xalloc(size);
+    memset(__glXActiveScreens, 0, size);
     
     for (i = 0; i < screenInfo.numScreens; i++) {
 	pScreen = screenInfo.screens[i];
@@ -319,9 +319,9 @@ void __glXResetScreens(void)
       if (__glXActiveScreens[i])
 	  __glXActiveScreens[i]->destroy(__glXActiveScreens[i]);
 
-    __glXFree(__glXActiveScreens);
-    __glXFree(__glXHyperpipeFuncs);
-    __glXFree(__glXSwapBarrierFuncs);
+    xfree(__glXActiveScreens);
+    xfree(__glXHyperpipeFuncs);
+    xfree(__glXSwapBarrierFuncs);
     __glXNumHyperpipeFuncs = 0;
     __glXNumSwapBarrierFuncs = 0;
     __glXHyperpipeFuncs = NULL;
diff --git a/GL/glx/glxserver.h b/GL/glx/glxserver.h
index 2e273b970..62e756551 100644
--- a/GL/glx/glxserver.h
+++ b/GL/glx/glxserver.h
@@ -51,7 +51,6 @@
 #include <extnsionst.h>
 #include <resource.h>
 #include <scrnintstr.h>
-#include "GL/glx_ansic.h"
 
 /*
 ** The X header misc.h defines these math functions.
diff --git a/GL/glx/glxutil.c b/GL/glx/glxutil.c
index 36ffd27eb..f1f9c06c5 100644
--- a/GL/glx/glxutil.c
+++ b/GL/glx/glxutil.c
@@ -48,85 +48,11 @@
 #include <pixmapstr.h>
 #include <windowstr.h>
 #include "glxutil.h"
-#include "GL/glx_ansic.h"
 #include "GL/internal/glcore.h"
 #include "GL/glxint.h"
 #include "glcontextmodes.h"
 
 /************************************************************************/
-
-/* Memory Allocation for GLX */
-
-void *
-__glXMalloc(size_t size)
-{
-    void *addr;
-
-    if (size == 0) {
-	return NULL;
-    }
-    addr = (void *) xalloc(size);
-    if (addr == NULL) {
-	/* XXX: handle out of memory error */
-	return NULL;
-    }
-    return addr;
-}
-
-void *
-__glXCalloc(size_t numElements, size_t elementSize)
-{
-    void *addr;
-    size_t size;
-
-    if ((numElements == 0) || (elementSize == 0)) {
-	return NULL;
-    }
-    size = numElements * elementSize;
-    addr = (void *) xalloc(size);
-    if (addr == NULL) {
-	/* XXX: handle out of memory error */
-	return NULL;
-    }
-    memset(addr, 0, size);
-    return addr;
-}
-
-void *
-__glXRealloc(void *addr, size_t newSize)
-{
-    void *newAddr;
-
-    if (addr) {
-	if (newSize == 0) {
-	    xfree(addr);
-	    return NULL;
-	} else {
-	    newAddr = xrealloc(addr, newSize);
-	}
-    } else {
-	if (newSize == 0) {
-	    return NULL;
-	} else {
-	    newAddr = xalloc(newSize);
-	}
-    }
-    if (newAddr == NULL) {
-	return NULL;	/* XXX: out of memory */
-    }
-
-    return newAddr;
-}
-
-void
-__glXFree(void *addr)
-{
-    if (addr) {
-	xfree(addr);
-    }
-}
-
-/************************************************************************/
 /* Context stuff */
 
 
diff --git a/GL/glx/glxvisuals.c b/GL/glx/glxvisuals.c
index f83bbb14e..0e9bdedec 100644
--- a/GL/glx/glxvisuals.c
+++ b/GL/glx/glxvisuals.c
@@ -35,6 +35,7 @@
 #include <dix-config.h>
 #endif
 
+#include <assert.h>
 #include <string.h>
 #include <regionstr.h>
 #include <resource.h>
@@ -218,15 +219,15 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
 
     /* Alloc space for the list of new GLX visuals */
     pNewVisualConfigs = (__GLXvisualConfig *)
-	__glXMalloc(numNewConfigs * sizeof(__GLXvisualConfig));
+	xalloc(numNewConfigs * sizeof(__GLXvisualConfig));
     if (!pNewVisualConfigs) {
 	return FALSE;
     }
 
     /* Alloc space for the list of new GLX visual privates */
-    pNewVisualPriv = (void **) __glXMalloc(numNewConfigs * sizeof(void *));
+    pNewVisualPriv = (void **) xalloc(numNewConfigs * sizeof(void *));
     if (!pNewVisualPriv) {
-	__glXFree(pNewVisualConfigs);
+	xfree(pNewVisualConfigs);
 	return FALSE;
     }
 
@@ -270,40 +271,40 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
     numConfigs = 0;
 
     /* Alloc temp space for the list of orig VisualIDs for each new visual */
-    orig_vid = (VisualID *) __glXMalloc(numNewVisuals * sizeof(VisualID));
+    orig_vid = (VisualID *) xalloc(numNewVisuals * sizeof(VisualID));
     if (!orig_vid) {
-	__glXFree(pNewVisualPriv);
-	__glXFree(pNewVisualConfigs);
+	xfree(pNewVisualPriv);
+	xfree(pNewVisualConfigs);
 	return FALSE;
     }
 
     /* Alloc space for the list of glXVisuals */
     modes = _gl_context_modes_create(numNewVisuals, sizeof(__GLcontextModes));
     if (modes == NULL) {
-	__glXFree(orig_vid);
-	__glXFree(pNewVisualPriv);
-	__glXFree(pNewVisualConfigs);
+	xfree(orig_vid);
+	xfree(pNewVisualPriv);
+	xfree(pNewVisualConfigs);
 	return FALSE;
     }
 
     /* Alloc space for the list of glXVisualPrivates */
-    glXVisualPriv = (void **)__glXMalloc(numNewVisuals * sizeof(void *));
+    glXVisualPriv = (void **)xalloc(numNewVisuals * sizeof(void *));
     if (!glXVisualPriv) {
 	_gl_context_modes_destroy( modes );
-	__glXFree(orig_vid);
-	__glXFree(pNewVisualPriv);
-	__glXFree(pNewVisualConfigs);
+	xfree(orig_vid);
+	xfree(pNewVisualPriv);
+	xfree(pNewVisualConfigs);
 	return FALSE;
     }
 
     /* Alloc space for the new list of the X server's visuals */
-    pVisualNew = (VisualPtr)__glXMalloc(numNewVisuals * sizeof(VisualRec));
+    pVisualNew = (VisualPtr)xalloc(numNewVisuals * sizeof(VisualRec));
     if (!pVisualNew) {
-	__glXFree(glXVisualPriv);
+	xfree(glXVisualPriv);
 	_gl_context_modes_destroy( modes );
-	__glXFree(orig_vid);
-	__glXFree(pNewVisualPriv);
-	__glXFree(pNewVisualConfigs);
+	xfree(orig_vid);
+	xfree(pNewVisualPriv);
+	xfree(pNewVisualConfigs);
 	return FALSE;
     }
 
@@ -388,7 +389,7 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
 		    numVids++;
 
 	/* Allocate a new list of VisualIDs for this depth */
-	pVids = (VisualID *)__glXMalloc(numVids * sizeof(VisualID));
+	pVids = (VisualID *)xalloc(numVids * sizeof(VisualID));
 
 	/* Initialize the new list of VisualIDs for this depth */
 	for (j = 0; j < pdepth[i].numVids; j++)
@@ -397,7 +398,7 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
 		    pVids[n++] = pVisualNew[k].vid;
 
 	/* Update this depth's list of VisualIDs */
-	__glXFree(pdepth[i].vids);
+	xfree(pdepth[i].vids);
 	pdepth[i].vids = pVids;
 	pdepth[i].numVids = numVids;
     }
@@ -407,16 +408,16 @@ static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
     *visualp = pVisualNew;
 
     /* Free the old list of the X server's visuals */
-    __glXFree(pVisual);
+    xfree(pVisual);
 
     /* Clean up temporary allocations */
-    __glXFree(orig_vid);
-    __glXFree(pNewVisualPriv);
-    __glXFree(pNewVisualConfigs);
+    xfree(orig_vid);
+    xfree(pNewVisualPriv);
+    xfree(pNewVisualConfigs);
 
     /* Free the private list created by DDX HW driver */
     if (visualPrivates)
-        __glXFree(visualPrivates);
+        xfree(visualPrivates);
     visualPrivates = NULL;
 
     return TRUE;
diff --git a/GL/glx/single2.c b/GL/glx/single2.c
index c44336af4..c8e114824 100644
--- a/GL/glx/single2.c
+++ b/GL/glx/single2.c
@@ -48,7 +48,6 @@
 #include "glxext.h"
 #include "indirect_dispatch.h"
 #include "unpack.h"
-#include "GL/glx_ansic.h"
 #include "glapitable.h"
 #include "glapi.h"
 #include "glthread.h"
@@ -266,24 +265,30 @@ char *__glXcombine_strings(const char *cext_string, const char *sext_string)
    ** pull tokens out of shortest string
    ** include space in combo_string for final separator and null terminator
    */
-   if ( (clen = __glXStrlen(cext_string)) > (slen = __glXStrlen(sext_string)) ) {
-	combo_string = (char *) __glXMalloc(slen + 2);
-	s1 = (char *) __glXMalloc(slen + 2); __glXStrcpy(s1, sext_string);
+   clen = strlen(cext_string);
+   slen = strlen(sext_string);
+   if (clen > slen) {
+	combo_string = (char *) xalloc(slen + 2);
+	s1 = (char *) xalloc(slen + 2);
+	strcpy(s1, sext_string);
 	s2 = cext_string;
    } else {
-	combo_string = (char *) __glXMalloc(clen + 2);
-	s1 = (char *) __glXMalloc(clen + 2); __glXStrcpy(s1, cext_string);
+	combo_string = (char *) xalloc(clen + 2);
+	s1 = (char *) xalloc(clen + 2);
+	strcpy(s1, cext_string);
 	s2 = sext_string;
    }
    if (!combo_string || !s1) {
-	if (combo_string) __glXFree(combo_string);
-	if (s1) __glXFree(s1);
+	if (combo_string)
+	    xfree(combo_string);
+	if (s1)
+	    xfree(s1);
 	return NULL;
    }
    combo_string[0] = '\0';
 
    /* Get first extension token */
-   token = __glXStrtok( s1, SEPARATOR);
+   token = strtok( s1, SEPARATOR);
    while ( token != NULL ) {
 
 	/*
@@ -291,20 +296,20 @@ char *__glXcombine_strings(const char *cext_string, const char *sext_string)
 	** beware of extension names which are prefixes of other extension names
 	*/
 	const char *p = s2;
-	end = p + __glXStrlen(p);
+	end = p + strlen(p);
 	while (p < end) {
-	    size_t n = __glXStrcspn(p, SEPARATOR);
-	    if ((__glXStrlen(token) == n) && (__glXStrncmp(token, p, n) == 0)) {
-		combo_string = __glXStrcat( combo_string, token);
-		combo_string = __glXStrcat( combo_string, SEPARATOR);
+	    size_t n = strcspn(p, SEPARATOR);
+	    if ((strlen(token) == n) && (strncmp(token, p, n) == 0)) {
+		combo_string = strcat(combo_string, token);
+		combo_string = strcat(combo_string, SEPARATOR);
 	    }
 	    p += (n + 1);
 	}
 
 	/* Get next extension token */
-	token = __glXStrtok( NULL, SEPARATOR);
+	token = strtok( NULL, SEPARATOR);
    }
-   __glXFree(s1);
+   xfree(s1);
    return combo_string;
 }
 
@@ -348,26 +353,24 @@ int DoGetString(__GLXclientState *cl, GLbyte *pc, GLboolean need_swap)
 	buf = __glXcombine_strings(buf1,
 				      cx->pGlxScreen->GLextensions);
 	if (buf1 != NULL) {
-	    __glXFree(buf1);
+	    xfree(buf1);
 	}
 	string = buf;
     }
     else if ( name == GL_VERSION ) {
 	if ( atof( string ) > atof( GLServerVersion ) ) {
-	    buf = __glXMalloc( __glXStrlen( string ) 
-			       + __glXStrlen( GLServerVersion )
-			       + 4 );
+	    buf = xalloc( strlen( string ) + strlen( GLServerVersion ) + 4 );
 	    if ( buf == NULL ) {
 		string = GLServerVersion;
 	    }
 	    else {
-		__glXSprintf( buf, "%s (%s)", GLServerVersion, string );
+		sprintf( buf, "%s (%s)", GLServerVersion, string );
 		string = buf;
 	    }
 	}
     }
     if (string) {
-	length = __glXStrlen((const char *) string) + 1;
+	length = strlen((const char *) string) + 1;
     }
 
     __GLX_BEGIN_REPLY(length);
@@ -380,9 +383,9 @@ int DoGetString(__GLXclientState *cl, GLbyte *pc, GLboolean need_swap)
 
     __GLX_SEND_HEADER();
     WriteToClient(client, length, (char *) string); 
-    if (buf != NULL) {
-	__glXFree(buf);
-    }
+    if (buf != NULL)
+	xfree(buf);
+
     return Success;
 }
 
diff --git a/GL/glx/single2swap.c b/GL/glx/single2swap.c
index 54dbc99bf..571cc0a62 100644
--- a/GL/glx/single2swap.c
+++ b/GL/glx/single2swap.c
@@ -44,7 +44,6 @@
 #include "glxext.h"
 #include "indirect_dispatch.h"
 #include "unpack.h"
-#include "GL/glx_ansic.h"
 #include "glapitable.h"
 #include "glapi.h"
 #include "glthread.h"
diff --git a/GL/glx/xfont.c b/GL/glx/xfont.c
index 6628f568d..795671534 100644
--- a/GL/glx/xfont.c
+++ b/GL/glx/xfont.c
@@ -82,7 +82,7 @@ static int __glXMakeBitmapFromGlyph(FontPtr font, CharInfoPtr pci)
 	p = buf;
 	allocbuf = 0;
     } else {
-	p = (unsigned char *) __glXMalloc(allocBytes);
+	p = (unsigned char *) xalloc(allocBytes);
 	if (!p)
 	    return BadAlloc;
 	allocbuf = p;
@@ -106,7 +106,7 @@ static int __glXMakeBitmapFromGlyph(FontPtr font, CharInfoPtr pci)
 				  allocbuf ? allocbuf : buf) );
 
     if (allocbuf) {
-	__glXFree(allocbuf);
+	xfree(allocbuf);
     }
     return Success;
 #undef __GL_CHAR_BUF_SIZE
diff --git a/GL/mesa/X/xf86glx.c b/GL/mesa/X/xf86glx.c
index 0444acc80..abecb3d2a 100644
--- a/GL/mesa/X/xf86glx.c
+++ b/GL/mesa/X/xf86glx.c
@@ -400,7 +400,7 @@ static void init_screen_visuals(__GLXMESAscreen *screen)
 	i++;
     }
 
-    __glXFree(used);
+    xfree(used);
 
     screen->xm_vis = pXMesaVisual;
 }
@@ -440,9 +440,3 @@ GlxGetMesaProvider (void)
 {
     return &__glXMesaProvider;
 }
-
-__GLXprovider *
-GlxGetMesaProvider (void)
-{
-    return &__glXMesaProvider;
-}