Merge branch 'mpx' into mdsd

Conflicts:

	Xi/opendev.c

.gitignore

@@ -16,6 +16,7 @@ config.log
 config.status
 config.sub
 configure
+configure.lineno
 depcomp
 install-sh
 libtool
@@ -91,6 +92,8 @@ cfb32/cfbzerarcG.c
 cfb32/cfbzerarcX.c
 doc/Xserver.1x
 doc/Xserver.man
+doc/SecurityPolicy.5
+doc/SecurityPolicy.man
 hw/dmx/Xdmx
 hw/dmx/Xdmx.1x
 hw/dmx/config/dmxtodmx
@@ -206,31 +209,58 @@ hw/xfree86/xaa/mf3-xaaBitmap.c
 hw/xfree86/xaa/mf3-xaaStipple.c
 hw/xfree86/xaa/s-xaaDashLine.c
 hw/xfree86/xaa/s-xaaLine.c
+hw/xfree86/xf1bpp/maskbits.c
+hw/xfree86/xf1bpp/mfbbitblt.c
 hw/xfree86/xf1bpp/mfbbltC.c
 hw/xfree86/xf1bpp/mfbbltCI.c
 hw/xfree86/xf1bpp/mfbbltG.c
 hw/xfree86/xf1bpp/mfbbltO.c
 hw/xfree86/xf1bpp/mfbbltX.c
+hw/xfree86/xf1bpp/mfbbres.c
+hw/xfree86/xf1bpp/mfbbresd.c
+hw/xfree86/xf1bpp/mfbclip.c
+hw/xfree86/xf1bpp/mfbcmap.c
+hw/xfree86/xf1bpp/mfbfillarc.c
+hw/xfree86/xf1bpp/mfbfillrct.c
+hw/xfree86/xf1bpp/mfbfillsp.c
+hw/xfree86/xf1bpp/mfbfont.c
+hw/xfree86/xf1bpp/mfbgc.c
+hw/xfree86/xf1bpp/mfbgetsp.c
 hw/xfree86/xf1bpp/mfbigbblak.c
 hw/xfree86/xf1bpp/mfbigbwht.c
+hw/xfree86/xf1bpp/mfbhrzvert.c
+hw/xfree86/xf1bpp/mfbimage.c
+hw/xfree86/xf1bpp/mfbline.c
+hw/xfree86/xf1bpp/mfbmisc.c
 hw/xfree86/xf1bpp/mfbpablack.c
 hw/xfree86/xf1bpp/mfbpainv.c
 hw/xfree86/xf1bpp/mfbpawhite.c
 hw/xfree86/xf1bpp/mfbpgbblak.c
 hw/xfree86/xf1bpp/mfbpgbinv.c
 hw/xfree86/xf1bpp/mfbpgbwht.c
+hw/xfree86/xf1bpp/mfbpixmap.c
 hw/xfree86/xf1bpp/mfbplyblack.c
 hw/xfree86/xf1bpp/mfbplyinv.c
 hw/xfree86/xf1bpp/mfbplywhite.c
+hw/xfree86/xf1bpp/mfbpntwin.c
+hw/xfree86/xf1bpp/mfbpolypnt.c
+hw/xfree86/xf1bpp/mfbpushpxl.c
+hw/xfree86/xf1bpp/mfbscrclse.c
+hw/xfree86/xf1bpp/mfbscrinit.c
 hw/xfree86/xf1bpp/mfbseg.c
+hw/xfree86/xf1bpp/mfbsetsp.c
 hw/xfree86/xf1bpp/mfbteblack.c
 hw/xfree86/xf1bpp/mfbtewhite.c
 hw/xfree86/xf1bpp/mfbtileC.c
 hw/xfree86/xf1bpp/mfbtileG.c
+hw/xfree86/xf1bpp/mfbwindow.c
+hw/xfree86/xf1bpp/mfbzerarc.c
 hw/xfree86/xf4bpp/mfbseg.c
 hw/xfree86/xf8_32bpp/cfbgc32.c
 hw/xfree86/xf8_32bpp/cfbgc8.c
 hw/xfree86/xorg.c
+hw/xfree86/xorg.conf.example
+hw/xfree86/xorg.conf.example.pre
 hw/xnest/Xnest
 hw/xnest/Xnest.1x
 hw/xnest/Xnest.man

GL/Makefile.am

@@ -1,8 +1,4 @@
-# someone could get really crazy someday and add support for the SI...
+if XDARWIN
-
-# xwin/darwin/xfree86 have their accel support under the DDX
-
-if BUILD_DARWIN
 DARWIN_SUBDIRS = apple
 endif
 SUBDIRS = glx mesa $(DARWIN_SUBDIRS)

GL/glx/Makefile.am

@@ -53,7 +53,6 @@ libglx_la_SOURCES = \
         glxserver.h \
         glxutil.c \
         glxutil.h \
-        glxvisuals.c \
         indirect_dispatch.c \
         indirect_dispatch.h \
         indirect_dispatch_swap.c \

GL/glx/g_disptab.h

@@ -34,7 +34,6 @@
 ** version 1.2.1 Specification.
 */
 
-extern int __glXDisp_GetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc);
 extern int __glXDisp_BindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc);
 extern int __glXDisp_QueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc);
 extern int __glXDisp_QueryHyperpipeNetworkSGIX(__GLXclientState *cl, GLbyte *pc);
@@ -42,7 +41,6 @@ extern int __glXDisp_DestroyHyperpipeConfigSGIX (__GLXclientState *cl, GLbyte *p
 extern int __glXDisp_QueryHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc);
 extern int __glXDisp_HyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc);
 
-extern int __glXDispSwap_GetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc);
 extern int __glXDispSwap_BindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc);
 extern int __glXDispSwap_QueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc);
 extern int __glXDispSwap_QueryHyperpipeNetworkSGIX(__GLXclientState *cl, GLbyte *pc);

GL/glx/glxcmdsswap.c

@@ -77,8 +77,7 @@ int __glXDispSwap_CreateContext(__GLXclientState *cl, GLbyte *pc)
     __GLX_SWAP_INT(&req->screen);
     __GLX_SWAP_INT(&req->shareList);
 
-    return DoCreateContext( cl, req->context, req->shareList, req->visual,
+    return __glXDisp_CreateContext(cl, pc);
-			    req->screen, req->isDirect );
 }
 
 int __glXDispSwap_CreateNewContext(__GLXclientState *cl, GLbyte *pc)
@@ -93,8 +92,7 @@ int __glXDispSwap_CreateNewContext(__GLXclientState *cl, GLbyte *pc)
     __GLX_SWAP_INT(&req->renderType);
     __GLX_SWAP_INT(&req->shareList);
 
-    return DoCreateContext( cl, req->context, req->shareList, req->fbconfig,
+    return __glXDisp_CreateNewContext(cl, pc);
-			    req->screen, req->isDirect );
 }
 
 int __glXDispSwap_CreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
@@ -110,8 +108,7 @@ int __glXDispSwap_CreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
     __GLX_SWAP_INT(&req->renderType);
     __GLX_SWAP_INT(&req->shareList);
 
-    return DoCreateContext( cl, req->context, req->shareList, req->fbconfig,
+    return __glXDisp_CreateContextWithConfigSGIX(cl, pc);
-			    req->screen, req->isDirect );
 }
 
 int __glXDispSwap_DestroyContext(__GLXclientState *cl, GLbyte *pc)
@@ -135,8 +132,7 @@ int __glXDispSwap_MakeCurrent(__GLXclientState *cl, GLbyte *pc)
     __GLX_SWAP_INT(&req->context);
     __GLX_SWAP_INT(&req->oldContextTag);
 
-    return DoMakeCurrent( cl, req->drawable, req->drawable,
+    return __glXDisp_MakeCurrent(cl, pc);
-			  req->context, req->oldContextTag );
 }
 
 int __glXDispSwap_MakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
@@ -150,8 +146,7 @@ int __glXDispSwap_MakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
     __GLX_SWAP_INT(&req->context);
     __GLX_SWAP_INT(&req->oldContextTag);
 
-    return DoMakeCurrent( cl, req->drawable, req->readdrawable,
+    return __glXDisp_MakeContextCurrent(cl, pc);
-			  req->context, req->oldContextTag );
 }
 
 int __glXDispSwap_MakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
@@ -165,8 +160,7 @@ int __glXDispSwap_MakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
     __GLX_SWAP_INT(&req->context);
     __GLX_SWAP_INT(&req->oldContextTag);
 
-    return DoMakeCurrent( cl, req->drawable, req->readable,
+    return __glXDisp_MakeCurrentReadSGI(cl, pc);
-			  req->context, req->oldContextTag );
 }
 
 int __glXDispSwap_IsDirect(__GLXclientState *cl, GLbyte *pc)
@@ -233,7 +227,7 @@ int __glXDispSwap_GetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_INT(&req->screen);
-    return DoGetVisualConfigs( cl, req->screen, GL_TRUE );
+    return __glXDisp_GetVisualConfigs(cl, pc);
 }
 
 int __glXDispSwap_GetFBConfigs(__GLXclientState *cl, GLbyte *pc)
@@ -242,7 +236,7 @@ int __glXDispSwap_GetFBConfigs(__GLXclientState *cl, GLbyte *pc)
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_INT(&req->screen);
-    return DoGetFBConfigs( cl, req->screen, GL_TRUE );
+    return __glXDisp_GetFBConfigs(cl, pc);
 }
 
 int __glXDispSwap_GetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
@@ -251,7 +245,7 @@ int __glXDispSwap_GetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
     __GLX_DECLARE_SWAP_VARIABLES;
 
     __GLX_SWAP_INT(&req->screen);
-    return DoGetFBConfigs( cl, req->screen, GL_TRUE );
+    return __glXDisp_GetFBConfigsSGIX(cl, pc);
 }
 
 int __glXDispSwap_CreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
@@ -265,14 +259,15 @@ int __glXDispSwap_CreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
     __GLX_SWAP_INT(&req->pixmap);
     __GLX_SWAP_INT(&req->glxpixmap);
 
-    return DoCreateGLXPixmap( cl, req->visual, req->screen,
+    return __glXDisp_CreateGLXPixmap(cl, pc);
-			      req->pixmap, req->glxpixmap, NULL, 0 );
 }
 
 int __glXDispSwap_CreatePixmap(__GLXclientState *cl, GLbyte *pc)
 {
     xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
+    CARD32 *attribs;
     __GLX_DECLARE_SWAP_VARIABLES;
+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 
     __GLX_SWAP_SHORT(&req->length);
     __GLX_SWAP_INT(&req->screen);
@@ -280,11 +275,10 @@ int __glXDispSwap_CreatePixmap(__GLXclientState *cl, GLbyte *pc)
     __GLX_SWAP_INT(&req->pixmap);
     __GLX_SWAP_INT(&req->glxpixmap);
     __GLX_SWAP_INT(&req->numAttribs);
+    attribs = (CARD32*)(req + 1);
+    __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
 
-    return DoCreateGLXPixmap( cl, req->fbconfig, req->screen,
+    return __glXDisp_CreatePixmap(cl, pc);
-			      req->pixmap, req->glxpixmap,
-			      (CARD32*)(req + 1),
-			      req->numAttribs );
 }
 
 int __glXDispSwap_CreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
@@ -299,8 +293,7 @@ int __glXDispSwap_CreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc
     __GLX_SWAP_INT(&req->pixmap);
     __GLX_SWAP_INT(&req->glxpixmap);
 
-    return DoCreateGLXPixmap( cl, req->fbconfig, req->screen,
+    return __glXDisp_CreateGLXPixmapWithConfigSGIX(cl, pc);
-			      req->pixmap, req->glxpixmap, NULL, 0 );
 }
 
 int __glXDispSwap_DestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
@@ -328,52 +321,123 @@ int __glXDispSwap_DestroyPixmap(__GLXclientState *cl, GLbyte *pc)
 int __glXDispSwap_QueryContext(__GLXclientState *cl, GLbyte *pc)
 {
     xGLXQueryContextReq *req = (xGLXQueryContextReq *) pc;    
+    __GLX_DECLARE_SWAP_VARIABLES;
 
-    (void) req;
+    __GLX_SWAP_INT(&req->context);
 
-    return BadRequest;    
+    return __glXDisp_QueryContext(cl, pc);
 }
 
 int __glXDispSwap_CreatePbuffer(__GLXclientState *cl, GLbyte *pc)
 {
     xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *) pc;    
+    __GLX_DECLARE_SWAP_VARIABLES;
+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+    CARD32 *attribs;
 
-    (void) req;
+    __GLX_SWAP_INT(&req->screen);
+    __GLX_SWAP_INT(&req->fbconfig);
+    __GLX_SWAP_INT(&req->pbuffer);
+    __GLX_SWAP_INT(&req->numAttribs);
+    attribs = (CARD32*)(req + 1);
+    __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
 
-    return BadRequest;    
+    return __glXDisp_CreatePbuffer(cl, pc);
+}
+
+int __glXDispSwap_CreateGLXPbufferSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreateGLXPbufferSGIXReq *req = (xGLXCreateGLXPbufferSGIXReq *) pc;    
+    __GLX_DECLARE_SWAP_VARIABLES;
+
+    __GLX_SWAP_INT(&req->screen);
+    __GLX_SWAP_INT(&req->fbconfig);
+    __GLX_SWAP_INT(&req->pbuffer);
+    __GLX_SWAP_INT(&req->width);
+    __GLX_SWAP_INT(&req->height);
+
+    return __glXDisp_CreateGLXPbufferSGIX(cl, pc);
 }
 
 int __glXDispSwap_DestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
 {
     xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) req;
+    __GLX_DECLARE_SWAP_VARIABLES;
 
-    return BadRequest;
+    __GLX_SWAP_INT(&req->pbuffer);
+
+    return __glXDisp_DestroyPbuffer(cl, pc);
+}
+
+int __glXDispSwap_DestroyGLXPbufferSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXDestroyGLXPbufferSGIXReq *req = (xGLXDestroyGLXPbufferSGIXReq *) req;
+    __GLX_DECLARE_SWAP_VARIABLES;
+
+    __GLX_SWAP_INT(&req->pbuffer);
+
+    return __glXDisp_DestroyGLXPbufferSGIX(cl, pc);
 }
 
 int __glXDispSwap_ChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
 {
     xGLXChangeDrawableAttributesReq *req =
 	(xGLXChangeDrawableAttributesReq *) req;
+    __GLX_DECLARE_SWAP_VARIABLES;
+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+    CARD32 *attribs;
 
-    return BadRequest;
+    __GLX_SWAP_INT(&req->drawable);
+    __GLX_SWAP_INT(&req->numAttribs);
+    attribs = (CARD32*)(req + 1);
+    __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
+
+    return __glXDisp_ChangeDrawableAttributes(cl, pc);
+}
+
+int __glXDispSwap_ChangeDrawableAttributesSGIX(__GLXclientState *cl,
+					       GLbyte *pc)
+{
+    xGLXChangeDrawableAttributesSGIXReq *req =
+	(xGLXChangeDrawableAttributesSGIXReq *) req;
+    __GLX_DECLARE_SWAP_VARIABLES;
+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+    CARD32 *attribs;
+
+    __GLX_SWAP_INT(&req->drawable);
+    __GLX_SWAP_INT(&req->numAttribs);
+    attribs = (CARD32*)(req + 1);
+    __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
+
+    return __glXDisp_ChangeDrawableAttributesSGIX(cl, pc);
 }
 
 int __glXDispSwap_CreateWindow(__GLXclientState *cl, GLbyte *pc)
 {
     xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
+    __GLX_DECLARE_SWAP_VARIABLES;
+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+    CARD32 *attribs;
 
-    (void) req;
+    __GLX_SWAP_INT(&req->screen);
+    __GLX_SWAP_INT(&req->fbconfig);
+    __GLX_SWAP_INT(&req->window);
+    __GLX_SWAP_INT(&req->glxwindow);
+    __GLX_SWAP_INT(&req->numAttribs);
+    attribs = (CARD32*)(req + 1);
+    __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
 
-    return BadRequest;
+    return __glXDisp_CreateWindow(cl, pc);
 }
 
 int __glXDispSwap_DestroyWindow(__GLXclientState *cl, GLbyte *pc)
 {
     xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc;
+    __GLX_DECLARE_SWAP_VARIABLES;
 
-    (void) req;
+    __GLX_SWAP_INT(&req->glxwindow);
 
-    return BadRequest;
+    return __glXDisp_DestroyWindow(cl, pc);
 }
 
 int __glXDispSwap_SwapBuffers(__GLXclientState *cl, GLbyte *pc)
@@ -643,7 +707,7 @@ void __glXSwapGetDrawableAttributesReply(ClientPtr client,
 
 int __glXDispSwap_Render(__GLXclientState *cl, GLbyte *pc)
 {
-    return DoRender(cl, pc, True);
+    return __glXDisp_Render(cl, pc);
 }
 
 /*
@@ -651,7 +715,7 @@ int __glXDispSwap_Render(__GLXclientState *cl, GLbyte *pc)
 */
 int __glXDispSwap_RenderLarge(__GLXclientState *cl, GLbyte *pc)
 {
-    return DoRenderLarge(cl, pc, True);
+    return __glXDisp_RenderLarge(cl, pc);
 }
 
 /************************************************************************/

GL/glx/glxcontext.h

@@ -44,12 +44,12 @@
 
 typedef struct __GLXtextureFromPixmap __GLXtextureFromPixmap;
 struct __GLXtextureFromPixmap {
-    int (*bindTexImage)		(__GLXcontext *baseContext,
+    int (*bindTexImage)		(__GLXcontext  *baseContext,
-				 int           buffer,
+				 int            buffer,
-				 __GLXpixmap  *pixmap);
+				 __GLXdrawable *pixmap);
-    int (*releaseTexImage)	(__GLXcontext *baseContext,
+    int (*releaseTexImage)	(__GLXcontext  *baseContext,
-				 int           buffer,
+				 int            buffer,
-				 __GLXpixmap  *pixmap);
+				 __GLXdrawable *pixmap);
 };
 
 
@@ -85,14 +85,8 @@ struct __GLXcontext {
     ** Pointer to screen info data for this context.  This is set
     ** when the context is created.
     */
-    ScreenPtr pScreen;
     __GLXscreen *pGlxScreen;
 
-    /*
-    ** This context is created with respect to this visual.
-    */
-    VisualRec *pVisual;
-
     /*
     ** The XID of this context.
     */
@@ -103,11 +97,6 @@ struct __GLXcontext {
     */
     XID share_id;
 
-    /*
-    ** Visual id.
-    */
-    VisualID vid;
-
     /*
     ** screen number.
     */
@@ -128,11 +117,6 @@ struct __GLXcontext {
     */
     GLboolean isDirect;
 
-    /*
-    ** Window pending state
-    */
-    GLuint pendingState;
-
     /*
     ** This flag keeps track of whether there are unflushed GL commands.
     */
@@ -151,12 +135,6 @@ struct __GLXcontext {
     GLuint *selectBuf;
     GLint selectBufSize;	/* number of elements allocated */
 
-    /*
-    ** Set only if current drawable is a glx pixmap.
-    */
-    __GLXpixmap *drawPixmap;
-    __GLXpixmap *readPixmap;
-
     /*
     ** The drawable private this context is bound to
     */

GL/glx/glxdrawable.h

@@ -42,26 +42,12 @@
 
 #include <damage.h>
 
-#ifdef XF86DRI
+/* We just need to avoid clashing with DRAWABLE_{WINDOW,PIXMAP} */
-#include <GL/internal/dri_interface.h>
+enum {
-#endif
+    GLX_DRAWABLE_WINDOW,
-
+    GLX_DRAWABLE_PIXMAP,
-typedef struct {
+    GLX_DRAWABLE_PBUFFER
-
+};
-    DrawablePtr pDraw;
-    __GLcontextModes *modes;
-    __GLXscreen *pGlxScreen;
-    ScreenPtr pScreen;
-    Bool idExists;
-    int refcnt;
-    GLenum target;
-#ifdef XF86DRI
-    DamagePtr pDamage;
-    __DRIcontext *pDRICtx;
-    GLint texname;
-    unsigned long offset;
-#endif
-} __GLXpixmap;
 
 struct __GLXdrawable {
     void (*destroy)(__GLXdrawable *private);
@@ -78,12 +64,10 @@ struct __GLXdrawable {
 
     DrawablePtr pDraw;
     XID drawId;
-    __GLXpixmap *pGlxPixmap;
 
     /*
-    ** Either DRAWABLE_PIXMAP or DRAWABLE_WINDOW, copied from pDraw above.
+    ** Either GLX_DRAWABLE_PIXMAP, GLX_DRAWABLE_WINDOW or
-    ** Needed by the resource freer because pDraw might already have been
+    ** GLX_DRAWABLE_PBUFFER.
-    ** freed.
     */
     int type;
 
@@ -105,6 +89,13 @@ struct __GLXdrawable {
     ** reference count
     */
     int refCount;
+
+    GLenum target;
+
+    /*
+    ** Event mask
+    */
+    unsigned long eventMask;
 };
 
 #endif /* !__GLX_drawable_h__ */

GL/glx/glxdri.c

@@ -59,77 +59,55 @@
 #include "dispatch.h"
 #include "extension_string.h"
 
+#define containerOf(ptr, type, member)			\
+    (type *)( (char *)ptr - offsetof(type,member) )
 
-#define STRINGIFY(macro_or_string)	STRINGIFY_ARG (macro_or_string)
+typedef struct __GLXDRIscreen   __GLXDRIscreen;
-#define	STRINGIFY_ARG(contents)	#contents
+typedef struct __GLXDRIcontext  __GLXDRIcontext;
-
-typedef struct __GLXDRIscreen      __GLXDRIscreen;
-typedef struct __GLXDRIcontext         __GLXDRIcontext;
 typedef struct __GLXDRIdrawable __GLXDRIdrawable;
 
 struct __GLXDRIscreen {
     __GLXscreen		 base;
+    __DRIscreen		 driScreen;
+    void		*driver;
 
-    __DRIscreen			 driScreen;
+    xf86EnterVTProc	*enterVT;
-    void			*driver;
+    xf86LeaveVTProc	*leaveVT;
 
-    xf86EnterVTProc *enterVT;
+    __DRIcopySubBufferExtension *copySubBuffer;
-    xf86LeaveVTProc *leaveVT;
+    __DRIswapControlExtension *swapControl;
 
+#ifdef __DRI_TEX_OFFSET
+    __DRItexOffsetExtension *texOffset;
     DRITexOffsetStartProcPtr texOffsetStart;
     DRITexOffsetFinishProcPtr texOffsetFinish;
-    __GLXpixmap* texOffsetOverride[16];
+    __GLXDRIdrawable *texOffsetOverride[16];
     GLuint lastTexOffsetOverride;
+#endif
 
     unsigned char glx_enable_bits[__GLX_EXT_BYTES];
 };
 
 struct __GLXDRIcontext {
-    __GLXcontext		 base;
+    __GLXcontext base;
-
+    __DRIcontext driContext;
-    __DRIcontext		 driContext;
+    XID hwContextID;
 };
 
 struct __GLXDRIdrawable {
-    __GLXdrawable	 base;
+    __GLXdrawable base;
+    __DRIdrawable driDrawable;
 
-    __DRIdrawable		*driDrawable;
+    /* Pulled in from old __GLXpixmap */
+#ifdef __DRI_TEX_OFFSET
+    GLint texname;
+    __GLXDRIcontext *ctx;
+    unsigned long offset;
+    DamagePtr pDamage;
+#endif
 };
 
-/* History:
+static const char CREATE_NEW_SCREEN_FUNC[] = __DRI_CREATE_NEW_SCREEN_STRING;
- * 20021121 - Initial version
- * 20021128 - Added __glXWindowExists() function
- * 20021207 - Added support for dynamic GLX extensions,
- *            GLX_SGI_swap_control, GLX_SGI_video_sync,
- *            GLX_OML_sync_control, and GLX_MESA_swap_control.
- *            Never officially released.  Do NOT test against
- *            this version.  Use 20030317 instead.
- * 20030317 - Added support GLX_SGIX_fbconfig,
- *            GLX_MESA_swap_frame_usage, GLX_OML_swap_method,
- *            GLX_{ARB,SGIS}_multisample, and
- *            GLX_SGIX_visual_select_group.
- * 20030606 - Added support for GLX_SGI_make_current_read.
- * 20030813 - Made support for dynamic extensions multi-head aware.
- * 20030818 - Added support for GLX_MESA_allocate_memory in place of the
- *            deprecated GLX_NV_vertex_array_range & GLX_MESA_agp_offset
- *            interfaces.
- * 20031201 - Added support for the first round of DRI interface changes.
- *            Do NOT test against this version!  It has binary
- *            compatibility bugs, use 20040317 instead.
- * 20040317 - Added the 'mode' field to __DRIcontextRec.
- * 20040415 - Added support for bindContext3 and unbindContext3.
- * 20040602 - Add __glXGetDrawableInfo.  I though that was there
- *            months ago. :(
- * 20050727 - Gut all the old interfaces.  This breaks compatability with
- *            any DRI driver built to any previous version.
- * 20060314 - Added support for GLX_MESA_copy_sub_buffer.
- */
-
-#define INTERNAL_VERSION 20050727
-
-static const char CREATE_NEW_SCREEN_FUNC[] =
-    "__driCreateNewScreen_" STRINGIFY (INTERNAL_VERSION);
-
 
 static void
 __glXDRIleaveServer(GLboolean rendering)
@@ -138,19 +116,19 @@ __glXDRIleaveServer(GLboolean rendering)
 
     for (i = 0; rendering && i < screenInfo.numScreens; i++) {
 	__GLXDRIscreen * const screen =
-	    (__GLXDRIscreen *) __glXgetActiveScreen(i);
+	    (__GLXDRIscreen *) glxGetScreen(screenInfo.screens[i]);
 	GLuint lastOverride = screen->lastTexOffsetOverride;
 
 	if (lastOverride) {
-	    __GLXpixmap **texOffsetOverride = screen->texOffsetOverride;
+	    __GLXDRIdrawable **texOffsetOverride = screen->texOffsetOverride;
 	    int j;
 
 	    for (j = 0; j < lastOverride; j++) {
-		__GLXpixmap *pGlxPix = texOffsetOverride[j];
+		__GLXDRIdrawable *pGlxPix = texOffsetOverride[j];
 
 		if (pGlxPix && pGlxPix->texname) {
 		    pGlxPix->offset =
-			screen->texOffsetStart((PixmapPtr)pGlxPix->pDraw);
+			screen->texOffsetStart((PixmapPtr)pGlxPix->base.pDraw);
 		}
 	    }
 	}
@@ -160,23 +138,22 @@ __glXDRIleaveServer(GLboolean rendering)
 
     for (i = 0; rendering && i < screenInfo.numScreens; i++) {
 	__GLXDRIscreen * const screen =
-	    (__GLXDRIscreen *) __glXgetActiveScreen(i);
+	    (__GLXDRIscreen *) glxGetScreen(screenInfo.screens[i]);
 	GLuint lastOverride = screen->lastTexOffsetOverride;
 
 	if (lastOverride) {
-	    __GLXpixmap **texOffsetOverride = screen->texOffsetOverride;
+	    __GLXDRIdrawable **texOffsetOverride = screen->texOffsetOverride;
 	    int j;
 
 	    for (j = 0; j < lastOverride; j++) {
-		__GLXpixmap *pGlxPix = texOffsetOverride[j];
+		__GLXDRIdrawable *pGlxPix = texOffsetOverride[j];
 
 		if (pGlxPix && pGlxPix->texname) {
-		    screen->driScreen.setTexOffset(pGlxPix->pDRICtx,
+		    screen->texOffset->setTexOffset(&pGlxPix->ctx->driContext,
-						   pGlxPix->texname,
+						    pGlxPix->texname,
-						   pGlxPix->offset,
+						    pGlxPix->offset,
-						   pGlxPix->pDraw->depth,
+						    pGlxPix->base.pDraw->depth,
-						   ((PixmapPtr)pGlxPix->pDraw)->
+						    ((PixmapPtr)pGlxPix->base.pDraw)->devKind);
-						   devKind);
 		}
 	    }
 	}
@@ -189,8 +166,8 @@ __glXDRIenterServer(GLboolean rendering)
     int i;
 
     for (i = 0; rendering && i < screenInfo.numScreens; i++) {
-	__GLXDRIscreen * const screen =
+	__GLXDRIscreen * const screen = (__GLXDRIscreen *)
-	    (__GLXDRIscreen *) __glXgetActiveScreen(i);
+	    glxGetScreen(screenInfo.screens[i]);
 
 	if (screen->lastTexOffsetOverride) {
 	    CALL_Flush(GET_DISPATCH(), ());
@@ -201,29 +178,21 @@ __glXDRIenterServer(GLboolean rendering)
     DRIWakeupHandler(NULL, 0, NULL);
 }
 
-/**
- * \bug
- * We're jumping through hoops here to get the DRIdrawable which the DRI
- * driver tries to keep to it self...  cf. FIXME in \c createDrawable.
- */
 static void
-__glXDRIdrawableFoo(__GLXDRIdrawable *draw)
+__glXDRIdrawableDestroy(__GLXdrawable *drawable)
 {
-    __GLXDRIscreen * const screen =
+    __GLXDRIdrawable *private = (__GLXDRIdrawable *) drawable;
-      (__GLXDRIscreen *) __glXgetActiveScreen(draw->base.pDraw->pScreen->myNum);
 
-    draw->driDrawable = (*screen->driScreen.getDrawable)(NULL,
+    (*private->driDrawable.destroyDrawable)(&private->driDrawable);
-							 draw->base.drawId,
-							 screen->driScreen.private);
-}
 
-static void
+    /* If the X window was destroyed, the dri DestroyWindow hook will
-__glXDRIdrawableDestroy(__GLXdrawable *private)
+     * aready have taken care of this, so only call if pDraw isn't NULL. */
-{
+    if (drawable->pDraw != NULL) {
-#if 0
+	    __glXenterServer(GL_FALSE);
-    (*glxPriv->driDrawable.destroyDrawable)(NULL,
+	    DRIDestroyDrawable(drawable->pDraw->pScreen,
-					    glxPriv->driDrawable.private);
+			       serverClient, drawable->pDraw);
-#endif
+	    __glXleaveServer(GL_FALSE);
+    }
 
     xfree(private);
 }
@@ -242,10 +211,7 @@ __glXDRIdrawableSwapBuffers(__GLXdrawable *basePrivate)
 {
     __GLXDRIdrawable *private = (__GLXDRIdrawable *) basePrivate;
 
-    __glXDRIdrawableFoo(private);
+    (*private->driDrawable.swapBuffers)(&private->driDrawable);
-
-    (*private->driDrawable->swapBuffers)(NULL,
-					 private->driDrawable->private);
 
     return TRUE;
 }
@@ -255,10 +221,12 @@ static int
 __glXDRIdrawableSwapInterval(__GLXdrawable *baseDrawable, int interval)
 {
     __GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseDrawable;
+    __GLXDRIscreen *screen = (__GLXDRIscreen *)
+	glxGetScreen(baseDrawable->pDraw->pScreen);
 
-    __glXDRIdrawableFoo(draw);
+    if (screen->swapControl)
+	screen->swapControl->setSwapInterval(&draw->driDrawable, interval);
 
-    draw->driDrawable->swap_interval = interval;
     return 0;
 }
 
@@ -268,22 +236,26 @@ __glXDRIdrawableCopySubBuffer(__GLXdrawable *basePrivate,
 			       int x, int y, int w, int h)
 {
     __GLXDRIdrawable *private = (__GLXDRIdrawable *) basePrivate;
+    __GLXDRIscreen *screen = (__GLXDRIscreen *)
+	glxGetScreen(basePrivate->pDraw->pScreen);
 
-    __glXDRIdrawableFoo(private);
+    if (screen->copySubBuffer)
-
+	screen->copySubBuffer->copySubBuffer(&private->driDrawable,
-    (*private->driDrawable->copySubBuffer)(NULL,
+					     x, y, w, h);
-					   private->driDrawable->private,
-					   x, y, w, h);
 }
 
 static void
 __glXDRIcontextDestroy(__GLXcontext *baseContext)
 {
     __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
+    Bool retval;
+
+    context->driContext.destroyContext(&context->driContext);
+
+    __glXenterServer(GL_FALSE);
+    retval = DRIDestroyContext(baseContext->pGlxScreen->pScreen, context->hwContextID);
+    __glXleaveServer(GL_FALSE);
 
-    context->driContext.destroyContext(NULL,
-				       context->base.pScreen->myNum,
-				       context->driContext.private);
     __glXContextDestroy(&context->base);
     xfree(context);
 }
@@ -292,24 +264,20 @@ static int
 __glXDRIcontextMakeCurrent(__GLXcontext *baseContext)
 {
     __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
+    __GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseContext->drawPriv;
+    __GLXDRIdrawable *read = (__GLXDRIdrawable *) baseContext->readPriv;
 
-    return (*context->driContext.bindContext)(NULL,
+    return (*context->driContext.bindContext)(&context->driContext,
-					      context->base.pScreen->myNum,
+					      &draw->driDrawable,
-					      baseContext->drawPriv->drawId,
+					      &read->driDrawable);
-					      baseContext->readPriv->drawId,
+}					      
-					      &context->driContext);
-}
 
 static int
 __glXDRIcontextLoseCurrent(__GLXcontext *baseContext)
 {
     __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
 
-    return (*context->driContext.unbindContext)(NULL,
+    return (*context->driContext.unbindContext)(&context->driContext);
-						context->base.pScreen->myNum,
-						baseContext->drawPriv->drawId,
-						baseContext->readPriv->drawId,
-						&context->driContext);
 }
 
 static int
@@ -331,12 +299,12 @@ static int
 __glXDRIcontextForceCurrent(__GLXcontext *baseContext)
 {
     __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
+    __GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseContext->drawPriv;
+    __GLXDRIdrawable *read = (__GLXDRIdrawable *) baseContext->readPriv;
 
-    return (*context->driContext.bindContext)(NULL,
+    return (*context->driContext.bindContext)(&context->driContext,
-					      context->base.pScreen->myNum,
+					      &draw->driDrawable,
-					      baseContext->drawPriv->drawId,
+					      &read->driDrawable);
-					      baseContext->readPriv->drawId,
-					      &context->driContext);
 }
 
 static void
@@ -370,24 +338,34 @@ glxFillAlphaChannel (PixmapPtr pixmap, int x, int y, int width, int height)
 static int
 __glXDRIbindTexImage(__GLXcontext *baseContext,
 		     int buffer,
-		     __GLXpixmap *glxPixmap)
+		     __GLXdrawable *glxPixmap)
 {
     RegionPtr	pRegion = NULL;
     PixmapPtr	pixmap;
-    int		bpp, override = 0;
+    int		bpp, override = 0, texname;
     GLenum	format, type;
-    ScreenPtr pScreen = glxPixmap->pScreen;
+    ScreenPtr pScreen = glxPixmap->pDraw->pScreen;
+    __GLXDRIdrawable *driDraw =
+	    containerOf(glxPixmap, __GLXDRIdrawable, base);
     __GLXDRIscreen * const screen =
-	(__GLXDRIscreen *) __glXgetActiveScreen(pScreen->myNum);
+	    (__GLXDRIscreen *) glxGetScreen(pScreen);
+
+    CALL_GetIntegerv(GET_DISPATCH(), (glxPixmap->target == GL_TEXTURE_2D ?
+				      GL_TEXTURE_BINDING_2D :
+				      GL_TEXTURE_BINDING_RECTANGLE_NV,
+				      &texname));
+
+    if (!texname)
+	return __glXError(GLXBadContextState);
 
     pixmap = (PixmapPtr) glxPixmap->pDraw;
 
-    if (screen->texOffsetStart && screen->driScreen.setTexOffset) {
+    if (screen->texOffsetStart && screen->texOffset) {
-	__GLXpixmap **texOffsetOverride = screen->texOffsetOverride;
+	__GLXDRIdrawable **texOffsetOverride = screen->texOffsetOverride;
-	int i, firstEmpty = 16, texname;
+	int i, firstEmpty = 16;
 
 	for (i = 0; i < 16; i++) {
-	    if (texOffsetOverride[i] == glxPixmap)
+	    if (texOffsetOverride[i] == driDraw)
 		goto alreadyin; 
 
 	    if (firstEmpty == 16 && !texOffsetOverride[i])
@@ -402,41 +380,37 @@ __glXDRIbindTexImage(__GLXcontext *baseContext,
 	if (firstEmpty >= screen->lastTexOffsetOverride)
 	    screen->lastTexOffsetOverride = firstEmpty + 1;
 
-	texOffsetOverride[firstEmpty] = glxPixmap;
+	texOffsetOverride[firstEmpty] = driDraw;
 
 alreadyin:
 	override = 1;
 
-	glxPixmap->pDRICtx = &((__GLXDRIcontext*)baseContext)->driContext;
+	driDraw->ctx = (__GLXDRIcontext*)baseContext;
 
-	CALL_GetIntegerv(GET_DISPATCH(), (glxPixmap->target == GL_TEXTURE_2D ?
+	if (texname == driDraw->texname)
-					  GL_TEXTURE_BINDING_2D :
-					  GL_TEXTURE_BINDING_RECTANGLE_NV,
-					  &texname));
-
-	if (texname == glxPixmap->texname)
 	    return Success;
 
-	glxPixmap->texname = texname;
+	driDraw->texname = texname;
 
-	screen->driScreen.setTexOffset(glxPixmap->pDRICtx, texname, 0,
+	screen->texOffset->setTexOffset(&driDraw->ctx->driContext, texname, 0,
-				       pixmap->drawable.depth, pixmap->devKind);
+					pixmap->drawable.depth,
+					pixmap->devKind);
     }
 nooverride:
 
-    if (!glxPixmap->pDamage) {
+    if (!driDraw->pDamage) {
 	if (!override) {
-	    glxPixmap->pDamage = DamageCreate(NULL, NULL, DamageReportNone,
+	    driDraw->pDamage = DamageCreate(NULL, NULL, DamageReportNone,
-					      TRUE, pScreen, NULL);
+					    TRUE, pScreen, NULL);
-	    if (!glxPixmap->pDamage)
+	    if (!driDraw->pDamage)
 		return BadAlloc;
 
-	    DamageRegister ((DrawablePtr) pixmap, glxPixmap->pDamage);
+	    DamageRegister ((DrawablePtr) pixmap, driDraw->pDamage);
 	}
 
 	pRegion = NULL;
     } else {
-	pRegion = DamageRegion(glxPixmap->pDamage);
+	pRegion = DamageRegion(driDraw->pDamage);
 	if (REGION_NIL(pRegion))
 	    return Success;
     }
@@ -515,7 +489,7 @@ nooverride:
     }
 
     if (!override)
-	DamageEmpty(glxPixmap->pDamage);
+	DamageEmpty(driDraw->pDamage);
 
     return Success;
 }
@@ -523,19 +497,21 @@ nooverride:
 static int
 __glXDRIreleaseTexImage(__GLXcontext *baseContext,
 			int buffer,
-			__GLXpixmap *pixmap)
+			__GLXdrawable *pixmap)
 {
-    ScreenPtr pScreen = pixmap->pScreen;
+    ScreenPtr pScreen = pixmap->pDraw->pScreen;
+    __GLXDRIdrawable *driDraw =
+	    containerOf(pixmap, __GLXDRIdrawable, base);
     __GLXDRIscreen * const screen =
-	(__GLXDRIscreen *) __glXgetActiveScreen(pScreen->myNum);
+	(__GLXDRIscreen *) glxGetScreen(pScreen);
     GLuint lastOverride = screen->lastTexOffsetOverride;
 
     if (lastOverride) {
-	__GLXpixmap **texOffsetOverride = screen->texOffsetOverride;
+	__GLXDRIdrawable **texOffsetOverride = screen->texOffsetOverride;
 	int i;
 
 	for (i = 0; i < lastOverride; i++) {
-	    if (texOffsetOverride[i] == pixmap) {
+	    if (texOffsetOverride[i] == driDraw) {
 		if (screen->texOffsetFinish)
 		    screen->texOffsetFinish((PixmapPtr)pixmap->pDraw);
 
@@ -572,9 +548,7 @@ __glXDRIscreenDestroy(__GLXscreen *baseScreen)
 {
     __GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen;
 
-    screen->driScreen.destroyScreen(NULL,
+    screen->driScreen.destroyScreen(&screen->driScreen);
-				    screen->base.pScreen->myNum,
-				    screen->driScreen.private);
 
     dlclose(screen->driver);
 
@@ -590,13 +564,18 @@ __glXDRIscreenCreateContext(__GLXscreen *baseScreen,
 {
     __GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen;
     __GLXDRIcontext *context, *shareContext;
-    void *sharePrivate;
+    VisualPtr visual;
+    int i;
+    GLboolean retval;
+    __DRIcontext *driShare;
+    drm_context_t hwContext;
+    ScreenPtr pScreen = baseScreen->pScreen;
 
     shareContext = (__GLXDRIcontext *) baseShareContext;
     if (shareContext)
-	sharePrivate = shareContext->driContext.private;
+	driShare = &shareContext->driContext;
     else
-	sharePrivate = NULL;
+	driShare = NULL;
 
     context = xalloc(sizeof *context);
     if (context == NULL)
@@ -608,28 +587,45 @@ __glXDRIscreenCreateContext(__GLXscreen *baseScreen,
     context->base.loseCurrent       = __glXDRIcontextLoseCurrent;
     context->base.copy              = __glXDRIcontextCopy;
     context->base.forceCurrent      = __glXDRIcontextForceCurrent;
-    context->base.pScreen           = screen->base.pScreen;
 
     context->base.textureFromPixmap = &__glXDRItextureFromPixmap;
+    /* Find the requested X visual */
+    visual = pScreen->visuals;
+    for (i = 0; i < pScreen->numVisuals; i++, visual++)
+	if (visual->vid == modes->visualID)
+	    break;
+    if (i == pScreen->numVisuals)
+	return GL_FALSE;
+
+    context->hwContextID = FakeClientID(0);
+
+    __glXenterServer(GL_FALSE);
+    retval = DRICreateContext(baseScreen->pScreen, visual,
+			      context->hwContextID, &hwContext);
+    __glXleaveServer(GL_FALSE);
 
     context->driContext.private =
-	screen->driScreen.createNewContext(NULL, modes,
+	screen->driScreen.createNewContext(&screen->driScreen,
+					   modes,
 					   0, /* render type */
-					   sharePrivate,
+					   driShare,
+					   hwContext,
 					   &context->driContext);
 
-    context->driContext.mode = modes;
-
     return &context->base;
 }
 
 static __GLXdrawable *
 __glXDRIscreenCreateDrawable(__GLXscreen *screen,
 			     DrawablePtr pDraw,
+			     int type,
 			     XID drawId,
 			     __GLcontextModes *modes)
 {
+    __GLXDRIscreen *driScreen = (__GLXDRIscreen *) screen;
     __GLXDRIdrawable *private;
+    GLboolean retval;
+    drm_drawable_t hwDrawable;
 
     private = xalloc(sizeof *private);
     if (private == NULL)
@@ -637,7 +633,8 @@ __glXDRIscreenCreateDrawable(__GLXscreen *screen,
 
     memset(private, 0, sizeof *private);
 
-    if (!__glXDrawableInit(&private->base, screen, pDraw, drawId, modes)) {
+    if (!__glXDrawableInit(&private->base, screen,
+			   pDraw, type, drawId, modes)) {
         xfree(private);
 	return NULL;
     }
@@ -647,238 +644,50 @@ __glXDRIscreenCreateDrawable(__GLXscreen *screen,
     private->base.swapBuffers   = __glXDRIdrawableSwapBuffers;
     private->base.copySubBuffer = __glXDRIdrawableCopySubBuffer;
 
-#if 0
+    __glXenterServer(GL_FALSE);
-    /* FIXME: It would only be natural that we called
+    retval = DRICreateDrawable(screen->pScreen, serverClient,
-     * driScreen->createNewDrawable here but the DRI drivers manage
+			       pDraw, &hwDrawable);
-     * them a little oddly. FIXME: describe this better.*/
+    __glXleaveServer(GL_FALSE);
 
     /* The last argument is 'attrs', which is used with pbuffers which
      * we currently don't support. */
 
-    glxPriv->driDrawable.private =
+    private->driDrawable.private =
-	(screen->driScreen.createNewDrawable)(NULL, modes,
+	(driScreen->driScreen.createNewDrawable)(&driScreen->driScreen,
-					      drawId,
+						 modes,
-					      &glxPriv->driDrawable,
+						 &private->driDrawable,
-					      0,
+						 hwDrawable, 0, NULL);
-					      NULL);
-#endif
 
     return &private->base;
 }
 
-
-static unsigned
-filter_modes(__GLcontextModes **server_modes,
-	     const __GLcontextModes *driver_modes)
-{
-    __GLcontextModes * m;
-    __GLcontextModes ** prev_next;
-    const __GLcontextModes * check;
-    unsigned modes_count = 0;
-
-    if ( driver_modes == NULL ) {
-	LogMessage(X_WARNING,
-		   "AIGLX: 3D driver returned no fbconfigs.\n");
-	return 0;
-    }
-
-    /* For each mode in server_modes, check to see if a matching mode exists
-     * in driver_modes.  If not, then the mode is not available.
-     */
-
-    prev_next = server_modes;
-    for ( m = *prev_next ; m != NULL ; m = *prev_next ) {
-	GLboolean do_delete = GL_TRUE;
-
-	for ( check = driver_modes ; check != NULL ; check = check->next ) {
-	    if ( _gl_context_modes_are_same( m, check ) ) {
-		do_delete = GL_FALSE;
-		break;
-	    }
-	}
-
-	/* The 3D has to support all the modes that match the GLX visuals
-	 * sent from the X server.
-	 */
-	if ( do_delete && (m->visualID != 0) ) {
-	    do_delete = GL_FALSE;
-
-	    LogMessage(X_WARNING,
-		       "AIGLX: 3D driver claims to not support "
-		       "visual 0x%02x\n", m->visualID);
-	}
-
-	if ( do_delete ) {
-	    *prev_next = m->next;
-
-	    m->next = NULL;
-	    _gl_context_modes_destroy( m );
-	}
-	else {
-	    modes_count++;
-	    prev_next = & m->next;
-	}
-    }
-
-    return modes_count;
-}
-
-
-static void
-enable_glx_extension(void *psc, const char *ext_name)
-{
-    __GLXDRIscreen * const screen = (__GLXDRIscreen *) psc;
-
-    __glXEnableExtension(screen->glx_enable_bits, ext_name);
-}
-
-
-static __DRIfuncPtr getProcAddress(const char *proc_name)
-{
-    if (strcmp(proc_name, "glxEnableExtension") == 0) {
-	return (__DRIfuncPtr) enable_glx_extension;
-    }
-
-    return NULL;
-}
-
-static __DRIscreen *findScreen(__DRInativeDisplay *dpy, int scrn)
-{
-    __GLXDRIscreen *screen = (__GLXDRIscreen *) __glXgetActiveScreen(scrn);
-
-    return &screen->driScreen;
-}
-
-static GLboolean windowExists(__DRInativeDisplay *dpy, __DRIid draw)
-{
-    DrawablePtr pDrawable = (DrawablePtr) LookupIDByType(draw, RT_WINDOW);
-    int unused;
-    drm_clip_rect_t *pRects;
-
-    return pDrawable ? DRIGetDrawableInfo(pDrawable->pScreen, pDrawable,
-					  (unsigned*)&unused, (unsigned*)&unused,
-					  &unused, &unused, &unused, &unused,
-					  &unused, &pRects, &unused, &unused,
-					  &unused, &pRects)
-		     : GL_FALSE;
-}
-
-static GLboolean createContext(__DRInativeDisplay *dpy, int screen,
-			       int configID, void *contextID,
-			       drm_context_t *hw_context)
-{
-    XID fakeID;
-    VisualPtr visual;
-    int i;
-    ScreenPtr pScreen;
-    GLboolean retval;
-
-    pScreen = screenInfo.screens[screen];
-
-    /* Find the requested X visual */
-    visual = pScreen->visuals;
-    for (i = 0; i < pScreen->numVisuals; i++, visual++)
-	if (visual->vid == configID)
-	    break;
-    if (i == pScreen->numVisuals)
-	return GL_FALSE;
-
-    fakeID = FakeClientID(0);
-    *(XID *) contextID = fakeID;
-
-    __glXDRIenterServer(GL_FALSE);
-    retval = DRICreateContext(pScreen, visual, fakeID, hw_context);
-    __glXDRIleaveServer(GL_FALSE);
-    return retval;
-}
-
-static GLboolean destroyContext(__DRInativeDisplay *dpy, int screen,
-				__DRIid context)
-{
-    GLboolean retval;
-
-    __glXDRIenterServer(GL_FALSE);
-    retval = DRIDestroyContext(screenInfo.screens[screen], context);
-    __glXDRIleaveServer(GL_FALSE);
-    return retval;
-}
-
 static GLboolean
-createDrawable(__DRInativeDisplay *dpy, int screen,
+getDrawableInfo(__DRIdrawable *driDrawable,
-	       __DRIid drawable, drm_drawable_t *hHWDrawable)
+		unsigned int *index, unsigned int *stamp,
-{
-    DrawablePtr pDrawable;
-    GLboolean retval;
-
-    pDrawable = (DrawablePtr) LookupIDByClass(drawable, RC_DRAWABLE);
-    if (!pDrawable)
-	return GL_FALSE;
-
-    __glXDRIenterServer(GL_FALSE);
-    retval = DRICreateDrawable(screenInfo.screens[screen], __pGlxClient,
-			       pDrawable, hHWDrawable);
-    __glXDRIleaveServer(GL_FALSE);
-    return retval;
-}
-
-static GLboolean
-destroyDrawable(__DRInativeDisplay *dpy, int screen, __DRIid drawable)
-{
-    DrawablePtr pDrawable;
-    GLboolean retval;
-
-    pDrawable = (DrawablePtr) LookupIDByClass(drawable, RC_DRAWABLE);
-    if (!pDrawable)
-	return GL_FALSE;
-
-    __glXDRIenterServer(GL_FALSE);
-    retval = DRIDestroyDrawable(screenInfo.screens[screen], __pGlxClient,
-				pDrawable);
-    __glXDRIleaveServer(GL_FALSE);
-    return retval;
-}
-
-static GLboolean
-getDrawableInfo(__DRInativeDisplay *dpy, int screen,
-		__DRIid drawable, unsigned int *index, unsigned int *stamp,
 		int *x, int *y, int *width, int *height,
 		int *numClipRects, drm_clip_rect_t **ppClipRects,
 		int *backX, int *backY,
 		int *numBackClipRects, drm_clip_rect_t **ppBackClipRects)
 {
-    DrawablePtr pDrawable;
+    __GLXDRIdrawable *drawable = containerOf(driDrawable,
+					     __GLXDRIdrawable, driDrawable);
+    ScreenPtr pScreen;
     drm_clip_rect_t *pClipRects, *pBackClipRects;
     GLboolean retval;
     size_t size;
 
-    pDrawable = (DrawablePtr) LookupIDByClass(drawable, RC_DRAWABLE);
+    /* If the X window has been destroyed, give up here. */
-    if (!pDrawable) {
+    if (drawable->base.pDraw == NULL)
-	ErrorF("getDrawableInfo failed to look up window\n");
-
-        *index = 0;
-	*stamp = 0;
-        *x = 0;
-        *y = 0;
-	*width = 0;
-	*height = 0;
-	*numClipRects = 0;
-	*ppClipRects = NULL;
-	*backX = 0;
-	*backY = 0;
-	*numBackClipRects = 0;
-	*ppBackClipRects = NULL;
-
 	return GL_FALSE;
-    }
 
-    __glXDRIenterServer(GL_FALSE);
+    pScreen = drawable->base.pDraw->pScreen;
-    retval = DRIGetDrawableInfo(screenInfo.screens[screen],
+    __glXenterServer(GL_FALSE);
-				pDrawable, index, stamp,
+    retval = DRIGetDrawableInfo(pScreen, drawable->base.pDraw, index, stamp,
 				x, y, width, height,
 				numClipRects, &pClipRects,
 				backX, backY,
 				numBackClipRects, &pBackClipRects);
-    __glXDRIleaveServer(GL_FALSE);
+    __glXleaveServer(GL_FALSE);
 
     if (*numClipRects > 0) {
 	size = sizeof (drm_clip_rect_t) * *numClipRects;
@@ -886,7 +695,6 @@ getDrawableInfo(__DRInativeDisplay *dpy, int screen,
 
 	/* Clip cliprects to screen dimensions (redirected windows) */
 	if (*ppClipRects != NULL) {
-	    ScreenPtr pScreen = screenInfo.screens[screen];
 	    int i, j;
 
 	    for (i = 0, j = 0; i < *numClipRects; i++) {
@@ -943,25 +751,33 @@ getUST(int64_t *ust)
     }
 }
 
+static void __glXReportDamage(__DRIdrawable *driDraw,
+			      int x, int y,
+			      drm_clip_rect_t *rects, int num_rects,
+			      GLboolean front_buffer)
+{
+    __GLXDRIdrawable *drawable =
+	    containerOf(driDraw, __GLXDRIdrawable, driDrawable);
+    DrawablePtr pDraw = drawable->base.pDraw;
+    RegionRec region;
+
+    REGION_INIT(pDraw->pScreen, &region, (BoxPtr) rects, num_rects);
+    REGION_TRANSLATE(pScreen, &region, pDraw->x, pDraw->y);
+    DamageDamageRegion(pDraw, &region);
+    REGION_UNINIT(pDraw->pScreen, &region);
+}
+
 /* Table of functions that we export to the driver. */
 static const __DRIinterfaceMethods interface_methods = {
-    getProcAddress,
-
     _gl_context_modes_create,
     _gl_context_modes_destroy,
-      
-    findScreen,
-    windowExists,
-      
-    createContext,
-    destroyContext,
 
-    createDrawable,
-    destroyDrawable,
     getDrawableInfo,
 
     getUST,
     NULL, /* glXGetMscRateOML, */
+
+    __glXReportDamage,
 };
 
 static const char dri_driver_path[] = DRI_DRIVER_PATH;
@@ -969,7 +785,8 @@ static const char dri_driver_path[] = DRI_DRIVER_PATH;
 static Bool
 glxDRIEnterVT (int index, int flags)
 {
-    __GLXDRIscreen *screen = (__GLXDRIscreen *) __glXgetActiveScreen(index);
+    __GLXDRIscreen *screen = (__GLXDRIscreen *) 
+	glxGetScreen(screenInfo.screens[index]);
 
     LogMessage(X_INFO, "AIGLX: Resuming AIGLX clients after VT switch\n");
 
@@ -984,7 +801,8 @@ glxDRIEnterVT (int index, int flags)
 static void
 glxDRILeaveVT (int index, int flags)
 {
-    __GLXDRIscreen *screen = (__GLXDRIscreen *) __glXgetActiveScreen(index);
+    __GLXDRIscreen *screen = (__GLXDRIscreen *)
+	glxGetScreen(screenInfo.screens[index]);
 
     LogMessage(X_INFO, "AIGLX: Suspending AIGLX clients for VT switch\n");
 
@@ -993,6 +811,48 @@ glxDRILeaveVT (int index, int flags)
     return (*screen->leaveVT) (index, flags);
 }
 
+static void
+initializeExtensions(__GLXDRIscreen *screen)
+{
+    const __DRIextension **extensions;
+    int i;
+
+    extensions = screen->driScreen.getExtensions(&screen->driScreen);
+    for (i = 0; extensions[i]; i++) {
+#ifdef __DRI_COPY_SUB_BUFFER
+	if (strcmp(extensions[i]->name, __DRI_COPY_SUB_BUFFER) == 0) {
+	    screen->copySubBuffer = (__DRIcopySubBufferExtension *) extensions[i];
+	    __glXEnableExtension(screen->glx_enable_bits,
+				 "GLX_MESA_copy_sub_buffer");
+	    
+	    LogMessage(X_INFO, "AIGLX: enabled GLX_MESA_copy_sub_buffer\n");
+	}
+#endif
+
+#ifdef __DRI_SWAP_CONTROL
+	if (strcmp(extensions[i]->name, __DRI_SWAP_CONTROL) == 0) {
+	    screen->swapControl = (__DRIswapControlExtension *) extensions[i];
+	    __glXEnableExtension(screen->glx_enable_bits,
+				 "GLX_SGI_swap_control");
+	    __glXEnableExtension(screen->glx_enable_bits,
+				 "GLX_MESA_swap_control");
+	    
+	    LogMessage(X_INFO, "AIGLX: enabled GLX_SGI_swap_control and GLX_MESA_swap_control\n");
+	}
+#endif
+
+#ifdef __DRI_TEX_OFFSET
+	if (strcmp(extensions[i]->name, __DRI_TEX_OFFSET) == 0) {
+	    screen->texOffset = (__DRItexOffsetExtension *) extensions[i];
+	    LogMessage(X_INFO, "AIGLX: enabled GLX_texture_from_pixmap with driver support\n");
+	}
+#endif
+	/* Ignore unknown extensions */
+    }
+}
+    
+#define COPY_SUB_BUFFER_INTERNAL_VERSION 20060314
+
 static __GLXscreen *
 __glXDRIscreenProbe(ScreenPtr pScreen)
 {
@@ -1013,7 +873,6 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
     char *driverName;
     drm_handle_t  hFB;
     int        junk;
-    __GLcontextModes * driver_modes;
     __GLXDRIscreen *screen;
     void *dev_priv = NULL;
     char filename[128];
@@ -1041,8 +900,6 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
     screen->base.pScreen       = pScreen;
 
     __glXInitExtensionEnableBits(screen->glx_enable_bits);
-    screen->driScreen.screenConfigs = screen;
-
 
     /* DRI protocol version. */
     dri_version.major = XF86DRI_MAJOR_VERSION;
@@ -1165,11 +1022,9 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
 	goto handle_error;
     }
     
-    driver_modes = NULL;
     screen->driScreen.private =
-	(*createNewScreen)(NULL, pScreen->myNum,
+	(*createNewScreen)(pScreen->myNum,
 			   &screen->driScreen,
-			   screen->base.modes,
 			   &ddx_version,
 			   &dri_version,
 			   &drm_version,
@@ -1178,7 +1033,7 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
 			   fd,
 			   api_ver,
 			   &interface_methods,
-			   &driver_modes);
+			   &screen->base.fbconfigs);
 
     if (screen->driScreen.private == NULL) {
 	LogMessage(X_ERROR, "AIGLX error: Calling driver entry point failed");
@@ -1188,6 +1043,8 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
     DRIGetTexOffsetFuncs(pScreen, &screen->texOffsetStart,
 			 &screen->texOffsetFinish);
 
+    initializeExtensions(screen);
+
     __glXScreenInit(&screen->base, pScreen);
 
     buffer_size = __glXGetExtensionString(screen->glx_enable_bits, NULL);
@@ -1201,10 +1058,6 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
 				       screen->base.GLXextensions);
     }
 
-
-    filter_modes(&screen->base.modes, driver_modes);
-    _gl_context_modes_destroy(driver_modes);
-
     __glXsetEnterLeaveServerFuncs(__glXDRIenterServer, __glXDRIleaveServer);
 
     screen->enterVT = pScrn->EnterVT;

GL/glx/glxext.c

@@ -45,8 +45,6 @@ __GLXcontext *__glXLastContext;
 ** X resources.
 */
 RESTYPE __glXContextRes;
-RESTYPE __glXClientRes;
-RESTYPE __glXPixmapRes;
 RESTYPE __glXDrawableRes;
 RESTYPE __glXSwapBarrierRes;
 
@@ -55,11 +53,7 @@ RESTYPE __glXSwapBarrierRes;
 */
 xGLXSingleReply __glXReply;
 
-/*
+static int glxClientPrivateIndex;
-** A set of state for each client.  The 0th one is unused because client
-** indices start at 1, not 0.
-*/
-static __GLXclientState *__glXClients[MAXCLIENTS + 1];
 
 /*
 ** Client that called into GLX dispatch.
@@ -77,29 +71,6 @@ static int __glXDispatch(ClientPtr);
 static void ResetExtension(ExtensionEntry* extEntry)
 {
     __glXFlushContextCache();
-    __glXResetScreens();
-}
-
-/*
-** Initialize the per-client context storage.
-*/
-static void ResetClientState(int clientIndex)
-{
-    __GLXclientState *cl = __glXClients[clientIndex];
-
-    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)
-	xfree(cl->GLClientextensions);
-
 }
 
 /*
@@ -129,95 +100,14 @@ static int ContextGone(__GLXcontext* cx, XID id)
     return True;
 }
 
-/*
-** Free a client's state.
-*/
-static int ClientGone(int clientIndex, XID id)
-{
-    __GLXcontext *cx;
-    __GLXclientState *cl = __glXClients[clientIndex];
-    int i;
-
-    if (cl) {
-	/*
-	** Free all the contexts that are current for this client.
-	*/
-	for (i=0; i < cl->numCurrentContexts; i++) {
-	    cx = cl->currentContexts[i];
-	    if (cx) {
-		__glXDeassociateContext(cx);
-		cx->isCurrent = GL_FALSE;
-		if (!cx->idExists) {
-		    __glXFreeContext(cx);
-		}
-	    }
-	}
-	/*
-	** Re-initialize the client state structure.  Don't free it because
-	** we'll probably get another client with this index and use the struct
-	** again.  There is a maximum of MAXCLIENTS of these structures.
-	*/
-	ResetClientState(clientIndex);
-    }
-
-    return True;
-}
-
-/*
-** Free a GLX Pixmap.
-*/
-static int PixmapGone(__GLXpixmap *pGlxPixmap, XID id)
-{
-    PixmapPtr pPixmap = (PixmapPtr) pGlxPixmap->pDraw;
-
-    pGlxPixmap->idExists = False;
-    if (!pGlxPixmap->refcnt) {
-#ifdef XF86DRI
-	if (pGlxPixmap->pDamage) {
-	    DamageUnregister (pGlxPixmap->pDraw, pGlxPixmap->pDamage);
-	    DamageDestroy(pGlxPixmap->pDamage);
-	}
-#endif
-	/*
-	** The DestroyPixmap routine should decrement the refcount and free
-	** only if it's zero.
-	*/
-	(*pGlxPixmap->pScreen->DestroyPixmap)(pPixmap);
-	xfree(pGlxPixmap);
-    }
-
-    return True;
-}
-
 /*
 ** Destroy routine that gets called when a drawable is freed.  A drawable
 ** contains the ancillary buffers needed for rendering.
 */
 static Bool DrawableGone(__GLXdrawable *glxPriv, XID xid)
 {
-    __GLXcontext *cx, *cx1;
+    glxPriv->pDraw = NULL;
-
+    glxPriv->drawId = 0;
-    /*
-    ** Use glxPriv->type to figure out what kind of drawable this is. Don't
-    ** use glxPriv->pDraw->type because by the time this routine is called,
-    ** the pDraw might already have been freed.
-    */
-    if (glxPriv->type == DRAWABLE_WINDOW) {
-	/*
-	** When a window is destroyed, notify all context bound to 
-	** it, that there are no longer bound to anything.
-	*/
-	for (cx = glxPriv->drawGlxc; cx; cx = cx1) {
-	    cx1 = cx->nextDrawPriv;
-	    cx->pendingState |= __GLX_PENDING_DESTROY;
-	}
-
-	for (cx = glxPriv->readGlxc; cx; cx = cx1) {
-	    cx1 = cx->nextReadPriv;
-	    cx->pendingState |= __GLX_PENDING_DESTROY;
-	}
-    }
-
     __glXUnrefDrawable(glxPriv);
 
     return True;
@@ -260,9 +150,10 @@ extern RESTYPE __glXSwapBarrierRes;
 
 static int SwapBarrierGone(int screen, XID drawable)
 {
-    if (__glXSwapBarrierFuncs &&
+    __GLXscreen *pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
-        __glXSwapBarrierFuncs[screen].bindSwapBarrierFunc != NULL) {
+
-        __glXSwapBarrierFuncs[screen].bindSwapBarrierFunc(screen, drawable, 0);
+    if (pGlxScreen->swapBarrierFuncs) {
+        pGlxScreen->swapBarrierFuncs->bindSwapBarrierFunc(screen, drawable, 0);
     }
     FreeResourceByType(drawable, __glXSwapBarrierRes, FALSE);
     return True;
@@ -310,22 +201,86 @@ int __glXError(int error)
     return __glXErrorBase + error;
 }
 
+__GLXclientState *
+glxGetClient(ClientPtr pClient)
+{
+    return (__GLXclientState *) pClient->devPrivates[glxClientPrivateIndex].ptr;
+}
+
+static void
+glxClientCallback (CallbackListPtr	*list,
+		   pointer		closure,
+		   pointer		data)
+{
+    NewClientInfoRec	*clientinfo = (NewClientInfoRec *) data;
+    ClientPtr		pClient = clientinfo->client;
+    __GLXclientState	*cl = glxGetClient(pClient);
+    __GLXcontext	*cx;
+    int i;
+
+    switch (pClient->clientState) {
+    case ClientStateRunning:
+	/*
+	** By default, assume that the client supports
+	** GLX major version 1 minor version 0 protocol.
+	*/
+	cl->GLClientmajorVersion = 1;
+	cl->GLClientminorVersion = 0;
+	cl->client = pClient;
+	break;
+
+    case ClientStateGone:
+	for (i = 0; i < cl->numCurrentContexts; i++) {
+	    cx = cl->currentContexts[i];
+	    if (cx) {
+		cx->isCurrent = GL_FALSE;
+		if (!cx->idExists)
+		    __glXFreeContext(cx);
+	    }
+	}
+
+	if (cl->returnBuf) xfree(cl->returnBuf);
+	if (cl->largeCmdBuf) xfree(cl->largeCmdBuf);
+	if (cl->currentContexts) xfree(cl->currentContexts);
+	if (cl->GLClientextensions) xfree(cl->GLClientextensions);
+	break;
+
+    default:
+	break;
+    }
+}
+
 /************************************************************************/
 
+static __GLXprovider *__glXProviderStack;
+
+void GlxPushProvider(__GLXprovider *provider)
+{
+    provider->next = __glXProviderStack;
+    __glXProviderStack = provider;
+}
+
 /*
 ** Initialize the GLX extension.
 */
 void GlxExtensionInit(void)
 {
     ExtensionEntry *extEntry;
+    ScreenPtr pScreen;
     int i;
+    __GLXprovider *p;
 
     __glXContextRes = CreateNewResourceType((DeleteType)ContextGone);
-    __glXClientRes = CreateNewResourceType((DeleteType)ClientGone);
-    __glXPixmapRes = CreateNewResourceType((DeleteType)PixmapGone);
     __glXDrawableRes = CreateNewResourceType((DeleteType)DrawableGone);
     __glXSwapBarrierRes = CreateNewResourceType((DeleteType)SwapBarrierGone);
 
+    glxClientPrivateIndex = AllocateClientPrivateIndex ();
+    if (!AllocateClientPrivate (glxClientPrivateIndex,
+				sizeof (__GLXclientState)))
+	return;
+    if (!AddCallback (&ClientStateCallback, glxClientCallback, 0))
+	return;
+
     /*
     ** Add extension to server extensions.
     */
@@ -344,17 +299,18 @@ void GlxExtensionInit(void)
 
     __glXErrorBase = extEntry->errorBase;
 
-    /*
+    for (i = 0; i < screenInfo.numScreens; i++) {
-    ** Initialize table of client state.  There is never a client 0.
+	pScreen = screenInfo.screens[i];
-    */
-    for (i = 1; i <= MAXCLIENTS; i++) {
-	__glXClients[i] = 0;
-    }
 
-    /*
+	for (p = __glXProviderStack; p != NULL; p = p->next) {
-    ** Initialize screen specific data.
+	    if (p->screenProbe(pScreen) != NULL) {
-    */
+		LogMessage(X_INFO,
-    __glXInitScreens();
+			   "GLX: Initialized %s GL provider for screen %d\n",
+			   p->name, i);
+	    	break;
+	    }
+	}
+    }
 }
 
 /************************************************************************/
@@ -422,11 +378,9 @@ void glxSuspendClients(void)
 {
     int i;
 
-    for (i = 1; i <= MAXCLIENTS; i++) {
+    for (i = 1; i < currentMaxClients; i++) {
-	if (__glXClients[i] == NULL || !__glXClients[i]->inUse)
+	if (clients[i] && glxGetClient(clients[i])->inUse)
-	    continue;
+	    IgnoreClient(clients[i]);
-
-	IgnoreClient(__glXClients[i]->client);
     }
 
     glxBlockClients = TRUE;
@@ -439,11 +393,9 @@ void glxResumeClients(void)
 
     glxBlockClients = FALSE;
 
-    for (i = 1; i <= MAXCLIENTS; i++) {
+    for (i = 1; i < currentMaxClients; i++) {
-	if (__glXClients[i] == NULL || !__glXClients[i]->inUse)
+	if (clients[i] && glxGetClient(clients[i])->inUse)
-	    continue;
+	    AttendClient(clients[i]);
-
-	AttendClient(__glXClients[i]->client);
     }
 
     __glXleaveServer(GL_FALSE);
@@ -505,29 +457,9 @@ static int __glXDispatch(ClientPtr client)
     int retval;
 
     opcode = stuff->glxCode;
-    cl = __glXClients[client->index];
+    cl = glxGetClient(client);
-    if (!cl) {
+    /* Mark it in use so we suspend it on VT switch. */
-	cl = (__GLXclientState *) xalloc(sizeof(__GLXclientState));
+    cl->inUse = TRUE;
-	 __glXClients[client->index] = cl;
-	if (!cl) {
-	    return BadAlloc;
-	}
-	memset(cl, 0, sizeof(__GLXclientState));
-    }
-    
-    if (!cl->inUse) {
-	/*
-	** This is first request from this client.  Associate a resource
-	** 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)) {
-	    return BadAlloc;
-	}
-	ResetClientState(client->index);
-	cl->inUse = GL_TRUE;
-	cl->client = client;
-    }
 
     /*
     ** If we're expecting a glXRenderLarge request, this better be one.

GL/glx/glxext.h

@@ -71,24 +71,6 @@ extern void __glXClearErrorOccured(void);
 extern GLboolean __glXErrorOccured(void);
 extern void __glXResetLargeCommandStatus(__GLXclientState*);
 
-extern int DoMakeCurrent( __GLXclientState *cl, GLXDrawable drawId,
-    GLXDrawable readId, GLXContextID contextId, GLXContextTag tag );
-extern int DoGetVisualConfigs(__GLXclientState *cl, unsigned screen,
-    GLboolean do_swap);
-extern int DoGetFBConfigs(__GLXclientState *cl, unsigned screen,
-    GLboolean do_swap);
-extern int DoCreateContext(__GLXclientState *cl, GLXContextID gcId,
-    GLXContextID shareList, VisualID visual, GLuint screen, GLboolean isDirect);
-extern int DoCreateGLXPixmap(__GLXclientState *cl, XID fbconfigId,
-    GLuint screenNum, XID pixmapId, XID glxpixmapId, CARD32 *attribs,
-    CARD32 numAttribs);
-extern int DoDestroyPixmap(__GLXclientState *cl, XID glxpixmapId);
-
-extern int DoQueryContext(__GLXclientState *cl, GLXContextID gcId);
-
-extern int DoRender(__GLXclientState *cl, GLbyte *pc, int do_swap);
-extern int DoRenderLarge(__GLXclientState *cl, GLbyte *pc, int do_swap);
-
 extern void GlxExtensionInit(void);
 
 extern const char GLServerVersion[];
@@ -106,25 +88,5 @@ extern int GlxInitVisuals(
     int               preferredVis
 );
 
-typedef struct {
-    void * (* queryHyperpipeNetworkFunc)(int, int *, int *);
-    void * (* queryHyperpipeConfigFunc)(int, int, int *, int *);
-    int    (* destroyHyperpipeConfigFunc)(int, int);
-    void * (* hyperpipeConfigFunc)(int, int, int *, int *, void *);
-} __GLXHyperpipeExtensionFuncs;
-
-extern void __glXHyperpipeInit(int screen, __GLXHyperpipeExtensionFuncs *funcs);
-
-extern __GLXHyperpipeExtensionFuncs *__glXHyperpipeFuncs;
-
-typedef struct {
-    int    (* bindSwapBarrierFunc)(int, XID, int);
-    int    (* queryMaxSwapBarriersFunc)(int);
-} __GLXSwapBarrierExtensionFuncs;
-
-extern void __glXSwapBarrierInit(int screen, __GLXSwapBarrierExtensionFuncs *funcs);
-
-extern __GLXSwapBarrierExtensionFuncs *__glXSwapBarrierFuncs;
-
 #endif /* _glxext_h_ */
 

GL/glx/glxglcore.c

@@ -70,7 +70,7 @@ struct __GLXMESAdrawable {
     XMesaBuffer   xm_buf;
 };
 
-static XMesaVisual find_mesa_visual(__GLXscreen *screen, VisualID vid);
+static XMesaVisual find_mesa_visual(__GLXscreen *screen, XID fbconfigID);
 
 
 static void
@@ -118,7 +118,7 @@ __glXMesaDrawableSwapBuffers(__GLXdrawable *base)
 
 static __GLXdrawable *
 __glXMesaScreenCreateDrawable(__GLXscreen *screen,
-			      DrawablePtr pDraw,
+			      DrawablePtr pDraw, int type,
 			      XID drawId,
 			      __GLcontextModes *modes)
 {
@@ -131,7 +131,8 @@ __glXMesaScreenCreateDrawable(__GLXscreen *screen,
 
     memset(glxPriv, 0, sizeof *glxPriv);
 
-    if (!__glXDrawableInit(&glxPriv->base, screen, pDraw, drawId, modes)) {
+    if (!__glXDrawableInit(&glxPriv->base, screen,
+			   pDraw, type, drawId, modes)) {
         xfree(glxPriv);
 	return NULL;
     }
@@ -140,7 +141,7 @@ __glXMesaScreenCreateDrawable(__GLXscreen *screen,
     glxPriv->base.resize      = __glXMesaDrawableResize;
     glxPriv->base.swapBuffers = __glXMesaDrawableSwapBuffers;
 
-    xm_vis = find_mesa_visual(screen, modes->visualID);
+    xm_vis = find_mesa_visual(screen, modes->fbconfigID);
     if (xm_vis == NULL) {
 	ErrorF("find_mesa_visual returned NULL for visualID = 0x%04x\n",
 	       modes->visualID);
@@ -154,6 +155,11 @@ __glXMesaScreenCreateDrawable(__GLXscreen *screen,
 	glxPriv->xm_buf = XMesaCreatePixmapBuffer(xm_vis, (PixmapPtr)pDraw, 0);
     }
 
+    if (glxPriv->xm_buf == NULL) {
+	xfree(glxPriv);
+	return NULL;
+    }
+
     return &glxPriv->base;
 }
 
@@ -234,7 +240,7 @@ __glXMesaScreenCreateContext(__GLXscreen *screen,
     context->base.copy           = __glXMesaContextCopy;
     context->base.forceCurrent   = __glXMesaContextForceCurrent;
 
-    xm_vis = find_mesa_visual(screen, modes->visualID);
+    xm_vis = find_mesa_visual(screen, modes->fbconfigID);
     if (!xm_vis) {
 	ErrorF("find_mesa_visual returned NULL for visualID = 0x%04x\n",
 	       modes->visualID);
@@ -259,7 +265,7 @@ __glXMesaScreenDestroy(__GLXscreen *screen)
     int i;
 
     if (mesaScreen->xm_vis) {
-	for (i = 0; i < mesaScreen->num_vis; i++) {
+	for (i = 0; i < mesaScreen->base.numFBConfigs; i++) {
 	    if (mesaScreen->xm_vis[i])
 		XMesaDestroyVisual(mesaScreen->xm_vis[i]);
 	}
@@ -273,104 +279,122 @@ __glXMesaScreenDestroy(__GLXscreen *screen)
 }
 
 static XMesaVisual
-find_mesa_visual(__GLXscreen *screen, VisualID vid)
+find_mesa_visual(__GLXscreen *screen, XID fbconfigID)
 {
     __GLXMESAscreen *mesaScreen = (__GLXMESAscreen *) screen;
     const __GLcontextModes *modes;
     unsigned i = 0;
 
-    for ( modes = screen->modes ; modes != NULL ; modes = modes->next ) {
+    for (modes = screen->fbconfigs; modes != NULL; modes = modes->next) {
-	if ( modes->visualID == vid ) {
+ 	if (modes->fbconfigID == fbconfigID)
-	    break;
+	    return mesaScreen->xm_vis[i];
-	}
-
 	i++;
     }
 
-    return (modes != NULL) ? mesaScreen->xm_vis[i] : NULL;
+    return NULL;
 }
 
-static void init_screen_visuals(__GLXMESAscreen *screen)
+const static int numBack = 2;
+const static int numDepth = 2;
+const static int numStencil = 2;
+
+static __GLcontextModes *
+createFBConfigsForVisual(__GLXscreen *screen, ScreenPtr pScreen,
+			 VisualPtr visual, __GLcontextModes *config)
 {
-    ScreenPtr pScreen = screen->base.pScreen;
+    int back, depth, stencil;
-    __GLcontextModes *modes;
-    XMesaVisual *pXMesaVisual;
-    int *used;
-    int i, j, size;
 
-    /* Alloc space for the list of XMesa visuals */
+    /* FIXME: Ok, I'm making all this up... anybody has a better idea? */
-    size = screen->base.numVisuals * sizeof(XMesaVisual);
-    pXMesaVisual = (XMesaVisual *) xalloc(size);
-    memset(pXMesaVisual, 0, size);
 
-    /* FIXME: Change 'used' to be a array of bits (rather than of ints),
+    for (back = numBack - 1; back >= 0; back--)
-     * FIXME: create a stack array of 8 or 16 bytes.  If 'numVisuals' is less
+	for (depth = 0; depth < numDepth; depth++)
-     * FIXME: than 64 or 128 the stack array can be used instead of calling
+	    for (stencil = 0; stencil < numStencil; stencil++) {
-     * FIXME: __glXMalloc / __glXFree.  If nothing else, convert 'used' to
+		config->visualType = _gl_convert_from_x_visual_type(visual->class);
-     * FIXME: array of bytes instead of ints!
+		config->xRenderable = GL_TRUE;
-     */
+		config->drawableType = GLX_WINDOW_BIT | GLX_PIXMAP_BIT;
-    used = (int *) xalloc(pScreen->numVisuals * sizeof(int));
+		config->rgbMode = (visual->class >= TrueColor);
-    memset(used, 0, pScreen->numVisuals * sizeof(int));
+		config->colorIndexMode = !config->rgbMode;
+		config->renderType =
+		    (config->rgbMode) ? GLX_RGBA_BIT : GLX_COLOR_INDEX_BIT;
+		config->doubleBufferMode = back;
+		config->haveDepthBuffer = depth;
+		config->depthBits = depth ? visual->nplanes : 0;
+		config->haveStencilBuffer = stencil;
+		config->stencilBits = stencil ? visual->bitsPerRGBValue : 0;
+		config->haveAccumBuffer = 0;
+
+		config->redBits = Ones(visual->redMask);
+		config->greenBits = Ones(visual->greenMask);
+		config->blueBits = Ones(visual->blueMask);
+		config->alphaBits = 0;
+		config->redMask = visual->redMask;
+		config->greenMask = visual->greenMask;
+		config->blueMask = visual->blueMask;
+		config->alphaMask = 0;
+		config->rgbBits = config->rgbMode ? visual->nplanes : 0;
+		config->indexBits = config->colorIndexMode ? visual->nplanes : 0;
+		config = config->next;
+	    }
+
+    return config;
+}
+
+static void
+createFBConfigs(__GLXscreen *pGlxScreen, ScreenPtr pScreen)
+{
+    __GLcontextModes *configs;
+    int i;
+
+    /* We assume here that each existing visual correspond to a
+     * different visual class.  Note, this runs before COMPOSITE adds
+     * its visual, so it's not entirely crazy. */
+    pGlxScreen->numFBConfigs = pScreen->numVisuals * numBack * numDepth * numStencil;
+    pGlxScreen->fbconfigs = _gl_context_modes_create(pGlxScreen->numFBConfigs,
+						     sizeof *configs);
+
+    configs = pGlxScreen->fbconfigs;
+    for (i = 0; i < pScreen->numVisuals; i++)
+	configs = createFBConfigsForVisual(pGlxScreen, pScreen,
+					   &pScreen->visuals[i], configs);
+}
+
+static void
+createMesaVisuals(__GLXMESAscreen *pMesaScreen)
+{
+    __GLcontextModes *config;
+    ScreenPtr pScreen;
+    VisualPtr visual = NULL;
+    int i, j;
 
     i = 0;
-    for ( modes = screen->base.modes; modes != NULL; modes = modes->next ) {
+    pScreen = pMesaScreen->base.pScreen;
-	const int vis_class = _gl_convert_to_x_visual_type( modes->visualType );
+    pMesaScreen->xm_vis =
-	const int nplanes = (modes->rgbBits - modes->alphaBits);
+	xcalloc(pMesaScreen->base.numFBConfigs, sizeof (XMesaVisual));
-	const VisualPtr pVis = pScreen->visuals;
+    for (config = pMesaScreen->base.fbconfigs; config != NULL; config = config->next) {
-
+	for (j = 0; j < pScreen->numVisuals; j++)
-	for (j = 0; j < pScreen->numVisuals; j++) {
+	    if (pScreen->visuals[j].vid == config->visualID) {
-	    if (pVis[j].class     == vis_class &&
+		visual = &pScreen->visuals[j];
-		pVis[j].nplanes   == nplanes &&
-		pVis[j].redMask   == modes->redMask &&
-		pVis[j].greenMask == modes->greenMask &&
-		pVis[j].blueMask  == modes->blueMask &&
-		!used[j]) {
-
-		/* Create the XMesa visual */
-		pXMesaVisual[i] =
-		    XMesaCreateVisual(pScreen,
-				      &pVis[j],
-				      modes->rgbMode,
-				      (modes->alphaBits > 0),
-				      modes->doubleBufferMode,
-				      modes->stereoMode,
-				      GL_TRUE, /* ximage_flag */
-				      modes->depthBits,
-				      modes->stencilBits,
-				      modes->accumRedBits,
-				      modes->accumGreenBits,
-				      modes->accumBlueBits,
-				      modes->accumAlphaBits,
-				      modes->samples,
-				      modes->level,
-				      modes->visualRating);
-		/* Set the VisualID */
-		modes->visualID = pVis[j].vid;
-
-		/* Mark this visual used */
-		used[j] = 1;
 		break;
 	    }
-	}
 
-	if ( j == pScreen->numVisuals ) {
+	pMesaScreen->xm_vis[i++] =
-	    ErrorF("No matching visual for __GLcontextMode with "
+	    XMesaCreateVisual(pScreen,
-		   "visual class = %d (%d), nplanes = %u\n",
+			      visual,
-		   vis_class, 
+			      config->rgbMode,
-		   modes->visualType,
+			      (config->alphaBits > 0),
-		   (modes->rgbBits - modes->alphaBits) );
+			      config->doubleBufferMode,
-	}
+			      config->stereoMode,
-	else if ( modes->visualID == -1 ) {
+			      GL_TRUE, /* ximage_flag */
-	    FatalError( "Matching visual found, but visualID still -1!\n" );
+			      config->depthBits,
-	}
+			      config->stencilBits,
-
+			      config->accumRedBits,
-	i++;
+			      config->accumGreenBits,
+			      config->accumBlueBits,
+			      config->accumAlphaBits,
+			      config->samples,
+			      config->level,
+			      config->visualRating);
     }
-
-    xfree(used);
-
-    screen->num_vis = pScreen->numVisuals;
-    screen->xm_vis = pXMesaVisual;
 }
 
 static __GLXscreen *
@@ -382,19 +406,22 @@ __glXMesaScreenProbe(ScreenPtr pScreen)
     if (screen == NULL)
 	return NULL;
 
+    /*
+     * Find the GLX visuals that are supported by this screen and create
+     * XMesa's visuals.
+     */
+    createFBConfigs(&screen->base, pScreen);
+
     __glXScreenInit(&screen->base, pScreen);
 
+    /* Now that GLX has created the corresponding X visual, create the mesa visuals. */
+    createMesaVisuals(screen);
+
     screen->base.destroy        = __glXMesaScreenDestroy;
     screen->base.createContext  = __glXMesaScreenCreateContext;
     screen->base.createDrawable = __glXMesaScreenCreateDrawable;
     screen->base.pScreen       = pScreen;
 
-    /*
-     * Find the GLX visuals that are supported by this screen and create
-     * XMesa's visuals.
-     */
-    init_screen_visuals(screen);
-
     return &screen->base;
 }
 

GL/glx/glxscreens.c

@@ -40,10 +40,14 @@
 #include <string.h>
 #include <windowstr.h>
 #include <os.h>
+#include <colormapst.h>
 
 #include "glxserver.h"
 #include "glxutil.h"
 #include "glxext.h"
+#include "glcontextmodes.h"
+
+static int glxScreenPrivateIndex;
 
 const char GLServerVersion[] = "1.4";
 static const char GLServerExtensions[] = 
@@ -179,36 +183,24 @@ static char GLXServerExtensions[] =
 			"GLX_MESA_copy_sub_buffer "
 			;
 
-__GLXscreen **__glXActiveScreens;
-
-__GLXSwapBarrierExtensionFuncs *__glXSwapBarrierFuncs = NULL;
-static int __glXNumSwapBarrierFuncs = 0;
-__GLXHyperpipeExtensionFuncs *__glXHyperpipeFuncs = NULL;
-static int __glXNumHyperpipeFuncs = 0;
-
-__GLXscreen *__glXgetActiveScreen(int num) {
-	return __glXActiveScreens[num];
-}
-
-
 /*
 ** This hook gets called when a window moves or changes size.
 */
-static Bool PositionWindow(WindowPtr pWin, int x, int y)
+static Bool glxPositionWindow(WindowPtr pWin, int x, int y)
 {
     ScreenPtr pScreen;
-    __GLXcontext *glxc;
     __GLXdrawable *glxPriv;
     Bool ret;
+    __GLXscreen *pGlxScreen;
 
     /*
     ** Call wrapped position window routine
     */
     pScreen = pWin->drawable.pScreen;
-    pScreen->PositionWindow =
+    pGlxScreen = glxGetScreen(pScreen);
-	__glXActiveScreens[pScreen->myNum]->WrappedPositionWindow;
+    pScreen->PositionWindow = pGlxScreen->PositionWindow;
     ret = (*pScreen->PositionWindow)(pWin, x, y);
-    pScreen->PositionWindow = PositionWindow;
+    pScreen->PositionWindow = glxPositionWindow;
 
     /*
     ** Tell all contexts rendering into this window that the window size
@@ -233,16 +225,6 @@ static Bool PositionWindow(WindowPtr pWin, int x, int y)
 	ret = False;
     }
 
-    /* mark contexts as needing resize */
-
-    for (glxc = glxPriv->drawGlxc; glxc; glxc = glxc->nextDrawPriv) {
-	glxc->pendingState |= __GLX_PENDING_RESIZE;
-    }
-
-    for (glxc = glxPriv->readGlxc; glxc; glxc = glxc->nextReadPriv) {
-	glxc->pendingState |= __GLX_PENDING_RESIZE;
-    }
-
     return ret;
 }
 
@@ -259,110 +241,320 @@ static Bool PositionWindow(WindowPtr pWin, int x, int y)
 
 void __glXHyperpipeInit(int screen, __GLXHyperpipeExtensionFuncs *funcs)
 {
-    if (__glXNumHyperpipeFuncs < screen + 1) {
+    __GLXscreen *pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
-        __glXHyperpipeFuncs = xrealloc(__glXHyperpipeFuncs,
-                                           (screen+1) * sizeof(__GLXHyperpipeExtensionFuncs));
-        __glXNumHyperpipeFuncs = screen + 1;
-    }
 
-    __glXHyperpipeFuncs[screen].queryHyperpipeNetworkFunc =
+    pGlxScreen->hyperpipeFuncs = funcs;
-        *funcs->queryHyperpipeNetworkFunc;
-    __glXHyperpipeFuncs[screen].queryHyperpipeConfigFunc =
-        *funcs->queryHyperpipeConfigFunc;
-    __glXHyperpipeFuncs[screen].destroyHyperpipeConfigFunc =
-        *funcs->destroyHyperpipeConfigFunc;
-    __glXHyperpipeFuncs[screen].hyperpipeConfigFunc =
-        *funcs->hyperpipeConfigFunc;
 }
 
 void __glXSwapBarrierInit(int screen, __GLXSwapBarrierExtensionFuncs *funcs)
 {
-    if (__glXNumSwapBarrierFuncs < screen + 1) {
+    __GLXscreen *pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
-        __glXSwapBarrierFuncs = xrealloc(__glXSwapBarrierFuncs,
+
-                                           (screen+1) * sizeof(__GLXSwapBarrierExtensionFuncs));
+    pGlxScreen->swapBarrierFuncs = funcs;
-        __glXNumSwapBarrierFuncs = screen + 1;
+}
+
+static Bool
+glxCloseScreen (int index, ScreenPtr pScreen)
+{
+    __GLXscreen *pGlxScreen = glxGetScreen(pScreen);
+
+    pScreen->CloseScreen = pGlxScreen->CloseScreen;
+    pScreen->PositionWindow = pGlxScreen->PositionWindow;
+
+    pGlxScreen->destroy(pGlxScreen);
+
+    return pScreen->CloseScreen(index, pScreen);
+}
+
+__GLXscreen *
+glxGetScreen(ScreenPtr pScreen)
+{
+    return (__GLXscreen *) pScreen->devPrivates[glxScreenPrivateIndex].ptr;
+}
+
+void GlxSetVisualConfigs(int nconfigs, 
+                         __GLXvisualConfig *configs, void **privates)
+{
+    /* We keep this stub around for the DDX drivers that still
+     * call it. */
+}
+
+static XID
+findVisualForConfig(ScreenPtr pScreen, __GLcontextModes *m)
+{
+    int i;
+
+    for (i = 0; i < pScreen->numVisuals; i++) {
+	if (_gl_convert_to_x_visual_type(m->visualType) == pScreen->visuals[i].class)
+	    return pScreen->visuals[i].vid;
     }
 
-    __glXSwapBarrierFuncs[screen].bindSwapBarrierFunc =
+    return 0;
-        funcs->bindSwapBarrierFunc;
-    __glXSwapBarrierFuncs[screen].queryMaxSwapBarriersFunc =
-        funcs->queryMaxSwapBarriersFunc;
 }
 
-static __GLXprovider *__glXProviderStack;
+/* This code inspired by composite/compinit.c.  We could move this to
+ * mi/ and share it with composite.*/
 
-void GlxPushProvider(__GLXprovider *provider)
+static VisualPtr
+AddScreenVisuals(ScreenPtr pScreen, int count, int d)
 {
-    provider->next = __glXProviderStack;
+    XID		*installedCmaps, *vids, vid;
-    __glXProviderStack = provider;
+    int		 numInstalledCmaps, numVisuals, i, j;
+    VisualPtr	 visuals;
+    ColormapPtr	 installedCmap;
+    DepthPtr	 depth;
+
+    depth = NULL;
+    for (i = 0; i < pScreen->numDepths; i++) {
+	if (pScreen->allowedDepths[i].depth == d) {
+	    depth = &pScreen->allowedDepths[i];
+	    break;
+	}
+    }
+    if (depth == NULL)
+	return NULL;
+
+    /* Find the installed colormaps */
+    installedCmaps = xalloc (pScreen->maxInstalledCmaps * sizeof (XID));
+    if (!installedCmaps)
+	return NULL;
+
+    numInstalledCmaps = pScreen->ListInstalledColormaps(pScreen, installedCmaps);
+
+    /* realloc the visual array to fit the new one in place */
+    numVisuals = pScreen->numVisuals;
+    visuals = xrealloc(pScreen->visuals, (numVisuals + count) * sizeof(VisualRec));
+    if (!visuals) {
+	xfree(installedCmaps);
+	return NULL;
+    }
+
+    vids = xrealloc(depth->vids, (depth->numVids + count) * sizeof(XID));
+    if (vids == NULL) {
+	xfree(installedCmaps);
+	xfree(visuals);
+	return NULL;
+    }
+
+    /*
+     * Fix up any existing installed colormaps -- we'll assume that
+     * the only ones created so far have been installed.  If this
+     * isn't true, we'll have to walk the resource database looking
+     * for all colormaps.
+     */
+    for (i = 0; i < numInstalledCmaps; i++) {
+	installedCmap = LookupIDByType (installedCmaps[i], RT_COLORMAP);
+	if (!installedCmap)
+	    continue;
+	j = installedCmap->pVisual - pScreen->visuals;
+	installedCmap->pVisual = &visuals[j];
+    }
+
+    xfree(installedCmaps);
+
+    for (i = 0; i < count; i++) {
+	vid = FakeClientID(0);
+	visuals[pScreen->numVisuals + i].vid = vid;
+	vids[depth->numVids + i] = vid;
+    }
+
+    pScreen->visuals = visuals;
+    pScreen->numVisuals += count;
+    depth->vids = vids;
+    depth->numVids += count;
+
+    /* Return a pointer to the first of the added visuals. */ 
+    return pScreen->visuals + pScreen->numVisuals - count;
 }
 
-void __glXScreenInit(__GLXscreen *screen, ScreenPtr pScreen)
+static int
+findFirstSet(unsigned int v)
 {
-    screen->pScreen       = pScreen;
+    int i;
-    screen->GLextensions  = xstrdup(GLServerExtensions);
-    screen->GLXvendor     = xstrdup(GLXServerVendorName);
-    screen->GLXversion    = xstrdup(GLXServerVersion);
-    screen->GLXextensions = xstrdup(GLXServerExtensions);
 
-    screen->WrappedPositionWindow = pScreen->PositionWindow;
+    for (i = 0; i < 32; i++)
-    pScreen->PositionWindow = PositionWindow;
+	if (v & (1 << i))
+	    return i;
 
-    __glXScreenInitVisuals(screen);
+    return -1;
 }
 
-void
+static void
-__glXScreenDestroy(__GLXscreen *screen)
+initGlxVisual(VisualPtr visual, __GLcontextModes *config)
+{
+    config->visualID = visual->vid;
+    visual->class = _gl_convert_to_x_visual_type(config->visualType);
+    visual->bitsPerRGBValue = config->redBits;
+    visual->ColormapEntries = 1 << config->redBits;
+    visual->nplanes = config->redBits + config->greenBits + config->blueBits;
+
+    visual->redMask = config->redMask;
+    visual->greenMask = config->greenMask;
+    visual->blueMask = config->blueMask;
+    visual->offsetRed = findFirstSet(config->redMask);
+    visual->offsetGreen = findFirstSet(config->greenMask);
+    visual->offsetBlue = findFirstSet(config->blueMask);
+}
+
+typedef struct {
+    GLboolean doubleBuffer;
+    GLboolean depthBuffer;
+} FBConfigTemplateRec, *FBConfigTemplatePtr;
+
+static __GLcontextModes *
+pickFBConfig(__GLXscreen *pGlxScreen, FBConfigTemplatePtr template, int class)
+{
+    __GLcontextModes *config;
+
+    for (config = pGlxScreen->fbconfigs; config != NULL; config = config->next) {
+	if (config->visualRating != GLX_NONE)
+	    continue;
+	if (_gl_convert_to_x_visual_type(config->visualType) != class)
+	    continue;
+	if ((config->doubleBufferMode > 0) != template->doubleBuffer)
+	    continue;
+	if ((config->depthBits > 0) != template->depthBuffer)
+	    continue;
+
+	return config;
+    }
+
+    return NULL;
+}
+
+static void
+addMinimalSet(__GLXscreen *pGlxScreen)
+{
+    __GLcontextModes *config;
+    VisualPtr visuals;
+    int i;
+    FBConfigTemplateRec best = { GL_TRUE, GL_TRUE };
+    FBConfigTemplateRec minimal = { GL_FALSE, GL_FALSE };
+
+    pGlxScreen->visuals = xcalloc(pGlxScreen->pScreen->numVisuals,
+				  sizeof (__GLcontextModes *));
+    if (pGlxScreen->visuals == NULL) {
+	ErrorF("Failed to allocate for minimal set of GLX visuals\n");
+	return;
+    }
+
+    pGlxScreen->numVisuals = pGlxScreen->pScreen->numVisuals;
+    visuals = pGlxScreen->pScreen->visuals;
+    for (i = 0; i < pGlxScreen->numVisuals; i++) {
+	if (visuals[i].nplanes == 32)
+	    config = pickFBConfig(pGlxScreen, &minimal, visuals[i].class);
+	else
+	    config = pickFBConfig(pGlxScreen, &best, visuals[i].class);
+	if (config == NULL)
+	    config = pGlxScreen->fbconfigs;
+	pGlxScreen->visuals[i] = config;
+	config->visualID = visuals[i].vid;
+    }
+
+}
+
+static void
+addTypicalSet(__GLXscreen *pGlxScreen)
+{
+    addMinimalSet(pGlxScreen);
+}
+
+static void
+addFullSet(__GLXscreen *pGlxScreen)
+{
+    __GLcontextModes *config;
+    VisualPtr visuals;
+    int i, depth;
+
+    pGlxScreen->visuals =
+	xcalloc(pGlxScreen->numFBConfigs, sizeof (__GLcontextModes *));
+    if (pGlxScreen->visuals == NULL) {
+	ErrorF("Failed to allocate for full set of GLX visuals\n");
+	return;
+    }
+
+    config = pGlxScreen->fbconfigs;
+    depth = config->redBits + config->greenBits + config->blueBits;
+    visuals = AddScreenVisuals(pGlxScreen->pScreen, pGlxScreen->numFBConfigs, depth);
+    if (visuals == NULL) {
+	xfree(pGlxScreen->visuals);
+	return;
+    }
+
+    pGlxScreen->numVisuals = pGlxScreen->numFBConfigs;
+    for (i = 0, config = pGlxScreen->fbconfigs; config; config = config->next, i++) {
+	pGlxScreen->visuals[i] = config;
+	initGlxVisual(&visuals[i], config);
+    }
+}
+
+static int glxVisualConfig = GLX_ALL_VISUALS;
+
+void GlxSetVisualConfig(int config)
+{
+    glxVisualConfig = config;
+}
+
+void __glXScreenInit(__GLXscreen *pGlxScreen, ScreenPtr pScreen)
+{
+    static int glxGeneration;
+    __GLcontextModes *m;
+    int i;
+
+    if (glxGeneration != serverGeneration)
+    {
+	glxScreenPrivateIndex = AllocateScreenPrivateIndex ();
+	if (glxScreenPrivateIndex == -1)
+	    return;
+
+	glxGeneration = serverGeneration;
+    }
+
+    pGlxScreen->pScreen       = pScreen;
+    pGlxScreen->GLextensions  = xstrdup(GLServerExtensions);
+    pGlxScreen->GLXvendor     = xstrdup(GLXServerVendorName);
+    pGlxScreen->GLXversion    = xstrdup(GLXServerVersion);
+    pGlxScreen->GLXextensions = xstrdup(GLXServerExtensions);
+
+    pGlxScreen->PositionWindow = pScreen->PositionWindow;
+    pScreen->PositionWindow = glxPositionWindow;
+ 
+    pGlxScreen->CloseScreen = pScreen->CloseScreen;
+    pScreen->CloseScreen = glxCloseScreen;
+
+    i = 0;
+    for (m = pGlxScreen->fbconfigs; m != NULL; m = m->next) {
+	m->fbconfigID = FakeClientID(0);
+	m->visualID = findVisualForConfig(pScreen, m);
+	i++;
+    }
+    pGlxScreen->numFBConfigs = i;
+
+    /* Select a subset of fbconfigs that we send to the client when it
+     * asks for the glx visuals.  All the fbconfigs here have a valid
+     * value for visual ID and each visual ID is only present once.
+     * This runs before composite adds its extra visual so we have to
+     * remember the number of visuals here.*/
+
+    switch (glxVisualConfig) {
+    case GLX_MINIMAL_VISUALS:
+	addMinimalSet(pGlxScreen);
+	break;
+    case GLX_TYPICAL_VISUALS:
+	addTypicalSet(pGlxScreen);
+	break;
+    case GLX_ALL_VISUALS:
+	addFullSet(pGlxScreen);
+	break;
+    }
+
+    pScreen->devPrivates[glxScreenPrivateIndex].ptr = (pointer) pGlxScreen;
+}
+ 
+void __glXScreenDestroy(__GLXscreen *screen)
 {
     xfree(screen->GLXvendor);
     xfree(screen->GLXversion);
     xfree(screen->GLXextensions);
     xfree(screen->GLextensions);
 }
-
-void __glXInitScreens(void)
-{
-    GLint i;
-    ScreenPtr pScreen;
-    __GLXprovider *p;
-    size_t size;
-
-    /*
-    ** This alloc has to work or else the server might as well core dump.
-    */
-    size = screenInfo.numScreens * sizeof(__GLXscreen *);
-    __glXActiveScreens = xalloc(size);
-    memset(__glXActiveScreens, 0, size);
-    
-    for (i = 0; i < screenInfo.numScreens; i++) {
-	pScreen = screenInfo.screens[i];
-
-	for (p = __glXProviderStack; p != NULL; p = p->next) {
-	    __glXActiveScreens[i] = p->screenProbe(pScreen);
-	    if (__glXActiveScreens[i] != NULL) {
-		LogMessage(X_INFO,
-			   "GLX: Initialized %s GL provider for screen %d\n",
-			   p->name, i);
-	        break;
-	    }
-	}
-    }
-}
-
-void __glXResetScreens(void)
-{
-  int i;
-
-  for (i = 0; i < screenInfo.numScreens; i++)
-      if (__glXActiveScreens[i])
-	  __glXActiveScreens[i]->destroy(__glXActiveScreens[i]);
-
-    xfree(__glXActiveScreens);
-    xfree(__glXHyperpipeFuncs);
-    xfree(__glXSwapBarrierFuncs);
-    __glXNumHyperpipeFuncs = 0;
-    __glXNumSwapBarrierFuncs = 0;
-    __glXHyperpipeFuncs = NULL;
-    __glXSwapBarrierFuncs = NULL;
-    __glXActiveScreens = NULL;
-}

GL/glx/glxscreens.h

@@ -42,6 +42,21 @@
 
 #include "GL/internal/glcore.h"
 
+typedef struct {
+    void * (* queryHyperpipeNetworkFunc)(int, int *, int *);
+    void * (* queryHyperpipeConfigFunc)(int, int, int *, int *);
+    int    (* destroyHyperpipeConfigFunc)(int, int);
+    void * (* hyperpipeConfigFunc)(int, int, int *, int *, void *);
+} __GLXHyperpipeExtensionFuncs;
+
+typedef struct {
+    int    (* bindSwapBarrierFunc)(int, XID, int);
+    int    (* queryMaxSwapBarriersFunc)(int);
+} __GLXSwapBarrierExtensionFuncs;
+
+void __glXHyperpipeInit(int screen, __GLXHyperpipeExtensionFuncs *funcs);
+void __glXSwapBarrierInit(int screen, __GLXSwapBarrierExtensionFuncs *funcs);
+
 /*
 ** Screen dependent data.  These methods are the interface between the DIX
 ** and DDX layers of the GLX server extension.  The methods provide an
@@ -57,21 +72,24 @@ struct __GLXscreen {
 
     __GLXdrawable *(*createDrawable)(__GLXscreen *context,
 				     DrawablePtr pDraw,
+				     int type,
 				     XID drawId,
 				     __GLcontextModes *modes);
     int            (*swapInterval)  (__GLXdrawable *drawable,
 				     int interval);
 
+    __GLXHyperpipeExtensionFuncs *hyperpipeFuncs;
+    __GLXSwapBarrierExtensionFuncs *swapBarrierFuncs;
+
     ScreenPtr pScreen;
 
-    /**
+    /* Linked list of valid fbconfigs for this screen. */
-     * Linked list of valid context modes for this screen.
+    __GLcontextModes *fbconfigs;
-     */
+    int numFBConfigs;
-    __GLcontextModes *modes;
 
-    void **pVisualPriv;
+    /* Subset of fbconfigs that are exposed as GLX visuals. */
+    __GLcontextModes **visuals;
     GLint numVisuals;
-    GLint numUsableVisuals;
 
     char *GLextensions;
 
@@ -79,18 +97,12 @@ struct __GLXscreen {
     char *GLXversion;
     char *GLXextensions;
 
-    /*
+    Bool (*PositionWindow)(WindowPtr pWin, int x, int y);
-    ** Things that are not statically set.
+    Bool (*CloseScreen)(int index, ScreenPtr pScreen);
-    */
-    Bool (*WrappedPositionWindow)(WindowPtr pWin, int x, int y);
-
 };
 
 
 void __glXScreenInit(__GLXscreen *screen, ScreenPtr pScreen);
 void __glXScreenDestroy(__GLXscreen *screen);
 
-void __glXInitScreens(void);
-extern void __glXResetScreens(void);
-
 #endif /* !__GLX_screens_h__ */

GL/glx/glxserver.h

@@ -90,12 +90,13 @@ typedef XID GLXDrawable;
 
 typedef struct __GLXclientStateRec __GLXclientState;
 
-extern __GLXscreen **__glXActiveScreens;
+extern __GLXscreen *glxGetScreen(ScreenPtr pScreen);
-extern GLint __glXNumActiveScreens;
+extern __GLXclientState *glxGetClient(ClientPtr pClient);
-extern __GLXscreen *__glXgetActiveScreen(int num);
 
 /************************************************************************/
 
+void GlxExtensionInit(void);
+
 void GlxSetVisualConfigs(int nconfigs, 
                          __GLXvisualConfig *configs, void **privates);
 
@@ -133,6 +134,14 @@ struct __GLXprovider {
 
 void GlxPushProvider(__GLXprovider *provider);
 
+enum {
+    GLX_MINIMAL_VISUALS,
+    GLX_TYPICAL_VISUALS,
+    GLX_ALL_VISUALS
+};
+
+void GlxSetVisualConfig(int config);
+
 void __glXsetEnterLeaveServerFuncs(void (*enter)(GLboolean),
 				   void (*leave)(GLboolean));
 void __glXenterServer(GLboolean rendering);

GL/glx/glxutil.c

@@ -139,18 +139,15 @@ __glXUnrefDrawable(__GLXdrawable *glxPriv)
 
 GLboolean
 __glXDrawableInit(__GLXdrawable *drawable,
-		  __GLXscreen *screen, DrawablePtr pDraw, XID drawId,
+		  __GLXscreen *screen, DrawablePtr pDraw, int type,
-		  __GLcontextModes *modes)
+		  XID drawId, __GLcontextModes *modes)
 {
-    drawable->type = pDraw->type;
     drawable->pDraw = pDraw;
+    drawable->type = type;
     drawable->drawId = drawId;
     drawable->refCount = 1;
     drawable->modes = modes;
-
+    drawable->eventMask = 0;
-    /* if not a pixmap, lookup will fail, so pGlxPixmap will be NULL */
-    drawable->pGlxPixmap = (__GLXpixmap *) 
-	LookupIDByType(drawId, __glXPixmapRes);
 
     return GL_TRUE;
 }

GL/glx/glxutil.h

@@ -50,7 +50,7 @@ extern void __glXUnrefDrawable(__GLXdrawable *glxPriv);
 
 extern GLboolean __glXDrawableInit(__GLXdrawable *drawable,
 				   __GLXscreen *screen,
-				   DrawablePtr pDraw, XID drawID,
+				   DrawablePtr pDraw, int type, XID drawID,
 				   __GLcontextModes *modes);
 
 /* context helper routines */

GL/glx/glxvisuals.c

@@ -1,518 +0,0 @@
-/*
- * Copyright © 2006  Red Hat, Inc.
- * (C) Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
- * 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, sub license,
- * 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 (including the next
- * paragraph) 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 NON-INFRINGEMENT.  IN NO EVENT SHALL
- * RED HAT, INC, OR PRECISION INSIGHT AND/OR THEIR SUPPLIERS 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.
- */
-
-/*
- * Authors:
- *   Kevin E. Martin <kevin@precisioninsight.com>
- *   Brian Paul <brian@precisioninsight.com>
- *   Kristian Høgsberg <krh@redhat.com>
- *
- */
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include <assert.h>
-#include <string.h>
-#include <regionstr.h>
-#include <resource.h>
-#include <GL/gl.h>
-#include <GL/glxint.h>
-#include <GL/glxtokens.h>
-#include <GL/internal/glcore.h>
-#include <scrnintstr.h>
-#include <config.h>
-#include <glxserver.h>
-#include <glxscreens.h>
-#include <glxdrawable.h>
-#include <glxcontext.h>
-#include <glxext.h>
-#include <glxutil.h>
-#include <micmap.h>
-
-void GlxWrapInitVisuals(miInitVisualsProcPtr *);
-
-#include "glcontextmodes.h"
-
-struct ScreenVisualsRec {
-    int num_vis;
-    void *private;
-    __GLcontextModes *modes;
-};
-typedef struct ScreenVisualsRec ScreenVisuals;
-
-static ScreenVisuals screenVisuals[MAXSCREENS];
-
-static int                 numConfigs     = 0;
-static __GLXvisualConfig  *visualConfigs  = NULL;
-static void              **visualPrivates = NULL;
-
-static int count_bits(unsigned int n)
-{
-   int bits = 0;
-
-   while (n > 0) {
-      if (n & 1) bits++;
-      n >>= 1;
-   }
-   return bits;
-}
-
-/*
- * In the case the driver defines no GLX visuals we'll use these.
- * Note that for TrueColor and DirectColor visuals, bufferSize is the 
- * sum of redSize, greenSize, blueSize and alphaSize, which may be larger 
- * than the nplanes/rootDepth of the server's X11 visuals
- */
-#define NUM_FALLBACK_CONFIGS 5
-static __GLXvisualConfig FallbackConfigs[NUM_FALLBACK_CONFIGS] = {
-  /* [0] = RGB, double buffered, Z */
-  {
-    -1,                 /* vid */
-    -1,                 /* class */
-    True,               /* rgba */
-    -1, -1, -1, 0,      /* rgba sizes */
-    -1, -1, -1, 0,      /* rgba masks */
-     0,  0,  0, 0,      /* rgba accum sizes */
-    True,               /* doubleBuffer */
-    False,              /* stereo */
-    -1,                 /* bufferSize */
-    16,                 /* depthSize */
-    0,                  /* stencilSize */
-    0,                  /* auxBuffers */
-    0,                  /* level */
-    GLX_NONE,           /* visualRating */
-    GLX_NONE,           /* transparentPixel */
-    0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
-    0                   /* transparentIndex */
-  },
-  /* [1] = RGB, double buffered, Z, stencil, accum */
-  {
-    -1,                 /* vid */
-    -1,                 /* class */
-    True,               /* rgba */
-    -1, -1, -1, 0,      /* rgba sizes */
-    -1, -1, -1, 0,      /* rgba masks */
-    16, 16, 16, 0,      /* rgba accum sizes */
-    True,               /* doubleBuffer */
-    False,              /* stereo */
-    -1,                 /* bufferSize */
-    16,                 /* depthSize */
-    8,                  /* stencilSize */
-    0,                  /* auxBuffers */
-    0,                  /* level */
-    GLX_NONE,           /* visualRating */
-    GLX_NONE,           /* transparentPixel */
-    0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
-    0                   /* transparentIndex */
-  },
-  /* [2] = RGB+Alpha, double buffered, Z, stencil, accum */
-  {
-    -1,                 /* vid */
-    -1,                 /* class */
-    True,               /* rgba */
-    -1, -1, -1, 8,      /* rgba sizes */
-    -1, -1, -1, -1,     /* rgba masks */
-    16, 16, 16, 16,     /* rgba accum sizes */
-    True,               /* doubleBuffer */
-    False,              /* stereo */
-    -1,                 /* bufferSize */
-    16,                 /* depthSize */
-    8,                  /* stencilSize */
-    0,                  /* auxBuffers */
-    0,                  /* level */
-    GLX_NONE,           /* visualRating */
-    GLX_NONE,           /* transparentPixel */
-    0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
-    0                   /* transparentIndex */
-  },
-  /* [3] = RGB+Alpha, single buffered, Z, stencil, accum */
-  {
-    -1,                 /* vid */
-    -1,                 /* class */
-    True,               /* rgba */
-    -1, -1, -1, 8,      /* rgba sizes */
-    -1, -1, -1, -1,     /* rgba masks */
-    16, 16, 16, 16,     /* rgba accum sizes */
-    False,              /* doubleBuffer */
-    False,              /* stereo */
-    -1,                 /* bufferSize */
-    16,                 /* depthSize */
-    8,                  /* stencilSize */
-    0,                  /* auxBuffers */
-    0,                  /* level */
-    GLX_NONE,           /* visualRating */
-    GLX_NONE,           /* transparentPixel */
-    0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
-    0                   /* transparentIndex */
-  },
-  /* [4] = CI, double buffered, Z */
-  {
-    -1,                 /* vid */
-    -1,                 /* class */
-    False,              /* rgba? (false = color index) */
-    -1, -1, -1, 0,      /* rgba sizes */
-    -1, -1, -1, 0,      /* rgba masks */
-     0,  0,  0, 0,      /* rgba accum sizes */
-    True,               /* doubleBuffer */
-    False,              /* stereo */
-    -1,                 /* bufferSize */
-    16,                 /* depthSize */
-    0,                  /* stencilSize */
-    0,                  /* auxBuffers */
-    0,                  /* level */
-    GLX_NONE,           /* visualRating */
-    GLX_NONE,           /* transparentPixel */
-    0, 0, 0, 0,         /* transparent rgba color (floats scaled to ints) */
-    0                   /* transparentIndex */
-  },
-};
-
-
-static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
-			 VisualID *defaultVisp,
-			 int ndepth, DepthPtr pdepth,
-			 int rootDepth)
-{
-    int numRGBconfigs;
-    int numCIconfigs;
-    int numVisuals = *nvisualp;
-    int numNewVisuals;
-    int numNewConfigs;
-    VisualPtr pVisual = *visualp;
-    VisualPtr pVisualNew = NULL;
-    VisualID *orig_vid = NULL;
-    __GLcontextModes *modes;
-    __GLXvisualConfig *pNewVisualConfigs = NULL;
-    void **glXVisualPriv;
-    void **pNewVisualPriv;
-    int found_default;
-    int i, j, k;
-
-    if (numConfigs > 0)
-        numNewConfigs = numConfigs;
-    else
-        numNewConfigs = NUM_FALLBACK_CONFIGS;
-
-    /* Alloc space for the list of new GLX visuals */
-    pNewVisualConfigs = (__GLXvisualConfig *)
-	xalloc(numNewConfigs * sizeof(__GLXvisualConfig));
-    if (!pNewVisualConfigs) {
-	return FALSE;
-    }
-
-    /* Alloc space for the list of new GLX visual privates */
-    pNewVisualPriv = (void **) xalloc(numNewConfigs * sizeof(void *));
-    if (!pNewVisualPriv) {
-	xfree(pNewVisualConfigs);
-	return FALSE;
-    }
-
-    /*
-    ** If SetVisualConfigs was not called, then use default GLX
-    ** visual configs.
-    */
-    if (numConfigs == 0) {
-	memcpy(pNewVisualConfigs, FallbackConfigs,
-               NUM_FALLBACK_CONFIGS * sizeof(__GLXvisualConfig));
-	memset(pNewVisualPriv, 0, NUM_FALLBACK_CONFIGS * sizeof(void *));
-    }
-    else {
-        /* copy driver's visual config info */
-        for (i = 0; i < numConfigs; i++) {
-            pNewVisualConfigs[i] = visualConfigs[i];
-            pNewVisualPriv[i] = visualPrivates[i];
-        }
-    }
-
-    /* Count the number of RGB and CI visual configs */
-    numRGBconfigs = 0;
-    numCIconfigs = 0;
-    for (i = 0; i < numNewConfigs; i++) {
-	if (pNewVisualConfigs[i].rgba)
-	    numRGBconfigs++;
-	else
-	    numCIconfigs++;
-    }
-
-    /* Count the total number of visuals to compute */
-    numNewVisuals = 0;
-    for (i = 0; i < numVisuals; i++) {
-        numNewVisuals +=
-	    (pVisual[i].class == TrueColor || pVisual[i].class == DirectColor)
-	    ? numRGBconfigs : numCIconfigs;
-    }
-
-    /* Reset variables for use with the next screen/driver's visual configs */
-    visualConfigs = NULL;
-    numConfigs = 0;
-
-    /* Alloc temp space for the list of orig VisualIDs for each new visual */
-    orig_vid = (VisualID *) xalloc(numNewVisuals * sizeof(VisualID));
-    if (!orig_vid) {
-	xfree(pNewVisualPriv);
-	xfree(pNewVisualConfigs);
-	return FALSE;
-    }
-
-    /* Alloc space for the list of glXVisuals */
-    modes = _gl_context_modes_create(numNewVisuals, sizeof(__GLcontextModes));
-    if (modes == NULL) {
-	xfree(orig_vid);
-	xfree(pNewVisualPriv);
-	xfree(pNewVisualConfigs);
-	return FALSE;
-    }
-
-    /* Alloc space for the list of glXVisualPrivates */
-    glXVisualPriv = (void **)xalloc(numNewVisuals * sizeof(void *));
-    if (!glXVisualPriv) {
-	_gl_context_modes_destroy( modes );
-	xfree(orig_vid);
-	xfree(pNewVisualPriv);
-	xfree(pNewVisualConfigs);
-	return FALSE;
-    }
-
-    /* Alloc space for the new list of the X server's visuals */
-    pVisualNew = (VisualPtr)xalloc(numNewVisuals * sizeof(VisualRec));
-    if (!pVisualNew) {
-	xfree(glXVisualPriv);
-	_gl_context_modes_destroy( modes );
-	xfree(orig_vid);
-	xfree(pNewVisualPriv);
-	xfree(pNewVisualConfigs);
-	return FALSE;
-    }
-
-    /* Initialize the new visuals */
-    found_default = FALSE;
-    screenVisuals[screenInfo.numScreens-1].modes = modes;
-    for (i = j = 0; i < numVisuals; i++) {
-        int is_rgb = (pVisual[i].class == TrueColor ||
-		      pVisual[i].class == DirectColor);
-
-	for (k = 0; k < numNewConfigs; k++) {
-	    if (pNewVisualConfigs[k].rgba != is_rgb)
-		continue;
-
-	    assert( modes != NULL );
-
-	    /* Initialize the new visual */
-	    pVisualNew[j] = pVisual[i];
-	    pVisualNew[j].vid = FakeClientID(0);
-
-	    /* Check for the default visual */
-	    if (!found_default && pVisual[i].vid == *defaultVisp) {
-		*defaultVisp = pVisualNew[j].vid;
-		found_default = TRUE;
-	    }
-
-	    /* Save the old VisualID */
-	    orig_vid[j] = pVisual[i].vid;
-
-	    /* Initialize the glXVisual */
-	    _gl_copy_visual_to_context_mode( modes, & pNewVisualConfigs[k] );
-	    modes->visualID = pVisualNew[j].vid;
-	    if (modes->fbconfigID == GLX_DONT_CARE)
-		modes->fbconfigID = modes->visualID;
-
-	    /*
-	     * If the class is -1, then assume the X visual information
-	     * is identical to what GLX needs, and take them from the X
-	     * visual.  NOTE: if class != -1, then all other fields MUST
-	     * be initialized.
-	     */
-	    if (modes->visualType == GLX_NONE) {
-		modes->visualType = _gl_convert_from_x_visual_type( pVisual[i].class );
-		modes->redBits    = count_bits(pVisual[i].redMask);
-		modes->greenBits  = count_bits(pVisual[i].greenMask);
-		modes->blueBits   = count_bits(pVisual[i].blueMask);
-		modes->alphaBits  = modes->alphaBits;
-		modes->redMask    = pVisual[i].redMask;
-		modes->greenMask  = pVisual[i].greenMask;
-		modes->blueMask   = pVisual[i].blueMask;
-		modes->alphaMask  = modes->alphaMask;
-		modes->rgbBits = (is_rgb)
-		    ? (modes->redBits + modes->greenBits +
-		       modes->blueBits + modes->alphaBits)
-		    : rootDepth;
-	    }
-
-	    /* Save the device-dependent private for this visual */
-	    glXVisualPriv[j] = pNewVisualPriv[k];
-
-	    j++;
-	    modes = modes->next;
-	}
-    }
-
-    assert(j <= numNewVisuals);
-
-    /* Save the GLX visuals in the screen structure */
-    screenVisuals[screenInfo.numScreens-1].num_vis = numNewVisuals;
-    screenVisuals[screenInfo.numScreens-1].private = glXVisualPriv;
-
-    /* Set up depth's VisualIDs */
-    for (i = 0; i < ndepth; i++) {
-	int numVids = 0;
-	VisualID *pVids = NULL;
-	int k, n = 0;
-
-	/* Count the new number of VisualIDs at this depth */
-	for (j = 0; j < pdepth[i].numVids; j++)
-	    for (k = 0; k < numNewVisuals; k++)
-		if (pdepth[i].vids[j] == orig_vid[k])
-		    numVids++;
-
-	/* Allocate a new list of VisualIDs for this depth */
-	pVids = (VisualID *)xalloc(numVids * sizeof(VisualID));
-
-	/* Initialize the new list of VisualIDs for this depth */
-	for (j = 0; j < pdepth[i].numVids; j++)
-	    for (k = 0; k < numNewVisuals; k++)
-		if (pdepth[i].vids[j] == orig_vid[k])
-		    pVids[n++] = pVisualNew[k].vid;
-
-	/* Update this depth's list of VisualIDs */
-	xfree(pdepth[i].vids);
-	pdepth[i].vids = pVids;
-	pdepth[i].numVids = numVids;
-    }
-
-    /* Update the X server's visuals */
-    *nvisualp = numNewVisuals;
-    *visualp = pVisualNew;
-
-    /* Free the old list of the X server's visuals */
-    xfree(pVisual);
-
-    /* Clean up temporary allocations */
-    xfree(orig_vid);
-    xfree(pNewVisualPriv);
-    xfree(pNewVisualConfigs);
-
-    /* Free the private list created by DDX HW driver */
-    if (visualPrivates)
-        xfree(visualPrivates);
-    visualPrivates = NULL;
-
-    return TRUE;
-}
-
-void GlxSetVisualConfigs(int nconfigs, 
-                         __GLXvisualConfig *configs, void **privates)
-{
-    numConfigs = nconfigs;
-    visualConfigs = configs;
-    visualPrivates = privates;
-}
-
-static miInitVisualsProcPtr saveInitVisualsProc;
-
-Bool GlxInitVisuals(VisualPtr *visualp, DepthPtr *depthp,
-		    int *nvisualp, int *ndepthp,
-		    int *rootDepthp, VisualID *defaultVisp,
-		    unsigned long sizes, int bitsPerRGB,
-		    int preferredVis)
-{
-    Bool ret;
-
-    if (saveInitVisualsProc) {
-        ret = saveInitVisualsProc(visualp, depthp, nvisualp, ndepthp,
-                                  rootDepthp, defaultVisp, sizes, bitsPerRGB,
-                                  preferredVis);
-        if (!ret)
-            return False;
-    }
-
-    /*
-     * Setup the visuals supported by this particular screen.
-     */
-    init_visuals(nvisualp, visualp, defaultVisp,
-		 *ndepthp, *depthp, *rootDepthp);
-
-
-    return True;
-}
-
-
-/************************************************************************/
-
-
-void
-GlxWrapInitVisuals(miInitVisualsProcPtr *initVisProc)
-{
-    saveInitVisualsProc = *initVisProc;
-    *initVisProc = GlxInitVisuals;
-}
-
-static void fixup_visuals(int screen)
-{
-    ScreenPtr pScreen = screenInfo.screens[screen];
-    ScreenVisuals *psv = &screenVisuals[screen];
-    int j;
-    __GLcontextModes *modes;
-
-    for ( modes = psv->modes ; modes != NULL ; modes = modes->next ) {
-	const int vis_class = _gl_convert_to_x_visual_type( modes->visualType );
-	const int nplanes = (modes->rgbBits - modes->alphaBits);
-	const VisualPtr pVis = pScreen->visuals;
-
-	/* Find a visual that matches the GLX visual's class and size */
-	for (j = 0; j < pScreen->numVisuals; j++) {
-	    if (pVis[j].class == vis_class &&
-		pVis[j].nplanes == nplanes) {
-
-		/* Fixup the masks */
-		modes->redMask   = pVis[j].redMask;
-		modes->greenMask = pVis[j].greenMask;
-		modes->blueMask  = pVis[j].blueMask;
-
-		/* Recalc the sizes */
-		modes->redBits   = count_bits(modes->redMask);
-		modes->greenBits = count_bits(modes->greenMask);
-		modes->blueBits  = count_bits(modes->blueMask);
-	    }
-	}
-    }
-}
-
-void __glXScreenInitVisuals(__GLXscreen *screen)
-{
-    int index = screen->pScreen->myNum;
-
-    screen->modes = screenVisuals[index].modes;
-    screen->pVisualPriv = screenVisuals[index].private;
-    screen->numVisuals = screenVisuals[index].num_vis;
-    screen->numUsableVisuals = screenVisuals[index].num_vis;
-
-    /*
-     * The ordering of the rgb compenents might have been changed by the
-     * driver after mi initialized them.
-     */
-    fixup_visuals(index);
-}

GL/glx/indirect_dispatch.h

@@ -207,6 +207,8 @@ extern HIDDEN void __glXDisp_TexCoord2iv(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_TexCoord2iv(GLbyte * pc);
 extern HIDDEN void __glXDisp_CompressedTexImage1DARB(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_CompressedTexImage1DARB(GLbyte * pc);
+extern HIDDEN void __glXDisp_Rotated(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_Rotated(GLbyte * pc);
 extern HIDDEN int __glXDisp_ReadPixels(struct __GLXclientStateRec *, GLbyte *);
 extern HIDDEN int __glXDispSwap_ReadPixels(struct __GLXclientStateRec *, GLbyte *);
 extern HIDDEN void __glXDisp_EdgeFlagv(GLbyte * pc);
@@ -293,8 +295,8 @@ extern HIDDEN void __glXDisp_ClearIndex(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_ClearIndex(GLbyte * pc);
 extern HIDDEN void __glXDisp_LoadMatrixd(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_LoadMatrixd(GLbyte * pc);
-extern HIDDEN void __glXDisp_RasterPos2dv(GLbyte * pc);
+extern HIDDEN void __glXDisp_PushMatrix(GLbyte * pc);
-extern HIDDEN void __glXDispSwap_RasterPos2dv(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_PushMatrix(GLbyte * pc);
 extern HIDDEN void __glXDisp_ConvolutionParameterfv(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_ConvolutionParameterfv(GLbyte * pc);
 extern HIDDEN int __glXDisp_GetTexGendv(struct __GLXclientStateRec *, GLbyte *);
@@ -371,14 +373,16 @@ extern HIDDEN void __glXDisp_ProgramNamedParameter4fvNV(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_ProgramNamedParameter4fvNV(GLbyte * pc);
 extern HIDDEN void __glXDisp_VertexAttrib4fvARB(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_VertexAttrib4fvARB(GLbyte * pc);
+extern HIDDEN int __glXDisp_CreateGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_CreateGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
 extern HIDDEN void __glXDisp_MultiTexCoord1svARB(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_MultiTexCoord1svARB(GLbyte * pc);
 extern HIDDEN void __glXDisp_EndQueryARB(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_EndQueryARB(GLbyte * pc);
 extern HIDDEN void __glXDisp_DepthMask(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_DepthMask(GLbyte * pc);
-extern HIDDEN void __glXDisp_Rotated(GLbyte * pc);
+extern HIDDEN void __glXDisp_Color4iv(GLbyte * pc);
-extern HIDDEN void __glXDispSwap_Rotated(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_Color4iv(GLbyte * pc);
 extern HIDDEN int __glXDisp_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);
 extern HIDDEN int __glXDispSwap_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);
 extern HIDDEN void __glXDisp_StencilOp(GLbyte * pc);
@@ -619,8 +623,8 @@ extern HIDDEN int __glXDisp_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
 extern HIDDEN int __glXDispSwap_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
 extern HIDDEN void __glXDisp_VertexAttrib4usvARB(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_VertexAttrib4usvARB(GLbyte * pc);
-extern HIDDEN void __glXDisp_Color4iv(GLbyte * pc);
+extern HIDDEN int __glXDisp_DestroyGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
-extern HIDDEN void __glXDispSwap_Color4iv(GLbyte * pc);
+extern HIDDEN int __glXDispSwap_DestroyGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
 extern HIDDEN void __glXDisp_EvalCoord2dv(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_EvalCoord2dv(GLbyte * pc);
 extern HIDDEN void __glXDisp_VertexAttrib3svARB(GLbyte * pc);
@@ -669,6 +673,8 @@ extern HIDDEN void __glXDisp_Lighti(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_Lighti(GLbyte * pc);
 extern HIDDEN int __glXDisp_GetFramebufferAttachmentParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
 extern HIDDEN int __glXDispSwap_GetFramebufferAttachmentParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_ChangeDrawableAttributesSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_ChangeDrawableAttributesSGIX(struct __GLXclientStateRec *, GLbyte *);
 extern HIDDEN void __glXDisp_MultiTexCoord4dvARB(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_MultiTexCoord4dvARB(GLbyte * pc);
 extern HIDDEN int __glXDisp_CreatePbuffer(struct __GLXclientStateRec *, GLbyte *);
@@ -751,8 +757,8 @@ extern HIDDEN void __glXDisp_PixelTransferf(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_PixelTransferf(GLbyte * pc);
 extern HIDDEN void __glXDisp_CopyTexImage1D(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_CopyTexImage1D(GLbyte * pc);
-extern HIDDEN void __glXDisp_PushMatrix(GLbyte * pc);
+extern HIDDEN void __glXDisp_RasterPos2dv(GLbyte * pc);
-extern HIDDEN void __glXDispSwap_PushMatrix(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_RasterPos2dv(GLbyte * pc);
 extern HIDDEN void __glXDisp_Fogiv(GLbyte * pc);
 extern HIDDEN void __glXDispSwap_Fogiv(GLbyte * pc);
 extern HIDDEN void __glXDisp_TexCoord1dv(GLbyte * pc);

GL/glx/indirect_size_get.c

@@ -697,6 +697,7 @@ __glGetBooleanv_size(GLenum e)
     case GL_MATRIX_INDEX_ARRAY_SIZE_ARB:
     case GL_MATRIX_INDEX_ARRAY_TYPE_ARB:
     case GL_MATRIX_INDEX_ARRAY_STRIDE_ARB:
+    case GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT:
     case GL_POINT_SPRITE_ARB:
 /*      case GL_POINT_SPRITE_NV:*/
     case GL_POINT_SPRITE_R_MODE_NV:
@@ -704,8 +705,11 @@ __glGetBooleanv_size(GLenum e)
     case GL_MAX_TEXTURE_COORDS_ARB:
     case GL_MAX_TEXTURE_IMAGE_UNITS_ARB:
     case GL_DEPTH_BOUNDS_TEST_EXT:
+    case GL_MAX_ARRAY_TEXTURE_LAYERS_EXT:
     case GL_STENCIL_TEST_TWO_SIDE_EXT:
     case GL_ACTIVE_STENCIL_FACE_EXT:
+    case GL_TEXTURE_BINDING_1D_ARRAY_EXT:
+    case GL_TEXTURE_BINDING_2D_ARRAY_EXT:
     case GL_RASTER_POSITION_UNCLIPPED_IBM:
         return 1;
     case GL_SMOOTH_POINT_SIZE_RANGE:

GL/glx/indirect_table.c

@@ -1575,9 +1575,9 @@ static const void *VendorPriv_function_table[104][2] = {
     /* [ 92] = 65540 */ {__glXDisp_GetFBConfigsSGIX, __glXDispSwap_GetFBConfigsSGIX},
     /* [ 93] = 65541 */ {__glXDisp_CreateContextWithConfigSGIX, __glXDispSwap_CreateContextWithConfigSGIX},
     /* [ 94] = 65542 */ {__glXDisp_CreateGLXPixmapWithConfigSGIX, __glXDispSwap_CreateGLXPixmapWithConfigSGIX},
-    /* [ 95] = 65543 */ {NULL, NULL},
+    /* [ 95] = 65543 */ {__glXDisp_CreateGLXPbufferSGIX, __glXDispSwap_CreateGLXPbufferSGIX},
-    /* [ 96] = 65544 */ {NULL, NULL},
+    /* [ 96] = 65544 */ {__glXDisp_DestroyGLXPbufferSGIX, __glXDispSwap_DestroyGLXPbufferSGIX},
-    /* [ 97] = 65545 */ {NULL, NULL},
+    /* [ 97] = 65545 */ {__glXDisp_ChangeDrawableAttributesSGIX, __glXDispSwap_ChangeDrawableAttributesSGIX},
     /* [ 98] = 65546 */ {__glXDisp_GetDrawableAttributesSGIX, __glXDispSwap_GetDrawableAttributesSGIX},
     /* [ 99] = 65547 */ {NULL, NULL},
     /* [ 100] = 65548 */ {NULL, NULL},

XTrap/xtrapdi.c

@@ -2033,7 +2033,7 @@ static void GetSendColorCellsRep(ClientPtr client, xResourceReq *req)
     }
     nmasks = creq->planes;
     length = ((long)npixels + (long)nmasks) * sizeof(Pixel);
-    data = (XETrapDatum *)ALLOCATE_LOCAL(sizeof(XETrapDatum)+length);
+    data = (XETrapDatum *)xalloc(sizeof(XETrapDatum)+length);
     if (!data)
     {
         SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
@@ -2051,7 +2051,7 @@ static void GetSendColorCellsRep(ClientPtr client, xResourceReq *req)
     {
         SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
             req->reqType, 0L, retval);
-        DEALLOCATE_LOCAL(data);
+        xfree(data);
         return;
     }
     crep = (xAllocColorCellsReply *)&(data->u.reply);
@@ -2076,7 +2076,7 @@ static void GetSendColorCellsRep(ClientPtr client, xResourceReq *req)
         SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
             req->reqType, 0L, XETrapErrorBase + BadIO);
     }
-    DEALLOCATE_LOCAL(data);
+    xfree(data);
 }
 static void GetSendColorPlanesRep(ClientPtr client, xResourceReq *req)
 {   /* adapted from ProcAllocColorPlanes() in dispatch.c */
@@ -2104,7 +2104,7 @@ static void GetSendColorPlanesRep(ClientPtr client, xResourceReq *req)
         return;
     }
     length = (long)npixels * sizeof(Pixel);
-    data = (XETrapDatum *)ALLOCATE_LOCAL(sizeof(XETrapDatum)+length);
+    data = (XETrapDatum *)xalloc(sizeof(XETrapDatum)+length);
     if (!data)
     {
         SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
@@ -2124,7 +2124,7 @@ static void GetSendColorPlanesRep(ClientPtr client, xResourceReq *req)
     {
         SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
             req->reqType, 0L, retval);
-        DEALLOCATE_LOCAL(data);
+        xfree(data);
         return;
     }
     crep->nPixels = npixels;
@@ -2149,6 +2149,6 @@ static void GetSendColorPlanesRep(ClientPtr client, xResourceReq *req)
         SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
             req->reqType, 0L, XETrapErrorBase + BadIO);
     }
-    DEALLOCATE_LOCAL(data);
+    xfree(data);
 }
 #endif /* COLOR_REPLIES */

Xext/Makefile.am

@@ -88,7 +88,7 @@ endif
 XCALIBRATE_SRCS = xcalibrate.c
 if XCALIBRATE
 BUILTIN_SRCS += $(XCALIBRATE_SRCS)
-# XCalibrare needs tslib
+# XCalibrate needs tslib
 endif
 
 # X EVent Interception Extension: allows accessibility helpers & composite

Xext/mbuf.c

@@ -403,7 +403,7 @@ CreateImageBuffers (pWin, nbuf, ids, action, hint)
 	pMultibuffer->pMultibuffers = pMultibuffers;
 	if (!AddResource (ids[i], MultibufferResType, (pointer) pMultibuffer))
 	    break;
-	pMultibuffer->pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height, depth);
+	pMultibuffer->pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height, depth, 0);
 	if (!pMultibuffer->pPixmap)
 	    break;
 	if (!AddResource (ids[i], MultibufferDrawableResType, (pointer) pMultibuffer->pPixmap))
@@ -524,12 +524,12 @@ ProcDisplayImageBuffers (client)
 	return Success;
     minDelay = stuff->minDelay;
     ids = (XID *) &stuff[1];
-    ppMultibuffers = (MultibuffersPtr *) ALLOCATE_LOCAL(nbuf * sizeof (MultibuffersPtr));
+    ppMultibuffers = (MultibuffersPtr *) xalloc(nbuf * sizeof (MultibuffersPtr));
-    pMultibuffer = (MultibufferPtr *) ALLOCATE_LOCAL(nbuf * sizeof (MultibufferPtr));
+    pMultibuffer = (MultibufferPtr *) xalloc(nbuf * sizeof (MultibufferPtr));
     if (!ppMultibuffers || !pMultibuffer)
     {
-	if (ppMultibuffers) DEALLOCATE_LOCAL(ppMultibuffers);
+	if (ppMultibuffers) xfree(ppMultibuffers);
-	if (pMultibuffer)   DEALLOCATE_LOCAL(pMultibuffer);
+	if (pMultibuffer)   xfree(pMultibuffer);
 	client->errorValue = 0;
 	return BadAlloc;
     }
@@ -541,8 +541,8 @@ ProcDisplayImageBuffers (client)
 MultibufferResType);
 	if (!pMultibuffer[i])
 	{
-	    DEALLOCATE_LOCAL(ppMultibuffers);
+	    xfree(ppMultibuffers);
-	    DEALLOCATE_LOCAL(pMultibuffer);
+	    xfree(pMultibuffer);
 	    client->errorValue = ids[i];
 	    return MultibufferErrorBase + MultibufferBadBuffer;
 	}
@@ -551,8 +551,8 @@ MultibufferResType);
 	{
 	    if (ppMultibuffers[i] == ppMultibuffers[j])
 	    {
-	    	DEALLOCATE_LOCAL(ppMultibuffers);
+	    	xfree(ppMultibuffers);
-	    	DEALLOCATE_LOCAL(pMultibuffer);
+	    	xfree(pMultibuffer);
 		client->errorValue = ids[i];
 	    	return BadMatch;
 	    }
@@ -571,8 +571,8 @@ MultibufferResType);
     else
 	PerformDisplayRequest (ppMultibuffers, pMultibuffer, nbuf);
 
-    DEALLOCATE_LOCAL(ppMultibuffers);
+    xfree(ppMultibuffers);
-    DEALLOCATE_LOCAL(pMultibuffer);
+    xfree(pMultibuffer);
     return Success;
 }
 
@@ -665,7 +665,7 @@ ProcGetMBufferAttributes (client)
     pMultibuffers = (MultibuffersPtr)LookupIDByType (pWin->drawable.id, MultibuffersResType);
     if (!pMultibuffers)
 	return BadAccess;
-    ids = (XID *) ALLOCATE_LOCAL (pMultibuffers->numMultibuffer * sizeof (XID));
+    ids = (XID *) xalloc (pMultibuffers->numMultibuffer * sizeof (XID));
     if (!ids)
 	return BadAlloc;
     for (i = 0; i < pMultibuffers->numMultibuffer; i++)
@@ -688,7 +688,7 @@ ProcGetMBufferAttributes (client)
 		   (char *)&rep);
     WriteToClient (client, (int)(pMultibuffers->numMultibuffer * sizeof (XID)),
 		   (char *)ids);
-    DEALLOCATE_LOCAL((pointer) ids);
+    xfree((pointer) ids);
     return client->noClientException;
 }
 
@@ -803,7 +803,7 @@ ProcGetBufferInfo (client)
 	nInfo += pDepth->numVids;
     }
     pInfo = (xMbufBufferInfo *)
-		ALLOCATE_LOCAL (nInfo * sizeof (xMbufBufferInfo));
+		xalloc (nInfo * sizeof (xMbufBufferInfo));
     if (!pInfo)
 	return BadAlloc;
 
@@ -839,7 +839,7 @@ ProcGetBufferInfo (client)
     }
     WriteToClient (client, sizeof (xMbufGetBufferInfoReply), (pointer) &rep);
     WriteToClient (client, (int) nInfo * sizeof (xMbufBufferInfo), (pointer) pInfo);
-    DEALLOCATE_LOCAL ((pointer) pInfo);
+    xfree ((pointer) pInfo);
     return client->noClientException;
 }
 
@@ -1256,7 +1256,7 @@ DisplayImageBuffers (ids, nbuf)
     MultibuffersPtr *pMultibuffers;
     int		    i, j;
 
-    pMultibuffer = (MultibufferPtr *) ALLOCATE_LOCAL (nbuf * sizeof *pMultibuffer +
+    pMultibuffer = (MultibufferPtr *) xalloc (nbuf * sizeof *pMultibuffer +
 				   nbuf * sizeof *pMultibuffers);
     if (!pMultibuffer)
 	return BadAlloc;
@@ -1266,19 +1266,19 @@ DisplayImageBuffers (ids, nbuf)
 	pMultibuffer[i] = (MultibufferPtr) LookupIDByType (ids[i], MultibufferResType);
 	if (!pMultibuffer[i])
 	{
-	    DEALLOCATE_LOCAL (pMultibuffer);
+	    xfree (pMultibuffer);
 	    return MultibufferErrorBase + MultibufferBadBuffer;
 	}
 	pMultibuffers[i] = pMultibuffer[i]->pMultibuffers;
 	for (j = 0; j < i; j++)
 	    if (pMultibuffers[i] == pMultibuffers[j])
 	    {
-		DEALLOCATE_LOCAL (pMultibuffer);
+		xfree (pMultibuffer);
 		return BadMatch;
 	    }
     }
     PerformDisplayRequest (pMultibuffers, pMultibuffer, nbuf);
-    DEALLOCATE_LOCAL (pMultibuffer);
+    xfree (pMultibuffer);
     return Success;
 }
 
@@ -1382,7 +1382,7 @@ MultibufferExpose (pMultibuffer, pRegion)
 	numRects = REGION_NUM_RECTS(pRegion);
 	pBox = REGION_RECTS(pRegion);
 
-	pEvent = (xEvent *) ALLOCATE_LOCAL(numRects * sizeof(xEvent));
+	pEvent = (xEvent *) xalloc(numRects * sizeof(xEvent));
 	if (pEvent) {
 	    pe = pEvent;
 
@@ -1398,7 +1398,7 @@ MultibufferExpose (pMultibuffer, pRegion)
 	    }
 	    (void) DeliverEventsToMultibuffer (pMultibuffer, pEvent, numRects,
 					       ExposureMask);
-	    DEALLOCATE_LOCAL(pEvent);
+	    xfree(pEvent);
 	}
     }
 }
@@ -1576,7 +1576,8 @@ MultibufferPositionWindow (pWin, x, y)
     {
 	pMultibuffer = &pMultibuffers->buffers[i];
 	pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height,
-					    pWin->drawable.depth);
+					    pWin->drawable.depth,
+					    CREATE_PIXMAP_USAGE_SCRATCH);
 	if (!pPixmap)
 	{
 	    DestroyImageBuffers (pWin);

Xext/mbufbf.c

@@ -329,10 +329,6 @@ bufCreateBuffer(pScreen, pWin, bufferNum)
     pBuffer->firstChild = NULL;
     pBuffer->lastChild  = NULL;
 
-    /* XXX - Worry about backingstore later */
-    pBuffer->backStorage   = NULL;
-    pBuffer->backingStore  = NotUseful;
-
     /* XXX - Need to call pScreen->CreateWindow for tile/stipples
      *       or should I just copy the devPrivates?
      */
@@ -505,22 +501,10 @@ bufClearImageBufferArea(pMBBuffer, x,y, w,h, generateExposures)
 
     pScreen = pBuffer->drawable.pScreen;
     REGION_INIT(pScreen, &reg, &box, 1);
-    if (pBuffer->backStorage)
-    {
-	/*
-	 * If the window has backing-store on, call through the
-	 * ClearToBackground vector to handle the special semantics
-	 * (i.e. things backing store is to be cleared out and
-	 * an Expose event is to be generated for those areas in backing
-	 * store if generateExposures is TRUE).
-	 */
-	pBSReg = (* pScreen->ClearBackingStore)(pBuffer, x, y, w, h,
-						 generateExposures);
-    }
 
     REGION_INTERSECT(pScreen, &reg, &reg, &pBuffer->clipList);
     if (pBuffer->backgroundState != None)
-	(*pScreen->PaintWindowBackground)(pBuffer, &reg, PW_BACKGROUND);
+	miPaintWindow(pBuffer, &reg, PW_BACKGROUND);
     if (generateExposures)
 	MultibufferExpose(pMBBuffer, &reg);
 #ifdef _notdef
@@ -533,7 +517,7 @@ bufClearImageBufferArea(pMBBuffer, x,y, w,h, generateExposures)
     if (generateExposures)
 	(*pScreen->WindowExposures)(pBuffer, &reg, pBSReg);
     else if (pBuffer->backgroundState != None)
-        (*pScreen->PaintWindowBackground)(pBuffer, &reg, PW_BACKGROUND);
+        miPaintWindow(pBuffer, &reg, PW_BACKGROUND);
 #endif
     REGION_UNINIT(pScreen, &reg);
     if (pBSReg)
@@ -630,7 +614,7 @@ bufDrawSelectPlane(pScreen, selectPlane, prgn, bufferNum)
     if (!pGC)
 	return;
 
-    prect = (xRectangle *)ALLOCATE_LOCAL(REGION_NUM_RECTS(prgn) *
+    prect = (xRectangle *)xalloc(REGION_NUM_RECTS(prgn) *
 					 sizeof(xRectangle));
     if (!prect)
     {
@@ -654,7 +638,7 @@ bufDrawSelectPlane(pScreen, selectPlane, prgn, bufferNum)
     prect -= numRects;
     (* pGC->ops->PolyFillRect)(pDrawable, pGC, numRects, prect);
 
-    DEALLOCATE_LOCAL(prect);
+    xfree(prect);
     FreeScratchGC (pGC);
 }
 
@@ -852,8 +836,7 @@ bufClipNotify(pWin, dx,dy)
 
 /*
  * Updates buffer's background fields when the window's changes.
- * This is necessary because pScreen->PaintWindowBackground
+ * This is necessary because miPaintWindow is used to paint the buffer.
- * is used to paint the buffer.
  *
  * XXBS - Backingstore state will have be tracked too if it is supported.
  */
@@ -943,7 +926,7 @@ bufWindowExposures(pWin, prgn, other_exposed)
 	pBuffer = (BufferPtr) pMBBuffer->pDrawable;
 
 	if (i != pMBWindow->displayedMultibuffer)
-	    (* pScreen->PaintWindowBackground)(pBuffer,&tmp_rgn,PW_BACKGROUND);
+	    miPaintWindow(pBuffer, &tmp_rgn, PW_BACKGROUND);
 	if ((pMBBuffer->otherEventMask | pMBBuffer->eventMask) & ExposureMask)
 	    MultibufferExpose(pMBBuffer, &tmp_rgn);
     }

Xext/mbufpx.c

@@ -155,7 +155,7 @@ pixCreateImageBuffers (pWin, nbuf, ids, action, hint)
     {
 	pMBBuffer = &pMBWindow->buffers[i];
 	pMBBuffer->pDrawable = (DrawablePtr)
-	    (*pScreen->CreatePixmap) (pScreen, width, height, depth);
+	    (*pScreen->CreatePixmap) (pScreen, width, height, depth, 0);
 	if (!pMBBuffer->pDrawable)
 	    break;
 
@@ -263,7 +263,7 @@ MultibufferPaintBackgroundRegion(pWin, pDrawable, pRegion)
     int nrects  = REGION_NUM_RECTS(pRegion);
     BoxPtr pbox = REGION_RECTS(pRegion);
 
-    pRects = (xRectangle *)ALLOCATE_LOCAL(nrects * sizeof(xRectangle));
+    pRects = (xRectangle *)xalloc(nrects * sizeof(xRectangle));
     if (pRects)
     {
 	int i;
@@ -275,7 +275,7 @@ MultibufferPaintBackgroundRegion(pWin, pDrawable, pRegion)
 	    pRects[i].height = pbox->y2 - pbox->y1;
 	}
 	MultibufferPaintBackgroundRectangles(pWin, pDrawable, nrects, pRects);
-	DEALLOCATE_LOCAL(pRects);
+	xfree(pRects);
     }
 }
 
@@ -542,7 +542,8 @@ pixPositionWindow (pWin, x, y)
     for (i = 0; i < pMBWindow->numMultibuffer; i++)
     {
 	pMBBuffer = &pMBWindow->buffers[i];
-	pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height, pWin->drawable.depth);
+	pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height, pWin->drawable.depth,
+					    CREATE_PIXMAP_USAGE_SCRATCH);
 	if (!pPixmap)
 	{
 	    (* MB_SCREEN_PRIV(pScreen)->DestroyImageBuffers)(pWin);

Xext/panoramiXprocs.c

@@ -1272,7 +1272,7 @@ int PanoramiXPolyPoint(ClientPtr client)
     isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
     npoint = ((client->req_len << 2) - sizeof(xPolyPointReq)) >> 2;
     if (npoint > 0) {
-        origPts = (xPoint *) ALLOCATE_LOCAL(npoint * sizeof(xPoint));
+        origPts = (xPoint *) xalloc(npoint * sizeof(xPoint));
         memcpy((char *) origPts, (char *) &stuff[1], npoint * sizeof(xPoint));
         FOR_NSCREENS_FORWARD(j){
 
@@ -1299,7 +1299,7 @@ int PanoramiXPolyPoint(ClientPtr client)
 	    result = (* SavedProcVector[X_PolyPoint])(client);
 	    if(result != Success) break;
         }
-        DEALLOCATE_LOCAL(origPts);
+        xfree(origPts);
         return (result);
     } else
 	return (client->noClientException);
@@ -1330,7 +1330,7 @@ int PanoramiXPolyLine(ClientPtr client)
     isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
     npoint = ((client->req_len << 2) - sizeof(xPolyLineReq)) >> 2;
     if (npoint > 0){
-        origPts = (xPoint *) ALLOCATE_LOCAL(npoint * sizeof(xPoint));
+        origPts = (xPoint *) xalloc(npoint * sizeof(xPoint));
         memcpy((char *) origPts, (char *) &stuff[1], npoint * sizeof(xPoint));
         FOR_NSCREENS_FORWARD(j){
 
@@ -1357,7 +1357,7 @@ int PanoramiXPolyLine(ClientPtr client)
 	    result = (* SavedProcVector[X_PolyLine])(client);
 	    if(result != Success) break;
         }
-        DEALLOCATE_LOCAL(origPts);
+        xfree(origPts);
         return (result);
    } else
 	return (client->noClientException);
@@ -1391,7 +1391,7 @@ int PanoramiXPolySegment(ClientPtr client)
     if(nsegs & 4) return BadLength;
     nsegs >>= 3;
     if (nsegs > 0) {
-	origSegs = (xSegment *) ALLOCATE_LOCAL(nsegs * sizeof(xSegment));
+	origSegs = (xSegment *) xalloc(nsegs * sizeof(xSegment));
         memcpy((char *) origSegs, (char *) &stuff[1], nsegs * sizeof(xSegment));
         FOR_NSCREENS_FORWARD(j){
 
@@ -1418,7 +1418,7 @@ int PanoramiXPolySegment(ClientPtr client)
 	    result = (* SavedProcVector[X_PolySegment])(client);
 	    if(result != Success) break;
     	}
-	DEALLOCATE_LOCAL(origSegs);
+	xfree(origSegs);
 	return (result);
     } else
 	  return (client->noClientException);
@@ -1453,7 +1453,7 @@ int PanoramiXPolyRectangle(ClientPtr client)
     if(nrects & 4) return BadLength;
     nrects >>= 3;
     if (nrects > 0){
-	origRecs = (xRectangle *) ALLOCATE_LOCAL(nrects * sizeof(xRectangle));
+	origRecs = (xRectangle *) xalloc(nrects * sizeof(xRectangle));
 	memcpy((char *)origRecs,(char *)&stuff[1],nrects * sizeof(xRectangle));
         FOR_NSCREENS_FORWARD(j){
 
@@ -1479,7 +1479,7 @@ int PanoramiXPolyRectangle(ClientPtr client)
 	    result = (* SavedProcVector[X_PolyRectangle])(client);
 	    if(result != Success) break;
 	}
-	DEALLOCATE_LOCAL(origRecs);
+	xfree(origRecs);
 	return (result);
     } else
        return (client->noClientException);
@@ -1513,7 +1513,7 @@ int PanoramiXPolyArc(ClientPtr client)
     if(narcs % sizeof(xArc)) return BadLength;
     narcs /= sizeof(xArc);
     if (narcs > 0){
-	origArcs = (xArc *) ALLOCATE_LOCAL(narcs * sizeof(xArc));
+	origArcs = (xArc *) xalloc(narcs * sizeof(xArc));
 	memcpy((char *) origArcs, (char *) &stuff[1], narcs * sizeof(xArc));
         FOR_NSCREENS_FORWARD(j){
 
@@ -1537,7 +1537,7 @@ int PanoramiXPolyArc(ClientPtr client)
 	    result = (* SavedProcVector[X_PolyArc])(client);
 	    if(result != Success) break;
         }
-	DEALLOCATE_LOCAL(origArcs);
+	xfree(origArcs);
 	return (result);
     } else
        return (client->noClientException);
@@ -1569,7 +1569,7 @@ int PanoramiXFillPoly(ClientPtr client)
 
     count = ((client->req_len << 2) - sizeof(xFillPolyReq)) >> 2;
     if (count > 0){
-	locPts = (DDXPointPtr) ALLOCATE_LOCAL(count * sizeof(DDXPointRec));
+	locPts = (DDXPointPtr) xalloc(count * sizeof(DDXPointRec));
 	memcpy((char *)locPts, (char *)&stuff[1], count * sizeof(DDXPointRec));
         FOR_NSCREENS_FORWARD(j){
 
@@ -1596,7 +1596,7 @@ int PanoramiXFillPoly(ClientPtr client)
 	    result = (* SavedProcVector[X_FillPoly])(client);
 	    if(result != Success) break;
 	}
-	DEALLOCATE_LOCAL(locPts);
+	xfree(locPts);
 	return (result);
     } else
        return (client->noClientException);
@@ -1630,7 +1630,7 @@ int PanoramiXPolyFillRectangle(ClientPtr client)
     if(things & 4) return BadLength;
     things >>= 3;
     if (things > 0){
-	origRects = (xRectangle *) ALLOCATE_LOCAL(things * sizeof(xRectangle));
+	origRects = (xRectangle *) xalloc(things * sizeof(xRectangle));
 	memcpy((char*)origRects,(char*)&stuff[1], things * sizeof(xRectangle));
         FOR_NSCREENS_FORWARD(j){
 
@@ -1655,7 +1655,7 @@ int PanoramiXPolyFillRectangle(ClientPtr client)
 	    result = (* SavedProcVector[X_PolyFillRectangle])(client);
 	    if(result != Success) break;
 	}
-	DEALLOCATE_LOCAL(origRects);
+	xfree(origRects);
 	return (result);
     } else
        return (client->noClientException);
@@ -1689,7 +1689,7 @@ int PanoramiXPolyFillArc(ClientPtr client)
     IF_RETURN((narcs % sizeof(xArc)), BadLength);
     narcs /= sizeof(xArc);
     if (narcs > 0) {
-	origArcs = (xArc *) ALLOCATE_LOCAL(narcs * sizeof(xArc));
+	origArcs = (xArc *) xalloc(narcs * sizeof(xArc));
 	memcpy((char *) origArcs, (char *)&stuff[1], narcs * sizeof(xArc));
         FOR_NSCREENS_FORWARD(j){
 
@@ -1714,7 +1714,7 @@ int PanoramiXPolyFillArc(ClientPtr client)
 	    result = (* SavedProcVector[X_PolyFillArc])(client);
 	    if(result != Success) break;
 	}
-	DEALLOCATE_LOCAL(origArcs);
+	xfree(origArcs);
 	return (result);
     } else
        return (client->noClientException);

Xext/saver.c

@@ -673,7 +673,7 @@ CreateSaverWindow (pScreen)
     wantMap = wColormap (pWin);
     if (wantMap == None)
 	return TRUE;
-    installedMaps = (Colormap *) ALLOCATE_LOCAL (pScreen->maxInstalledCmaps *
+    installedMaps = (Colormap *) xalloc (pScreen->maxInstalledCmaps *
 						 sizeof (Colormap));
     numInstalled = (*pWin->drawable.pScreen->ListInstalledColormaps)
 						    (pScreen, installedMaps);
@@ -681,7 +681,7 @@ CreateSaverWindow (pScreen)
 	if (installedMaps[i] == wantMap)
 	    break;
 
-    DEALLOCATE_LOCAL ((char *) installedMaps);
+    xfree ((char *) installedMaps);
 
     if (i < numInstalled)
 	return TRUE;

Xext/shape.c

@@ -1060,7 +1060,7 @@ ProcShapeGetRectangles (client)
     }
     if (!region) {
 	nrects = 1;
-	rects = (xRectangle *) ALLOCATE_LOCAL (sizeof (xRectangle));
+	rects = (xRectangle *) xalloc (sizeof (xRectangle));
 	if (!rects)
 	    return BadAlloc;
 	switch (stuff->kind) {
@@ -1087,7 +1087,7 @@ ProcShapeGetRectangles (client)
 	BoxPtr box;
 	nrects = REGION_NUM_RECTS(region);
 	box = REGION_RECTS(region);
-	rects = (xRectangle *) ALLOCATE_LOCAL (nrects * sizeof (xRectangle));
+	rects = (xRectangle *) xalloc (nrects * sizeof (xRectangle));
 	if (!rects && nrects)
 	    return BadAlloc;
 	for (i = 0; i < nrects; i++, box++) {
@@ -1110,7 +1110,7 @@ ProcShapeGetRectangles (client)
     }
     WriteToClient (client, sizeof (rep), (char *) &rep);
     WriteToClient (client, nrects * sizeof (xRectangle), (char *) rects);
-    DEALLOCATE_LOCAL (rects);
+    xfree (rects);
     return client->noClientException;
 }
 

Xext/shm.c

@@ -57,10 +57,38 @@ in this Software without prior written authorization from The Open Group.
 #include "gcstruct.h"
 #include "extnsionst.h"
 #include "servermd.h"
+#include "shmint.h"
 #define _XSHM_SERVER_
 #include <X11/extensions/shmstr.h>
 #include <X11/Xfuncproto.h>
 
+/* Needed for Solaris cross-zone shared memory extension */
+#ifdef HAVE_SHMCTL64
+#include <sys/ipc_impl.h>
+#define SHMSTAT(id, buf)	shmctl64(id, IPC_STAT64, buf)
+#define SHMSTAT_TYPE 		struct shmid_ds64
+#define SHMPERM_TYPE 		struct ipc_perm64
+#define SHM_PERM(buf) 		buf.shmx_perm
+#define SHM_SEGSZ(buf)		buf.shmx_segsz
+#define SHMPERM_UID(p)		p->ipcx_uid
+#define SHMPERM_CUID(p)		p->ipcx_cuid
+#define SHMPERM_GID(p)		p->ipcx_gid
+#define SHMPERM_CGID(p)		p->ipcx_cgid
+#define SHMPERM_MODE(p)		p->ipcx_mode
+#define SHMPERM_ZONEID(p)	p->ipcx_zoneid
+#else
+#define SHMSTAT(id, buf) 	shmctl(id, IPC_STAT, buf)
+#define SHMSTAT_TYPE 		struct shmid_ds
+#define SHMPERM_TYPE 		struct ipc_perm
+#define SHM_PERM(buf) 		buf.shm_perm
+#define SHM_SEGSZ(buf)		buf.shm_segsz
+#define SHMPERM_UID(p)		p->uid
+#define SHMPERM_CUID(p)		p->cuid
+#define SHMPERM_GID(p)		p->gid
+#define SHMPERM_CGID(p)		p->cgid
+#define SHMPERM_MODE(p)		p->mode
+#endif
+
 #ifdef PANORAMIX
 #include "panoramiX.h"
 #include "panoramiXsrv.h"
@@ -78,7 +106,6 @@ typedef struct _ShmDesc {
 } ShmDescRec, *ShmDescPtr;
 
 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 */,
@@ -154,7 +181,7 @@ static ShmFuncs fbFuncs = {fbShmCreatePixmap, fbShmPutImage};
 }
 
 
-#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__CYGWIN__)
+#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__CYGWIN__) || defined(__DragonFly__)
 #include <sys/signal.h>
 
 static Bool badSysCall = FALSE;
@@ -348,32 +375,57 @@ ProcShmQueryVersion(client)
  * using the credentials from the client if available
  */
 static int
-shm_access(ClientPtr client, struct ipc_perm *perm, int readonly)
+shm_access(ClientPtr client, SHMPERM_TYPE *perm, int readonly)
 {
     int uid, gid;
     mode_t mask;
+    int uidset = 0, gidset = 0;
+    LocalClientCredRec *lcc;
+    
+    if (GetLocalClientCreds(client, &lcc) != -1) {
 
-    if (LocalClientCred(client, &uid, &gid) != -1) {
+	if (lcc->fieldsSet & LCC_UID_SET) {
+	    uid = lcc->euid;
+	    uidset = 1;
+	}
+	if (lcc->fieldsSet & LCC_GID_SET) {
+	    gid = lcc->egid;
+	    gidset = 1;
+	}
+
+#if defined(HAVE_GETZONEID) && defined(SHMPERM_ZONEID)
+	if ( ((lcc->fieldsSet & LCC_ZID_SET) == 0) || (lcc->zoneid == -1)
+	     || (lcc->zoneid != SHMPERM_ZONEID(perm))) {
+		uidset = 0;
+		gidset = 0;
+	}
+#endif
+	FreeLocalClientCreds(lcc);
 	
-	/* User id 0 always gets access */
+	if (uidset) {
-	if (uid == 0) {
+	    /* User id 0 always gets access */
-	    return 0;
+	    if (uid == 0) {
-	}
+		return 0;
-	/* Check the owner */
-	if (perm->uid == uid || perm->cuid == uid) {
-	    mask = S_IRUSR;
-	    if (!readonly) {
-		mask |= S_IWUSR;
 	    }
-	    return (perm->mode & mask) == mask ? 0 : -1;
+	    /* Check the owner */
-	}
+	    if (SHMPERM_UID(perm) == uid || SHMPERM_CUID(perm) == uid) {
-	/* Check the group */
+		mask = S_IRUSR;
-	if (perm->gid == gid || perm->cgid == gid) {
+		if (!readonly) {
-	    mask = S_IRGRP;
+		    mask |= S_IWUSR;
-	    if (!readonly) {
+		}
-		mask |= S_IWGRP;
+		return (SHMPERM_MODE(perm) & mask) == mask ? 0 : -1;
+	    }
+	}
+
+	if (gidset) {
+	    /* Check the group */
+	    if (SHMPERM_GID(perm) == gid || SHMPERM_CGID(perm) == gid) {
+		mask = S_IRGRP;
+		if (!readonly) {
+		    mask |= S_IWGRP;
+		}
+		return (SHMPERM_MODE(perm) & mask) == mask ? 0 : -1;
 	    }
-	    return (perm->mode & mask) == mask ? 0 : -1;
 	}
     }
     /* Otherwise, check everyone else */
@@ -381,14 +433,14 @@ shm_access(ClientPtr client, struct ipc_perm *perm, int readonly)
     if (!readonly) {
 	mask |= S_IWOTH;
     }
-    return (perm->mode & mask) == mask ? 0 : -1;
+    return (SHMPERM_MODE(perm) & mask) == mask ? 0 : -1;
 }
 
 static int
 ProcShmAttach(client)
     register ClientPtr client;
 {
-    struct shmid_ds buf;
+    SHMSTAT_TYPE buf;
     ShmDescPtr shmdesc;
     REQUEST(xShmAttachReq);
 
@@ -417,7 +469,7 @@ ProcShmAttach(client)
 	shmdesc->addr = shmat(stuff->shmid, 0,
 			      stuff->readOnly ? SHM_RDONLY : 0);
 	if ((shmdesc->addr == ((char *)-1)) ||
-	    shmctl(stuff->shmid, IPC_STAT, &buf))
+	    SHMSTAT(stuff->shmid, &buf))
 	{
 	    xfree(shmdesc);
 	    return BadAccess;
@@ -427,7 +479,7 @@ ProcShmAttach(client)
 	 * do manual checking of access rights for the credentials 
 	 * of the client */
 
-	if (shm_access(client, &(buf.shm_perm), stuff->readOnly) == -1) {
+	if (shm_access(client, &(SHM_PERM(buf)), stuff->readOnly) == -1) {
 	    shmdt(shmdesc->addr);
 	    xfree(shmdesc);
 	    return BadAccess;
@@ -436,7 +488,7 @@ ProcShmAttach(client)
 	shmdesc->shmid = stuff->shmid;
 	shmdesc->refcnt = 1;
 	shmdesc->writable = !stuff->readOnly;
-	shmdesc->size = buf.shm_segsz;
+	shmdesc->size = SHM_SEGSZ(buf);
 	shmdesc->next = Shmsegs;
 	Shmsegs = shmdesc;
     }
@@ -491,7 +543,8 @@ miShmPutImage(dst, pGC, depth, format, w, h, sx, sy, sw, sh, dx, dy, data)
     putGC = GetScratchGC(depth, dst->pScreen);
     if (!putGC)
 	return;
-    pmap = (*dst->pScreen->CreatePixmap)(dst->pScreen, sw, sh, depth);
+    pmap = (*dst->pScreen->CreatePixmap)(dst->pScreen, sw, sh, depth,
+					 CREATE_PIXMAP_USAGE_SCRATCH);
     if (!pmap)
     {
 	FreeScratchGC(putGC);
@@ -510,7 +563,7 @@ miShmPutImage(dst, pGC, depth, format, w, h, sx, sy, sw, sh, dx, dy, data)
     (*pmap->drawable.pScreen->DestroyPixmap)(pmap);
 }
 
-static void
+_X_EXPORT void
 fbShmPutImage(dst, pGC, depth, format, w, h, sx, sy, sw, sh, dx, dy, data)
     DrawablePtr dst;
     GCPtr	pGC;
@@ -1018,7 +1071,7 @@ fbShmCreatePixmap (pScreen, width, height, depth, addr)
 {
     register PixmapPtr pPixmap;
 
-    pPixmap = (*pScreen->CreatePixmap)(pScreen, 0, 0, pScreen->rootDepth);
+    pPixmap = (*pScreen->CreatePixmap)(pScreen, 0, 0, pScreen->rootDepth, 0);
     if (!pPixmap)
 	return NullPixmap;
 

Xext/shmint.h

@@ -36,6 +36,9 @@ ShmRegisterFuncs(ScreenPtr pScreen, ShmFuncsPtr funcs);
 void
 ShmSetPixmapFormat(ScreenPtr pScreen, int format);
 
+void
+fbShmPutImage(XSHM_PUT_IMAGE_ARGS);
+
 void
 ShmRegisterFbFuncs(ScreenPtr pScreen);
 

Xext/sync.c

@@ -601,7 +601,7 @@ SyncSendCounterNotifyEvents(client, ppAwait, num_events)
     if (client->clientGone)
 	return;
     pev = pEvents = (xSyncCounterNotifyEvent *)
-		 ALLOCATE_LOCAL(num_events * sizeof(xSyncCounterNotifyEvent));
+		 xalloc(num_events * sizeof(xSyncCounterNotifyEvent));
     if (!pEvents) 
 	return;
     UpdateCurrentTime();
@@ -622,7 +622,7 @@ SyncSendCounterNotifyEvents(client, ppAwait, num_events)
     }
     /* swapping will be taken care of by this */
     WriteEventsToClient(client, num_events, (xEvent *)pEvents);
-    DEALLOCATE_LOCAL(pEvents);
+    xfree(pEvents);
 }
 
 
@@ -732,7 +732,7 @@ SyncAwaitTriggerFired(pTrigger)
 
     pAwaitUnion = (SyncAwaitUnion *)pAwait->pHeader;
     numwaits = pAwaitUnion->header.num_waitconditions;
-    ppAwait = (SyncAwait **)ALLOCATE_LOCAL(numwaits * sizeof(SyncAwait *));
+    ppAwait = (SyncAwait **)xalloc(numwaits * sizeof(SyncAwait *));
     if (!ppAwait)
 	goto bail;
 
@@ -801,7 +801,7 @@ SyncAwaitTriggerFired(pTrigger)
     if (num_events)
 	SyncSendCounterNotifyEvents(pAwaitUnion->header.client, ppAwait,
 				    num_events);
-    DEALLOCATE_LOCAL(ppAwait);
+    xfree(ppAwait);
 
 bail:
     /* unblock the client */
@@ -1396,7 +1396,7 @@ ProcSyncListSystemCounters(client)
 
     if (len)
     {
-	walklist = list = (xSyncSystemCounter *) ALLOCATE_LOCAL(len);
+	walklist = list = (xSyncSystemCounter *) xalloc(len);
 	if (!list)
 	    return BadAlloc;
     }
@@ -1442,7 +1442,7 @@ ProcSyncListSystemCounters(client)
     if (len) 
     {
 	WriteToClient(client, len, (char *) list);
-	DEALLOCATE_LOCAL(list);
+	xfree(list);
     }
 
     return (client->noClientException);
@@ -2592,8 +2592,9 @@ IdleTimeWakeupHandler (pointer env,
     IdleTimeQueryValue (NULL, &idle);
 
     if ((pIdleTimeValueGreater &&
-         XSyncValueGreaterThan (idle, *pIdleTimeValueGreater)) ||
+         XSyncValueGreaterOrEqual (idle, *pIdleTimeValueGreater)) ||
-        (pIdleTimeValueLess && XSyncValueLessThan (idle, *pIdleTimeValueLess)))
+        (pIdleTimeValueLess &&
+	 XSyncValueLessOrEqual (idle, *pIdleTimeValueLess)))
     {
 	SyncChangeCounter (IdleTimeCounter, idle);
     }

Xext/xace.c

@@ -44,6 +44,22 @@ static int (*SwappedUntrustedProcVector[256])(
     ClientPtr /*client*/
 );
 
+/* Special-cased hook functions.  Called by Xserver.
+ */
+void XaceHookAuditBegin(ClientPtr ptr)
+{
+    XaceAuditRec rec = { ptr, 0 };
+    /* call callbacks, there is no return value. */
+    CallCallbacks(&XaceHooks[XACE_AUDIT_BEGIN], &rec);
+}
+
+void XaceHookAuditEnd(ClientPtr ptr, int result)
+{
+    XaceAuditRec rec = { ptr, result };
+    /* call callbacks, there is no return value. */
+    CallCallbacks(&XaceHooks[XACE_AUDIT_END], &rec);
+}
+
 /* Entry point for hook functions.  Called by Xserver.
  */
 int XaceHook(int hook, ...)
@@ -60,15 +76,6 @@ int XaceHook(int hook, ...)
      */
     switch (hook)
     {
-	case XACE_CORE_DISPATCH: {
-	    XaceCoreDispatchRec rec = {
-		va_arg(ap, ClientPtr),
-		TRUE	/* default allow */
-	    };
-	    calldata = &rec;
-	    prv = &rec.rval;
-	    break;
-	}
 	case XACE_RESOURCE_ACCESS: {
 	    XaceResourceAccessRec rec = {
 		va_arg(ap, ClientPtr),
@@ -190,22 +197,6 @@ int XaceHook(int hook, ...)
 	    calldata = &rec;
 	    break;
 	}
-	case XACE_AUDIT_BEGIN: {
-	    XaceAuditRec rec = {
-		va_arg(ap, ClientPtr),
-		0
-	    };
-	    calldata = &rec;
-	    break;
-	}
-	case XACE_AUDIT_END: {
-	    XaceAuditRec rec = {
-		va_arg(ap, ClientPtr),
-		va_arg(ap, int)
-	    };
-	    calldata = &rec;
-	    break;
-	}
 	default: {
 	    va_end(ap);
 	    return 0;	/* unimplemented hook number */
@@ -271,11 +262,15 @@ XaceCatchDispatchProc(ClientPtr client)
 {
     REQUEST(xReq);
     int major = stuff->reqType;
+    XaceCoreDispatchRec rec = { client, TRUE /* default allow */ };
 
     if (!ProcVector[major])
 	return (BadRequest);
 
-    if (!XaceHook(XACE_CORE_DISPATCH, client))
+    /* call callbacks and return result, if any. */
+    CallCallbacks(&XaceHooks[XACE_CORE_DISPATCH], &rec);
+
+    if (!rec.rval)
 	return (BadAccess);
 
     return client->swapped ? 
@@ -437,7 +432,7 @@ XaceCensorImage(client, pVisibleRegion, widthBytesLine, pDraw, x, y, w, h,
 
 	/* convert region to list-of-rectangles for PolyFillRect */
 
-	pRects = (xRectangle *)ALLOCATE_LOCAL(nRects * sizeof(xRectangle *));
+	pRects = (xRectangle *)xalloc(nRects * sizeof(xRectangle *));
 	if (!pRects)
 	{
 	    failed = TRUE;
@@ -489,7 +484,7 @@ XaceCensorImage(client, pVisibleRegion, widthBytesLine, pDraw, x, y, w, h,
 	     */
 	    bzero(pBuf, (int)(widthBytesLine * h));
 	}
-	if (pRects)     DEALLOCATE_LOCAL(pRects);
+	if (pRects)     xfree(pRects);
 	if (pScratchGC) FreeScratchGC(pScratchGC);
 	if (pPix)       FreeScratchPixmapHeader(pPix);
     }

Xext/xace.h

@@ -68,6 +68,11 @@ extern int XaceHook(
     ... /*appropriate args for hook*/
     ); 
 
+/* Special-cased hook functions
+ */
+extern void XaceHookAuditEnd(ClientPtr ptr, int result);
+extern void XaceHookAuditBegin(ClientPtr ptr);
+
 /* Register a callback for a given hook.
  */
 #define XaceRegisterCallback(hook,callback,data) \
@@ -98,9 +103,13 @@ extern void XaceCensorImage(
 
 #ifdef __GNUC__
 #define XaceHook(args...) XaceAllowOperation
+#define XaceHookAuditEnd(args...) { ; }
+#define XaceHookAuditBegin(args...) { ; }
 #define XaceCensorImage(args...) { ; }
 #else
 #define XaceHook(...) XaceAllowOperation
+#define XaceHookAuditEnd(...) { ; }
+#define XaceHookAuditBegin(...) { ; }
 #define XaceCensorImage(...) { ; }
 #endif
 

Xext/xf86bigfont.c

@@ -104,7 +104,7 @@ static unsigned int pagesize;
 
 static Bool badSysCall = FALSE;
 
-#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__CYGWIN__)
+#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__CYGWIN__) || defined(__DragonFly__)
 
 #include <sys/signal.h>
 
@@ -491,7 +491,7 @@ ProcXF86BigfontQueryFont(
 	    } else {
 #endif
 		pCI = (xCharInfo *)
-		      ALLOCATE_LOCAL(nCharInfos * sizeof(xCharInfo));
+		      xalloc(nCharInfos * sizeof(xCharInfo));
 		if (!pCI)
 		    return BadAlloc;
 #ifdef HAS_SHM
@@ -554,9 +554,9 @@ ProcXF86BigfontQueryFont(
 		hashModulus = nCharInfos+1;
 
 	    tmp = (CARD16*)
-		  ALLOCATE_LOCAL((4*nCharInfos+1) * sizeof(CARD16));
+		  xalloc((4*nCharInfos+1) * sizeof(CARD16));
 	    if (!tmp) {
-		if (!pDesc) DEALLOCATE_LOCAL(pCI);
+		if (!pDesc) xfree(pCI);
 		return BadAlloc;
 	    }
 	    pIndex2UniqIndex = tmp;
@@ -639,12 +639,12 @@ ProcXF86BigfontQueryFont(
 	        + (nCharInfos+1)/2 * 2 * sizeof(CARD16)
 	      : 0);
 	xXF86BigfontQueryFontReply* reply =
-	   (xXF86BigfontQueryFontReply *) ALLOCATE_LOCAL(rlength);
+	   (xXF86BigfontQueryFontReply *) xalloc(rlength);
 	char* p;
 	if (!reply) {
 	    if (nCharInfos > 0) {
-		if (shmid == -1) DEALLOCATE_LOCAL(pIndex2UniqIndex);
+		if (shmid == -1) xfree(pIndex2UniqIndex);
-		if (!pDesc) DEALLOCATE_LOCAL(pCI);
+		if (!pDesc) xfree(pCI);
 	    }
 	    return BadAlloc;
 	}
@@ -722,10 +722,10 @@ ProcXF86BigfontQueryFont(
 	    }
 	}
 	WriteToClient(client, rlength, (char *)reply);
-	DEALLOCATE_LOCAL(reply);
+	xfree(reply);
 	if (nCharInfos > 0) {
-	    if (shmid == -1) DEALLOCATE_LOCAL(pIndex2UniqIndex);
+	    if (shmid == -1) xfree(pIndex2UniqIndex);
-	    if (!pDesc) DEALLOCATE_LOCAL(pCI);
+	    if (!pDesc) xfree(pCI);
 	}
 	return (client->noClientException);
     }

Xext/xres.c

@@ -63,7 +63,7 @@ ProcXResQueryClients (ClientPtr client)
 
     REQUEST_SIZE_MATCH(xXResQueryClientsReq);
 
-    current_clients = ALLOCATE_LOCAL((currentMaxClients - 1) * sizeof(int));
+    current_clients = xalloc((currentMaxClients - 1) * sizeof(int));
 
     num_clients = 0;
     for(i = 1; i < currentMaxClients; i++) {
@@ -101,7 +101,7 @@ ProcXResQueryClients (ClientPtr client)
         }
     }
 
-    DEALLOCATE_LOCAL(current_clients);
+    xfree(current_clients);
 
     return (client->noClientException);
 }
@@ -134,7 +134,7 @@ ProcXResQueryClientResources (ClientPtr client)
         return BadValue;
     }
 
-    counts = ALLOCATE_LOCAL((lastResourceType + 1) * sizeof(int));
+    counts = xalloc((lastResourceType + 1) * sizeof(int));
 
     memset(counts, 0, (lastResourceType + 1) * sizeof(int));
 
@@ -183,7 +183,7 @@ ProcXResQueryClientResources (ClientPtr client)
         }
     }
 
-    DEALLOCATE_LOCAL(counts);
+    xfree(counts);
     
     return (client->noClientException);
 }

Xi/allowev.c

@@ -56,13 +56,10 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
@@ -103,10 +100,8 @@ ProcXAllowDeviceEvents(ClientPtr client)
     REQUEST_SIZE_MATCH(xAllowDeviceEventsReq);
 
     thisdev = LookupDeviceIntRec(stuff->deviceid);
-    if (thisdev == NULL) {
+    if (thisdev == NULL)
-	SendErrorToClient(client, IReqCode, X_AllowDeviceEvents, 0, BadDevice);
+	return BadDevice;
-	return Success;
-    }
     time = ClientTimeToServerTime(stuff->time);
 
     switch (stuff->mode) {
@@ -129,9 +124,8 @@ ProcXAllowDeviceEvents(ClientPtr client)
 	AllowSome(client, time, thisdev, THAWED_BOTH, FALSE);
 	break;
     default:
-	SendErrorToClient(client, IReqCode, X_AllowDeviceEvents, 0, BadValue);
 	client->errorValue = stuff->mode;
-	return Success;
+	return BadValue;
     }
     return Success;
 }

Xi/chgdctl.c

@@ -56,14 +56,11 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>	/* control constants */
 #include "XIstubs.h"
 
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 #include "exevents.h"
@@ -153,11 +150,8 @@ ProcXChangeDeviceControl(ClientPtr client)
 	    a = &dev->valuator->axes[r->first_valuator];
 	    for (i = 0; i < r->num_valuators; i++)
 		if (*(resolution + i) < (a + i)->min_resolution ||
-		    *(resolution + i) > (a + i)->max_resolution) {
+		    *(resolution + i) > (a + i)->max_resolution)
-		    SendErrorToClient(client, IReqCode,
+		    return BadValue;
-				      X_ChangeDeviceControl, 0, BadValue);
-		    return Success;
-		}
 	    for (i = 0; i < r->num_valuators; i++)
 		(a++)->resolution = *resolution++;
 
@@ -269,11 +263,8 @@ out:
 
         WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), &rep);
     }
-    else {
-        SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0, ret);
-    }
 
-    return Success;
+    return ret;
 }
 
 /***********************************************************************

Xi/chgfctl.c

@@ -56,13 +56,10 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>	/* control constants */
 
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
@@ -119,9 +116,7 @@ ChangeKbdFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
 	    t = defaultKeyboardControl.click;
 	else if (t < 0 || t > 100) {
 	    client->errorValue = t;
-	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+	    return BadValue;
-			      BadValue);
-	    return Success;
 	}
 	kctrl.click = t;
     }
@@ -132,9 +127,7 @@ ChangeKbdFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
 	    t = defaultKeyboardControl.bell;
 	else if (t < 0 || t > 100) {
 	    client->errorValue = t;
-	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+	    return BadValue;
-			      BadValue);
-	    return Success;
 	}
 	kctrl.bell = t;
     }
@@ -145,9 +138,7 @@ ChangeKbdFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
 	    t = defaultKeyboardControl.bell_pitch;
 	else if (t < 0) {
 	    client->errorValue = t;
-	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+	    return BadValue;
-			      BadValue);
-	    return Success;
 	}
 	kctrl.bell_pitch = t;
     }
@@ -158,9 +149,7 @@ ChangeKbdFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
 	    t = defaultKeyboardControl.bell_duration;
 	else if (t < 0) {
 	    client->errorValue = t;
-	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+	    return BadValue;
-			      BadValue);
-	    return Success;
 	}
 	kctrl.bell_duration = t;
     }
@@ -174,15 +163,10 @@ ChangeKbdFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
 	key = (KeyCode) f->key;
 	if (key < 8 || key > 255) {
 	    client->errorValue = key;
-	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+	    return BadValue;
-			      BadValue);
-	    return Success;
-	}
-	if (!(mask & DvAutoRepeatMode)) {
-	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
-			      BadMatch);
-	    return Success;
 	}
+	if (!(mask & DvAutoRepeatMode))
+	    return BadMatch;
     }
 
     if (mask & DvAutoRepeatMode) {
@@ -210,9 +194,7 @@ ChangeKbdFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
 		(defaultKeyboardControl.autoRepeats[inx] & kmask);
 	} else {
 	    client->errorValue = t;
-	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+	    return BadValue;
-			      BadValue);
-	    return Success;
 	}
     }
 
@@ -250,9 +232,7 @@ ChangePtrFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
 	    pctrl.num = defaultPointerControl.num;
 	else if (accelNum < 0) {
 	    client->errorValue = accelNum;
-	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+	    return BadValue;
-			      BadValue);
-	    return Success;
 	} else
 	    pctrl.num = accelNum;
     }
@@ -265,9 +245,7 @@ ChangePtrFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
 	    pctrl.den = defaultPointerControl.den;
 	else if (accelDenom <= 0) {
 	    client->errorValue = accelDenom;
-	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+	    return BadValue;
-			      BadValue);
-	    return Success;
 	} else
 	    pctrl.den = accelDenom;
     }
@@ -280,9 +258,7 @@ ChangePtrFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
 	    pctrl.threshold = defaultPointerControl.threshold;
 	else if (threshold < 0) {
 	    client->errorValue = threshold;
-	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+	    return BadValue;
-			      BadValue);
-	    return Success;
 	} else
 	    pctrl.threshold = threshold;
     }
@@ -341,21 +317,16 @@ ChangeStringFeedback(ClientPtr client, DeviceIntPtr dev,
 	}
     }
 
-    if (f->num_keysyms > s->ctrl.max_symbols) {
+    if (f->num_keysyms > s->ctrl.max_symbols)
-	SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+	return BadValue;
-			  BadValue);
+
-	return Success;
-    }
     sup_syms = s->ctrl.symbols_supported;
     for (i = 0; i < f->num_keysyms; i++) {
 	for (j = 0; j < s->ctrl.num_symbols_supported; j++)
 	    if (*(syms + i) == *(sup_syms + j))
 		break;
-	if (j == s->ctrl.num_symbols_supported) {
+	if (j == s->ctrl.num_symbols_supported)
-	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+	    return BadMatch;
-			      BadMatch);
-	    return Success;
-	}
     }
 
     s->ctrl.num_symbols_displayed = f->num_keysyms;
@@ -393,9 +364,7 @@ ChangeBellFeedback(ClientPtr client, DeviceIntPtr dev,
 	    t = defaultKeyboardControl.bell;
 	else if (t < 0 || t > 100) {
 	    client->errorValue = t;
-	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+	    return BadValue;
-			      BadValue);
-	    return Success;
 	}
 	bctrl.percent = t;
     }
@@ -406,9 +375,7 @@ ChangeBellFeedback(ClientPtr client, DeviceIntPtr dev,
 	    t = defaultKeyboardControl.bell_pitch;
 	else if (t < 0) {
 	    client->errorValue = t;
-	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+	    return BadValue;
-			      BadValue);
-	    return Success;
 	}
 	bctrl.pitch = t;
     }
@@ -419,9 +386,7 @@ ChangeBellFeedback(ClientPtr client, DeviceIntPtr dev,
 	    t = defaultKeyboardControl.bell_duration;
 	else if (t < 0) {
 	    client->errorValue = t;
-	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+	    return BadValue;
-			      BadValue);
-	    return Success;
 	}
 	bctrl.duration = t;
     }
@@ -485,38 +450,27 @@ ProcXChangeFeedbackControl(ClientPtr client)
 
     len = stuff->length - (sizeof(xChangeFeedbackControlReq) >> 2);
     dev = LookupDeviceIntRec(stuff->deviceid);
-    if (dev == NULL) {
+    if (dev == NULL)
-	SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
+	return BadDevice;
-			  BadDevice);
-	return Success;
-    }
 
     switch (stuff->feedbackid) {
     case KbdFeedbackClass:
-	if (len != (sizeof(xKbdFeedbackCtl) >> 2)) {
+	if (len != (sizeof(xKbdFeedbackCtl) >> 2))
-	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
+	    return BadLength;
-			      0, BadLength);
+
-	    return Success;
-	}
 	for (k = dev->kbdfeed; k; k = k->next)
-	    if (k->ctrl.id == ((xKbdFeedbackCtl *) & stuff[1])->id) {
+	    if (k->ctrl.id == ((xKbdFeedbackCtl *) & stuff[1])->id)
-		ChangeKbdFeedback(client, dev, stuff->mask, k,
+		return ChangeKbdFeedback(client, dev, stuff->mask, k,
-				  (xKbdFeedbackCtl *) & stuff[1]);
+					 (xKbdFeedbackCtl *) & stuff[1]);
-		return Success;
-	    }
 	break;
     case PtrFeedbackClass:
-	if (len != (sizeof(xPtrFeedbackCtl) >> 2)) {
+	if (len != (sizeof(xPtrFeedbackCtl) >> 2))
-	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
+	    return BadLength;
-			      0, BadLength);
+
-	    return Success;
-	}
 	for (p = dev->ptrfeed; p; p = p->next)
-	    if (p->ctrl.id == ((xPtrFeedbackCtl *) & stuff[1])->id) {
+	    if (p->ctrl.id == ((xPtrFeedbackCtl *) & stuff[1])->id)
-		ChangePtrFeedback(client, dev, stuff->mask, p,
+		return ChangePtrFeedback(client, dev, stuff->mask, p,
-				  (xPtrFeedbackCtl *) & stuff[1]);
+					 (xPtrFeedbackCtl *) & stuff[1]);
-		return Success;
-	    }
 	break;
     case StringFeedbackClass:
     {
@@ -526,63 +480,46 @@ ProcXChangeFeedbackControl(ClientPtr client)
 	if (client->swapped) {
 	    swaps(&f->num_keysyms, n);
 	}
-	if (len != ((sizeof(xStringFeedbackCtl) >> 2) + f->num_keysyms)) {
+	if (len != ((sizeof(xStringFeedbackCtl) >> 2) + f->num_keysyms))
-	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
+	    return BadLength;
-			      0, BadLength);
+
-	    return Success;
-	}
 	for (s = dev->stringfeed; s; s = s->next)
-	    if (s->ctrl.id == ((xStringFeedbackCtl *) & stuff[1])->id) {
+	    if (s->ctrl.id == ((xStringFeedbackCtl *) & stuff[1])->id)
-		ChangeStringFeedback(client, dev, stuff->mask, s,
+		return ChangeStringFeedback(client, dev, stuff->mask, s,
-				     (xStringFeedbackCtl *) & stuff[1]);
+					    (xStringFeedbackCtl *) & stuff[1]);
-		return Success;
-	    }
 	break;
     }
     case IntegerFeedbackClass:
-	if (len != (sizeof(xIntegerFeedbackCtl) >> 2)) {
+	if (len != (sizeof(xIntegerFeedbackCtl) >> 2))
-	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
+	    return BadLength;
-			      0, BadLength);
+
-	    return Success;
-	}
 	for (i = dev->intfeed; i; i = i->next)
-	    if (i->ctrl.id == ((xIntegerFeedbackCtl *) & stuff[1])->id) {
+	    if (i->ctrl.id == ((xIntegerFeedbackCtl *) & stuff[1])->id)
-		ChangeIntegerFeedback(client, dev, stuff->mask, i,
+		return ChangeIntegerFeedback(client, dev, stuff->mask, i,
-				      (xIntegerFeedbackCtl *) & stuff[1]);
+					     (xIntegerFeedbackCtl *)&stuff[1]);
-		return Success;
-	    }
 	break;
     case LedFeedbackClass:
-	if (len != (sizeof(xLedFeedbackCtl) >> 2)) {
+	if (len != (sizeof(xLedFeedbackCtl) >> 2))
-	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
+	    return BadLength;
-			      0, BadLength);
+
-	    return Success;
-	}
 	for (l = dev->leds; l; l = l->next)
-	    if (l->ctrl.id == ((xLedFeedbackCtl *) & stuff[1])->id) {
+	    if (l->ctrl.id == ((xLedFeedbackCtl *) & stuff[1])->id)
-		ChangeLedFeedback(client, dev, stuff->mask, l,
+		return ChangeLedFeedback(client, dev, stuff->mask, l,
-				  (xLedFeedbackCtl *) & stuff[1]);
+					 (xLedFeedbackCtl *) & stuff[1]);
-		return Success;
-	    }
 	break;
     case BellFeedbackClass:
-	if (len != (sizeof(xBellFeedbackCtl) >> 2)) {
+	if (len != (sizeof(xBellFeedbackCtl) >> 2))
-	    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
+	    return BadLength;
-			      0, BadLength);
+
-	    return Success;
-	}
 	for (b = dev->bell; b; b = b->next)
-	    if (b->ctrl.id == ((xBellFeedbackCtl *) & stuff[1])->id) {
+	    if (b->ctrl.id == ((xBellFeedbackCtl *) & stuff[1])->id)
-		ChangeBellFeedback(client, dev, stuff->mask, b,
+		return ChangeBellFeedback(client, dev, stuff->mask, b,
-				   (xBellFeedbackCtl *) & stuff[1]);
+					  (xBellFeedbackCtl *) & stuff[1]);
-		return Success;
-	    }
 	break;
     default:
 	break;
     }
 
-    SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0, BadMatch);
+    return BadMatch;
-    return Success;
 }
 

Xi/chgkbd.c

@@ -56,14 +56,11 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "XIstubs.h"
 #include "globals.h"
-#include "extnsionst.h"
 
 #include "exevents.h"
 #include "exglobals.h"
@@ -98,10 +95,8 @@ SProcXChangeKeyboardDevice(ClientPtr client)
 int
 ProcXChangeKeyboardDevice(ClientPtr client)
 {
-    REQUEST(xChangeKeyboardDeviceReq);
+    /* REQUEST(xChangeKeyboardDeviceReq); */
     REQUEST_SIZE_MATCH(xChangeKeyboardDeviceReq);
 
-    SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0,
+    return BadDevice;
-                      BadDevice);
-    return Success;
 }

Xi/chgkmap.c

@@ -56,12 +56,9 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exevents.h"
 #include "exglobals.h"
@@ -111,18 +108,13 @@ ProcXChangeDeviceKeyMapping(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xChangeDeviceKeyMappingReq);
 
     dev = LookupDeviceIntRec(stuff->deviceid);
-    if (dev == NULL) {
+    if (dev == NULL)
-	SendErrorToClient(client, IReqCode, X_ChangeDeviceKeyMapping, 0,
+	return BadDevice;
-			  BadDevice);
-	return Success;
-    }
     len = stuff->length - (sizeof(xChangeDeviceKeyMappingReq) >> 2);
 
     ret = ChangeKeyMapping(client, dev, len, DeviceMappingNotify,
 			   stuff->firstKeyCode, stuff->keyCodes,
 			   stuff->keySymsPerKeyCode, (KeySym *) & stuff[1]);
 
-    if (ret != Success)
+    return ret;
-	SendErrorToClient(client, IReqCode, X_ChangeDeviceKeyMapping, 0, ret);
-    return Success;
 }

Xi/chgprop.c

@@ -56,13 +56,10 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include "windowstr.h"
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 
 #include "exevents.h"
@@ -115,30 +112,22 @@ ProcXChangeDeviceDontPropagateList(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xChangeDeviceDontPropagateListReq);
 
     if (stuff->length != (sizeof(xChangeDeviceDontPropagateListReq) >> 2) +
-	stuff->count) {
+	stuff->count)
-	SendErrorToClient(client, IReqCode, X_ChangeDeviceDontPropagateList, 0,
+	return BadLength;
-			  BadLength);
-	return Success;
-    }
 
     rc = dixLookupWindow(&pWin, stuff->window, client, DixUnknownAccess);
-    if (rc != Success) {
+    if (rc != Success)
-	SendErrorToClient(client, IReqCode, X_ChangeDeviceDontPropagateList, 0,
+	return rc;
-			  rc);
-	return Success;
-    }
 
     if (stuff->mode != AddToList && stuff->mode != DeleteFromList) {
 	client->errorValue = stuff->window;
-	SendErrorToClient(client, IReqCode, X_ChangeDeviceDontPropagateList, 0,
+	return BadMode;
-			  BadMode);
-	return Success;
     }
 
-    if (CreateMaskFromList(client, (XEventClass *) & stuff[1],
+    if ((rc = CreateMaskFromList(client, (XEventClass *) & stuff[1],
-			   stuff->count, tmp, NULL,
+				 stuff->count, tmp, NULL,
-			   X_ChangeDeviceDontPropagateList) != Success)
+				 X_ChangeDeviceDontPropagateList)) != Success)
-	return Success;
+	return rc;
 
     others = wOtherInputMasks(pWin);
     if (!others && stuff->mode == DeleteFromList)
@@ -153,11 +142,8 @@ ProcXChangeDeviceDontPropagateList(ClientPtr client)
 	    tmp[i].mask |= others->dontPropagateMask[i];
 
 	if (DeviceEventSuppressForWindow(pWin, client, tmp[i].mask, i) !=
-	    Success) {
+	    Success)
-	    SendErrorToClient(client, IReqCode,
+	    return BadClass;
-			      X_ChangeDeviceDontPropagateList, 0, BadClass);
-	    return Success;
-	}
     }
 
     return Success;

Xi/chgptr.c

@@ -56,8 +56,6 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
@@ -65,7 +63,6 @@ SOFTWARE.
 #include "windowstr.h"	/* window structure  */
 #include "scrnintstr.h"	/* screen structure  */
 
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 
 #include "dixevents.h"
@@ -101,10 +98,8 @@ SProcXChangePointerDevice(ClientPtr client)
 int
 ProcXChangePointerDevice(ClientPtr client)
 {
-    REQUEST(xChangePointerDeviceReq);
+    /* REQUEST(xChangePointerDeviceReq); */
     REQUEST_SIZE_MATCH(xChangePointerDeviceReq);
 
-    SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0,
+    return BadDevice;
-                      BadDevice);
-    return Success;
 }

Xi/closedev.c

@@ -56,15 +56,12 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include "windowstr.h"	/* window structure  */
 #include "scrnintstr.h"	/* screen structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "XIstubs.h"
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
@@ -151,10 +148,8 @@ ProcXCloseDevice(ClientPtr client)
     REQUEST_SIZE_MATCH(xCloseDeviceReq);
 
     d = LookupDeviceIntRec(stuff->deviceid);
-    if (d == NULL) {
+    if (d == NULL)
-	SendErrorToClient(client, IReqCode, X_CloseDevice, 0, BadDevice);
+	return BadDevice;
-	return Success;
-    }
 
     if (d->deviceGrab.grab && SameClient(d->deviceGrab.grab, client))
 	(*d->deviceGrab.DeactivateGrab) (d);	/* release active grab */

Xi/devbell.c

@@ -56,12 +56,9 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
@@ -108,14 +105,12 @@ ProcXDeviceBell(ClientPtr client)
     dev = LookupDeviceIntRec(stuff->deviceid);
     if (dev == NULL) {
 	client->errorValue = stuff->deviceid;
-	SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadDevice);
+	return BadDevice;
-	return Success;
     }
 
     if (stuff->percent < -100 || stuff->percent > 100) {
 	client->errorValue = stuff->percent;
-	SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadValue);
+	return BadValue;
-	return Success;
     }
     if (stuff->feedbackclass == KbdFeedbackClass) {
 	for (k = dev->kbdfeed; k; k = k->next)
@@ -123,8 +118,7 @@ ProcXDeviceBell(ClientPtr client)
 		break;
 	if (!k) {
 	    client->errorValue = stuff->feedbackid;
-	    SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadValue);
+	    return BadValue;
-	    return Success;
 	}
 	base = k->ctrl.bell;
 	proc = k->BellProc;
@@ -136,8 +130,7 @@ ProcXDeviceBell(ClientPtr client)
 		break;
 	if (!b) {
 	    client->errorValue = stuff->feedbackid;
-	    SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadValue);
+	    return BadValue;
-	    return Success;
 	}
 	base = b->ctrl.percent;
 	proc = b->BellProc;
@@ -145,8 +138,7 @@ ProcXDeviceBell(ClientPtr client)
 	class = BellFeedbackClass;
     } else {
 	client->errorValue = stuff->feedbackclass;
-	SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadValue);
+	return BadValue;
-	return Success;
     }
     newpercent = (base * stuff->percent) / 100;
     if (stuff->percent < 0)

Xi/exevents.c

@@ -74,6 +74,10 @@ SOFTWARE.
 #include "dixgrabs.h"	/* CreateGrab() */
 #include "scrnintstr.h"
 
+#ifdef XKB
+#include "xkbsrv.h"
+#endif
+
 #define WID(w) ((w) ? ((w)->drawable.id) : 0)
 #define AllModifiersMask ( \
 	ShiftMask | LockMask | ControlMask | Mod1Mask | Mod2Mask | \
@@ -1005,7 +1009,7 @@ SetModifierMapping(ClientPtr client, DeviceIntPtr dev, int len, int rlen,
 }
 
 void
-SendDeviceMappingNotify(CARD8 request,
+SendDeviceMappingNotify(ClientPtr client, CARD8 request,
 			KeyCode firstKeyCode, CARD8 count, DeviceIntPtr dev)
 {
     xEvent event;
@@ -1020,6 +1024,11 @@ SendDeviceMappingNotify(CARD8 request,
 	ev->count = count;
     }
 
+#ifdef XKB
+    if (request == MappingKeyboard || request == MappingModifier)
+        XkbApplyMappingChange(dev, request, firstKeyCode, count, client);
+#endif
+
     SendEventToAllWindows(dev, DeviceMappingNotifyMask, (xEvent *) ev, 1);
 }
 
@@ -1055,7 +1064,7 @@ ChangeKeyMapping(ClientPtr client,
     keysyms.map = map;
     if (!SetKeySymsMap(&k->curKeySyms, &keysyms))
 	return BadAlloc;
-    SendDeviceMappingNotify(MappingKeyboard, firstKeyCode, keyCodes, dev);
+    SendDeviceMappingNotify(client, MappingKeyboard, firstKeyCode, keyCodes, dev);
     return client->noClientException;
 }
 

Xi/extinit.c

@@ -58,8 +58,6 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>
-#include <X11/Xproto.h>
 #include "inputstr.h"
 #include "gcstruct.h"	/* pointer for extnsionst.h */
 #include "extnsionst.h"	/* extension entry   */
@@ -1209,6 +1207,7 @@ XInputExtensionInit(void)
 	EventSwapVector[DeviceButtonStateNotify] = SEventIDispatch;
 	EventSwapVector[DeviceMappingNotify] = SEventIDispatch;
 	EventSwapVector[ChangeDeviceNotify] = SEventIDispatch;
+	EventSwapVector[DevicePresenceNotify] = SEventIDispatch;
 	EventSwapVector[DeviceEnterNotify] = SEventIDispatch;
 	EventSwapVector[DeviceLeaveNotify] = SEventIDispatch;
 

Xi/getbmap.c

@@ -56,12 +56,9 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
@@ -106,18 +103,13 @@ ProcXGetDeviceButtonMapping(ClientPtr client)
     rep.sequenceNumber = client->sequence;
 
     dev = LookupDeviceIntRec(stuff->deviceid);
-    if (dev == NULL) {
+    if (dev == NULL)
-	SendErrorToClient(client, IReqCode, X_GetDeviceButtonMapping, 0,
+	return BadDevice;
-			  BadDevice);
-	return Success;
-    }
 
     b = dev->button;
-    if (b == NULL) {
+    if (b == NULL)
-	SendErrorToClient(client, IReqCode, X_GetDeviceButtonMapping, 0,
+	return BadMatch;
-			  BadMatch);
+
-	return Success;
-    }
     rep.nElts = b->numButtons;
     rep.length = (rep.nElts + (4 - 1)) / 4;
     WriteReplyToClient(client, sizeof(xGetDeviceButtonMappingReply), &rep);

Xi/getdctl.c

@@ -56,12 +56,9 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
@@ -250,10 +247,8 @@ ProcXGetDeviceControl(ClientPtr client)
     REQUEST_SIZE_MATCH(xGetDeviceControlReq);
 
     dev = LookupDeviceIntRec(stuff->deviceid);
-    if (dev == NULL) {
+    if (dev == NULL)
-	SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0, BadDevice);
+	return BadDevice;
-	return Success;
-    }
 
     rep.repType = X_Reply;
     rep.RepType = X_GetDeviceControl;
@@ -262,29 +257,20 @@ ProcXGetDeviceControl(ClientPtr client)
 
     switch (stuff->control) {
     case DEVICE_RESOLUTION:
-	if (!dev->valuator) {
+	if (!dev->valuator)
-	    SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0,
+	    return BadMatch;
-			      BadMatch);
-	    return Success;
-	}
 	total_length = sizeof(xDeviceResolutionState) +
 	    (3 * sizeof(int) * dev->valuator->numAxes);
 	break;
     case DEVICE_ABS_CALIB:
-        if (!dev->absolute) {
+        if (!dev->absolute)
-            SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0,
+	    return BadMatch;
-                              BadMatch);
-            return Success;
-        }
 
         total_length = sizeof(xDeviceAbsCalibCtl);
         break;
     case DEVICE_ABS_AREA:
-        if (!dev->absolute) {
+        if (!dev->absolute)
-            SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0,
+	    return BadMatch;
-                              BadMatch);
-            return Success;
-        }
 
         total_length = sizeof(xDeviceAbsAreaCtl);
         break;
@@ -295,15 +281,12 @@ ProcXGetDeviceControl(ClientPtr client)
         total_length = sizeof(xDeviceEnableCtl);
         break;
     default:
-	SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0, BadValue);
+	return BadValue;
-	return Success;
     }
 
     buf = (char *)xalloc(total_length);
-    if (!buf) {
+    if (!buf)
-	SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0, BadAlloc);
+	return BadAlloc;
-	return Success;
-    }
     savbuf = buf;
 
     switch (stuff->control) {

Xi/getfctl.c

@@ -56,12 +56,9 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
@@ -308,10 +305,8 @@ ProcXGetFeedbackControl(ClientPtr client)
     REQUEST_SIZE_MATCH(xGetFeedbackControlReq);
 
     dev = LookupDeviceIntRec(stuff->deviceid);
-    if (dev == NULL) {
+    if (dev == NULL)
-	SendErrorToClient(client, IReqCode, X_GetFeedbackControl, 0, BadDevice);
+	return BadDevice;
-	return Success;
-    }
 
     rep.repType = X_Reply;
     rep.RepType = X_GetFeedbackControl;
@@ -345,16 +340,12 @@ ProcXGetFeedbackControl(ClientPtr client)
 	total_length += sizeof(xBellFeedbackState);
     }
 
-    if (total_length == 0) {
+    if (total_length == 0)
-	SendErrorToClient(client, IReqCode, X_GetFeedbackControl, 0, BadMatch);
+	return BadMatch;
-	return Success;
-    }
 
     buf = (char *)xalloc(total_length);
-    if (!buf) {
+    if (!buf)
-	SendErrorToClient(client, IReqCode, X_GetFeedbackControl, 0, BadAlloc);
+	return BadAlloc;
-	return Success;
-    }
     savbuf = buf;
 
     for (k = dev->kbdfeed; k; k = k->next)

Xi/getfocus.c

@@ -56,13 +56,10 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "windowstr.h"	/* focus struct      */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
@@ -101,10 +98,8 @@ ProcXGetDeviceFocus(ClientPtr client)
     REQUEST_SIZE_MATCH(xGetDeviceFocusReq);
 
     dev = LookupDeviceIntRec(stuff->deviceid);
-    if (dev == NULL || !dev->focus) {
+    if (dev == NULL || !dev->focus)
-	SendErrorToClient(client, IReqCode, X_GetDeviceFocus, 0, BadDevice);
+	return BadDevice;
-	return Success;
-    }
 
     rep.repType = X_Reply;
     rep.RepType = X_GetDeviceFocus;

Xi/getkmap.c

@@ -56,12 +56,9 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 #include "swaprep.h"
@@ -102,29 +99,21 @@ ProcXGetDeviceKeyMapping(ClientPtr client)
     REQUEST_SIZE_MATCH(xGetDeviceKeyMappingReq);
 
     dev = LookupDeviceIntRec(stuff->deviceid);
-    if (dev == NULL) {
+    if (dev == NULL)
-	SendErrorToClient(client, IReqCode, X_GetDeviceKeyMapping, 0,
+	return BadDevice;
-			  BadDevice);
+    if (dev->key == NULL)
-	return Success;
+	return BadMatch;
-    }
-
-    if (dev->key == NULL) {
-	SendErrorToClient(client, IReqCode, X_GetDeviceKeyMapping, 0, BadMatch);
-	return Success;
-    }
     k = &dev->key->curKeySyms;
 
     if ((stuff->firstKeyCode < k->minKeyCode) ||
 	(stuff->firstKeyCode > k->maxKeyCode)) {
 	client->errorValue = stuff->firstKeyCode;
-	SendErrorToClient(client, IReqCode, X_GetDeviceKeyMapping, 0, BadValue);
+	return BadValue;
-	return Success;
     }
 
     if (stuff->firstKeyCode + stuff->count > k->maxKeyCode + 1) {
 	client->errorValue = stuff->count;
-	SendErrorToClient(client, IReqCode, X_GetDeviceKeyMapping, 0, BadValue);
+	return BadValue;
-	return Success;
     }
 
     rep.repType = X_Reply;

Xi/getmmap.c

@@ -56,12 +56,9 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>	/* Request macro     */
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
@@ -102,18 +99,13 @@ ProcXGetDeviceModifierMapping(ClientPtr client)
     REQUEST_SIZE_MATCH(xGetDeviceModifierMappingReq);
 
     dev = LookupDeviceIntRec(stuff->deviceid);
-    if (dev == NULL) {
+    if (dev == NULL)
-	SendErrorToClient(client, IReqCode, X_GetDeviceModifierMapping, 0,
+	return BadDevice;
-			  BadDevice);
-	return Success;
-    }
 
     kp = dev->key;
-    if (kp == NULL) {
+    if (kp == NULL)
-	SendErrorToClient(client, IReqCode, X_GetDeviceModifierMapping, 0,
+	return BadMatch;
-			  BadMatch);
+
-	return Success;
-    }
     maxkeys = kp->maxKeysPerModifier;
 
     rep.repType = X_Reply;

Xi/getprop.c

@@ -56,13 +56,10 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include "windowstr.h"	/* window structs    */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 #include "swaprep.h"
@@ -116,11 +113,8 @@ ProcXGetDeviceDontPropagateList(ClientPtr client)
     rep.count = 0;
 
     rc = dixLookupWindow(&pWin, stuff->window, client, DixUnknownAccess);
-    if (rc != Success) {
+    if (rc != Success)
-	SendErrorToClient(client, IReqCode, X_GetDeviceDontPropagateList, 0,
+	return rc;
-			  rc);
-	return Success;
-    }
 
     if ((others = wOtherInputMasks(pWin)) != 0) {
 	for (i = 0; i < EMASKSIZE; i++)

Xi/getselev.c

@@ -56,13 +56,10 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include "windowstr.h"	/* window struct     */
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 #include "swaprep.h"
@@ -118,11 +115,8 @@ ProcXGetSelectedExtensionEvents(ClientPtr client)
     rep.all_clients_count = 0;
 
     rc = dixLookupWindow(&pWin, stuff->window, client, DixUnknownAccess);
-    if (rc != Success) {
+    if (rc != Success)
-	SendErrorToClient(client, IReqCode, X_GetSelectedExtensionEvents, 0,
+	return rc;
-			  rc);
-	return Success;
-    }
 
     if ((pOthers = wOtherInputMasks(pWin)) != 0) {
 	for (others = pOthers->inputClients; others; others = others->next)

Xi/getvers.c

@@ -56,12 +56,9 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
@@ -102,11 +99,8 @@ ProcXGetExtensionVersion(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xGetExtensionVersionReq);
 
     if (stuff->length != (sizeof(xGetExtensionVersionReq) +
-			  stuff->nbytes + 3) >> 2) {
+			  stuff->nbytes + 3) >> 2)
-	SendErrorToClient(client, IReqCode, X_GetExtensionVersion, 0,
+	return BadLength;
-			  BadLength);
-	return Success;
-    }
 
     rep.repType = X_Reply;
     rep.RepType = X_GetExtensionVersion;

Xi/grabdev.c

@@ -56,13 +56,10 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include "windowstr.h"	/* window structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 #include "dixevents.h"	/* GrabDevice */
@@ -109,7 +106,7 @@ SProcXGrabDevice(ClientPtr client)
 int
 ProcXGrabDevice(ClientPtr client)
 {
-    int error;
+    int rc;
     xGrabDeviceReply rep;
     DeviceIntPtr dev;
     struct tmask tmp[EMASKSIZE];
@@ -117,10 +114,8 @@ ProcXGrabDevice(ClientPtr client)
     REQUEST(xGrabDeviceReq);
     REQUEST_AT_LEAST_SIZE(xGrabDeviceReq);
 
-    if (stuff->length != (sizeof(xGrabDeviceReq) >> 2) + stuff->event_count) {
+    if (stuff->length != (sizeof(xGrabDeviceReq) >> 2) + stuff->event_count)
-	SendErrorToClient(client, IReqCode, X_GrabDevice, 0, BadLength);
+	return BadLength;
-	return Success;
-    }
 
     rep.repType = X_Reply;
     rep.RepType = X_GrabDevice;
@@ -128,25 +123,22 @@ ProcXGrabDevice(ClientPtr client)
     rep.length = 0;
 
     dev = LookupDeviceIntRec(stuff->deviceid);
-    if (dev == NULL) {
+    if (dev == NULL)
-	SendErrorToClient(client, IReqCode, X_GrabDevice, 0, BadDevice);
+	return BadDevice;
-	return Success;
-    }
 
-    if (CreateMaskFromList(client, (XEventClass *) & stuff[1],
+    if ((rc = CreateMaskFromList(client, (XEventClass *) & stuff[1],
-			   stuff->event_count, tmp, dev,
+				 stuff->event_count, tmp, dev,
-			   X_GrabDevice) != Success)
+				 X_GrabDevice)) != Success)
-	return Success;
+	return rc;
 
-    error = GrabDevice(client, dev, stuff->this_device_mode,
+    rc = GrabDevice(client, dev, stuff->this_device_mode,
-		       stuff->other_devices_mode, stuff->grabWindow,
+		    stuff->other_devices_mode, stuff->grabWindow,
-		       stuff->ownerEvents, stuff->time,
+		    stuff->ownerEvents, stuff->time,
-		       tmp[stuff->deviceid].mask, &rep.status, FALSE);
+		    tmp[stuff->deviceid].mask, &rep.status, FALSE);
+
+    if (rc != Success)
+	return rc;
 
-    if (error != Success) {
-	SendErrorToClient(client, IReqCode, X_GrabDevice, 0, error);
-	return Success;
-    }
     WriteReplyToClient(client, sizeof(xGrabDeviceReply), &rep);
     return Success;
 }
@@ -190,15 +182,12 @@ CreateMaskFromList(ClientPtr client, XEventClass * list, int count,
 
     for (i = 0; i < count; i++, list++) {
 	device = *list >> 8;
-	if (device > 255) { /* FIXME: we only use 7 bit for devices? */
+	if (device > 255) /* FIXME: we only use 7 bit for devices? */
-	    SendErrorToClient(client, IReqCode, req, 0, BadClass);
 	    return BadClass;
-	}
+
 	tdev = LookupDeviceIntRec(device);
-	if (tdev == NULL || (dev != NULL && tdev != dev)) {
+	if (tdev == NULL || (dev != NULL && tdev != dev))
-	    SendErrorToClient(client, IReqCode, req, 0, BadClass);
 	    return BadClass;
-	}
 
 	for (j = 0; j < ExtEventIndex; j++)
 	    if (EventInfo[j].type == (*list & 0xff)) {

Xi/grabdevb.c

@@ -56,14 +56,11 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include "windowstr.h"	/* window structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exevents.h"
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
@@ -117,28 +114,19 @@ ProcXGrabDeviceButton(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xGrabDeviceButtonReq);
 
     if (stuff->length !=
-	(sizeof(xGrabDeviceButtonReq) >> 2) + stuff->event_count) {
+	(sizeof(xGrabDeviceButtonReq) >> 2) + stuff->event_count)
-	SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0, BadLength);
+	return BadLength;
-	return Success;
-    }
 
     dev = LookupDeviceIntRec(stuff->grabbed_device);
-    if (dev == NULL) {
+    if (dev == NULL)
-	SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0, BadDevice);
+	return BadDevice;
-	return Success;
+
-    }
     if (stuff->modifier_device != UseXKeyboard) {
 	mdev = LookupDeviceIntRec(stuff->modifier_device);
-	if (mdev == NULL) {
+	if (mdev == NULL)
-	    SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0,
+	    return BadDevice;
-			      BadDevice);
+	if (mdev->key == NULL)
-	    return Success;
+	    return BadMatch;
-	}
-	if (mdev->key == NULL) {
-	    SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0,
-			      BadMatch);
-	    return Success;
-	}
     } else
 	mdev = PickKeyboard(client);
 
@@ -147,13 +135,11 @@ ProcXGrabDeviceButton(ClientPtr client)
     if ((ret = CreateMaskFromList(client, class,
 				  stuff->event_count, tmp, dev,
 				  X_GrabDeviceButton)) != Success)
-	return Success;
+	return ret;
     ret = GrabButton(client, dev, stuff->this_device_mode,
 		     stuff->other_devices_mode, stuff->modifiers, mdev,
 		     stuff->button, stuff->grabWindow, stuff->ownerEvents,
 		     (Cursor) 0, (Window) 0, tmp[stuff->grabbed_device].mask);
 
-    if (ret != Success)
+    return ret;
-	SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0, ret);
-    return (Success);
 }

Xi/grabdevk.c

@@ -56,14 +56,11 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include "windowstr.h"	/* window structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exevents.h"
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
@@ -115,27 +112,19 @@ ProcXGrabDeviceKey(ClientPtr client)
     REQUEST(xGrabDeviceKeyReq);
     REQUEST_AT_LEAST_SIZE(xGrabDeviceKeyReq);
 
-    if (stuff->length != (sizeof(xGrabDeviceKeyReq) >> 2) + stuff->event_count) {
+    if (stuff->length != (sizeof(xGrabDeviceKeyReq) >> 2) + stuff->event_count)
-	SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, BadLength);
+	return BadLength;
-	return Success;
-    }
 
     dev = LookupDeviceIntRec(stuff->grabbed_device);
-    if (dev == NULL) {
+    if (dev == NULL)
-	SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, BadDevice);
+	return BadDevice;
-	return Success;
-    }
 
     if (stuff->modifier_device != UseXKeyboard) {
 	mdev = LookupDeviceIntRec(stuff->modifier_device);
-	if (mdev == NULL) {
+	if (mdev == NULL)
-	    SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, BadDevice);
+	    return BadDevice;
-	    return Success;
+	if (mdev->key == NULL)
-	}
+	    return BadMatch;
-	if (mdev->key == NULL) {
-	    SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, BadMatch);
-	    return Success;
-	}
     } else
 	mdev = PickKeyboard(client);
 
@@ -144,17 +133,12 @@ ProcXGrabDeviceKey(ClientPtr client)
     if ((ret = CreateMaskFromList(client, class,
 				  stuff->event_count, tmp, dev,
 				  X_GrabDeviceKey)) != Success)
-	return Success;
+	return ret;
 
     ret = GrabKey(client, dev, stuff->this_device_mode,
 		  stuff->other_devices_mode, stuff->modifiers, mdev,
 		  stuff->key, stuff->grabWindow, stuff->ownerEvents,
 		  tmp[stuff->grabbed_device].mask);
 
-    if (ret != Success) {
+    return ret;
-	SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, ret);
-	return Success;
-    }
-
-    return Success;
 }

Xi/gtmotion.c

@@ -56,12 +56,9 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exevents.h"
 #include "exglobals.h"
@@ -110,17 +107,11 @@ ProcXGetDeviceMotionEvents(ClientPtr client)
 
     REQUEST_SIZE_MATCH(xGetDeviceMotionEventsReq);
     dev = LookupDeviceIntRec(stuff->deviceid);
-    if (dev == NULL) {
+    if (dev == NULL)
-	SendErrorToClient(client, IReqCode, X_GetDeviceMotionEvents, 0,
+	return BadDevice;
-			  BadDevice);
-	return Success;
-    }
     v = dev->valuator;
-    if (v == NULL || v->numAxes == 0) {
+    if (v == NULL || v->numAxes == 0)
-	SendErrorToClient(client, IReqCode, X_GetDeviceMotionEvents, 0,
+	return BadMatch;
-			  BadMatch);
-	return Success;
-    }
     if (dev->valuator->motionHintWindow)
 	MaybeStopDeviceHint(dev, client);
     axes = v->numAxes;
@@ -144,12 +135,9 @@ ProcXGetDeviceMotionEvents(ClientPtr client)
     if (num_events) {
 	size = sizeof(Time) + (axes * sizeof(INT32));
 	tsize = num_events * size;
-	coords = (INT32 *) ALLOCATE_LOCAL(tsize);
+	coords = (INT32 *) xalloc(tsize);
-	if (!coords) {
+	if (!coords)
-	    SendErrorToClient(client, IReqCode, X_GetDeviceMotionEvents, 0,
+	    return BadAlloc;
-			      BadAlloc);
-	    return Success;
-	}
 	rep.nEvents = (v->GetMotionProc) (dev, (xTimecoord *) coords,	/* XXX */
 					  start.milliseconds, stop.milliseconds,
 					  (ScreenPtr) NULL);
@@ -173,7 +161,7 @@ ProcXGetDeviceMotionEvents(ClientPtr client)
 	WriteToClient(client, length * 4, (char *)coords);
     }
     if (coords)
-	DEALLOCATE_LOCAL(coords);
+	xfree(coords);
     return Success;
 }
 

Xi/opendev.c

@@ -56,14 +56,11 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "XIstubs.h"
 #include "windowstr.h"	/* window structure  */
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
@@ -110,17 +107,13 @@ ProcXOpenDevice(ClientPtr client)
 	for (dev = inputInfo.off_devices; dev; dev = dev->next)
 	    if (dev->id == stuff->deviceid)
 		break;
-	if (dev == NULL) {
+	if (dev == NULL)
-	    SendErrorToClient(client, IReqCode, X_OpenDevice, 0, BadDevice);
+	    return BadDevice;
-	    return Success;
-	}
     }
 
     OpenInputDevice(dev, client, &status);
-    if (status != Success) {
+    if (status != Success)
-	SendErrorToClient(client, IReqCode, X_OpenDevice, 0, status);
+	return status;
-	return Success;
-    }
 
     rep.repType = X_Reply;
     rep.RepType = X_OpenDevice;

Xi/queryst.c

@@ -38,13 +38,10 @@ from The Open Group.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include "windowstr.h"	/* window structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exevents.h"
 #include "exglobals.h"
@@ -100,10 +97,8 @@ ProcXQueryDeviceState(ClientPtr client)
     rep.sequenceNumber = client->sequence;
 
     dev = LookupDeviceIntRec(stuff->deviceid);
-    if (dev == NULL) {
+    if (dev == NULL)
-	SendErrorToClient(client, IReqCode, X_QueryDeviceState, 0, BadDevice);
+	return BadDevice;
-	return Success;
-    }
 
     v = dev->valuator;
     if (v != NULL && v->motionHintWindow != NULL)
@@ -126,10 +121,8 @@ ProcXQueryDeviceState(ClientPtr client)
 	num_classes++;
     }
     buf = (char *)xalloc(total_length);
-    if (!buf) {
+    if (!buf)
-	SendErrorToClient(client, IReqCode, X_QueryDeviceState, 0, BadAlloc);
+	return BadAlloc;
-	return Success;
-    }
     savbuf = buf;
 
     if (k != NULL) {

Xi/selectev.c

@@ -57,13 +57,10 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include "windowstr.h"	/* window structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exevents.h"
 #include "exglobals.h"
@@ -164,40 +161,29 @@ ProcXSelectExtensionEvent(ClientPtr client)
     REQUEST(xSelectExtensionEventReq);
     REQUEST_AT_LEAST_SIZE(xSelectExtensionEventReq);
 
-    if (stuff->length != (sizeof(xSelectExtensionEventReq) >> 2) + stuff->count) {
+    if (stuff->length != (sizeof(xSelectExtensionEventReq) >> 2) + stuff->count)
-	SendErrorToClient(client, IReqCode, X_SelectExtensionEvent, 0,
+	return BadLength;
-			  BadLength);
-	return Success;
-    }
 
     ret = dixLookupWindow(&pWin, stuff->window, client, DixUnknownAccess);
-    if (ret != Success) {
+    if (ret != Success)
-	SendErrorToClient(client, IReqCode, X_SelectExtensionEvent, 0, ret);
+	return ret;
-	return Success;
-    }
 
     if (HandleDevicePresenceMask(client, pWin, (XEventClass *) & stuff[1],
-                                &stuff->count) != Success) {
+                                &stuff->count) != Success)
-       SendErrorToClient(client, IReqCode, X_SelectExtensionEvent, 0,
+	return BadAlloc;
-                         BadAlloc);
-       return Success;
-    }
 
     if ((ret = CreateMaskFromList(client, (XEventClass *) & stuff[1],
 				  stuff->count, tmp, NULL,
 				  X_SelectExtensionEvent)) != Success)
-	return Success;
+	return ret;
 
     for (i = 0; i < EMASKSIZE; i++)
 	if (tmp[i].dev != NULL) {
 	    if ((ret =
 		 SelectForWindow((DeviceIntPtr) tmp[i].dev, pWin, client,
 				 tmp[i].mask, ExtExclusiveMasks[i],
-				 ExtValidMasks[i])) != Success) {
+				 ExtValidMasks[i])) != Success)
-		SendErrorToClient(client, IReqCode, X_SelectExtensionEvent, 0,
+		return ret;
-				  ret);
-		return Success;
-	    }
 	}
 
     return Success;

Xi/sendexev.c

@@ -57,13 +57,10 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include "windowstr.h"	/* Window            */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exevents.h"
 #include "exglobals.h"
@@ -131,38 +128,29 @@ ProcXSendExtensionEvent(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xSendExtensionEventReq);
 
     if (stuff->length != (sizeof(xSendExtensionEventReq) >> 2) + stuff->count +
-	(stuff->num_events * (sizeof(xEvent) >> 2))) {
+	(stuff->num_events * (sizeof(xEvent) >> 2)))
-	SendErrorToClient(client, IReqCode, X_SendExtensionEvent, 0, BadLength);
+	return BadLength;
-	return Success;
-    }
 
     dev = LookupDeviceIntRec(stuff->deviceid);
-    if (dev == NULL) {
+    if (dev == NULL)
-	SendErrorToClient(client, IReqCode, X_SendExtensionEvent, 0, BadDevice);
+	return BadDevice;
-	return Success;
-    }
 
     /* The client's event type must be one defined by an extension. */
 
     first = ((xEvent *) & stuff[1]);
     if (!((EXTENSION_EVENT_BASE <= first->u.u.type) &&
-	  (first->u.u.type < lastEvent))) {
+	  (first->u.u.type < lastEvent)))
 	client->errorValue = first->u.u.type;
-	SendErrorToClient(client, IReqCode, X_SendExtensionEvent, 0, BadValue);
+	return BadValue;
-	return Success;
-    }
 
     list = (XEventClass *) (first + stuff->num_events);
     if ((ret = CreateMaskFromList(client, list, stuff->count, tmp, dev,
 				  X_SendExtensionEvent)) != Success)
-	return Success;
+	return ret;
 
     ret = (SendEvent(client, dev, stuff->destination,
 		     stuff->propagate, (xEvent *) & stuff[1],
 		     tmp[stuff->deviceid].mask, stuff->num_events));
 
-    if (ret != Success)
+    return ret;
-	SendErrorToClient(client, IReqCode, X_SendExtensionEvent, 0, ret);
-
-    return Success;
 }

Xi/setbmap.c

@@ -59,13 +59,10 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exevents.h"
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
@@ -104,11 +101,8 @@ ProcXSetDeviceButtonMapping(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xSetDeviceButtonMappingReq);
 
     if (stuff->length != (sizeof(xSetDeviceButtonMappingReq) +
-			  stuff->map_length + 3) >> 2) {
+			  stuff->map_length + 3) >> 2)
-	SendErrorToClient(client, IReqCode, X_SetDeviceButtonMapping, 0,
+	return BadLength;
-			  BadLength);
-	return Success;
-    }
 
     rep.repType = X_Reply;
     rep.RepType = X_SetDeviceButtonMapping;
@@ -117,24 +111,20 @@ ProcXSetDeviceButtonMapping(ClientPtr client)
     rep.status = MappingSuccess;
 
     dev = LookupDeviceIntRec(stuff->deviceid);
-    if (dev == NULL) {
+    if (dev == NULL)
-	SendErrorToClient(client, IReqCode, X_SetDeviceButtonMapping, 0,
+	return BadDevice;
-			  BadDevice);
-	return Success;
-    }
 
     ret = SetButtonMapping(client, dev, stuff->map_length, (BYTE *) & stuff[1]);
 
-    if (ret == BadValue || ret == BadMatch) {
+    if (ret == BadValue || ret == BadMatch)
-	SendErrorToClient(client, IReqCode, X_SetDeviceButtonMapping, 0, ret);
+	return ret;
-	return Success;
+    else {
-    } else {
 	rep.status = ret;
 	WriteReplyToClient(client, sizeof(xSetDeviceButtonMappingReply), &rep);
     }
 
     if (ret != MappingBusy)
-	SendDeviceMappingNotify(MappingPointer, 0, 0, dev);
+	SendDeviceMappingNotify(client, MappingPointer, 0, 0, dev);
     return Success;
 }
 

Xi/setdval.c

@@ -56,13 +56,10 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "XIstubs.h"
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
@@ -106,24 +103,17 @@ ProcXSetDeviceValuators(ClientPtr client)
     rep.sequenceNumber = client->sequence;
 
     if (stuff->length != (sizeof(xSetDeviceValuatorsReq) >> 2) +
-	stuff->num_valuators) {
+	stuff->num_valuators)
-	SendErrorToClient(client, IReqCode, X_SetDeviceValuators, 0, BadLength);
+	return BadLength;
-	return Success;
-    }
-    dev = LookupDeviceIntRec(stuff->deviceid);
-    if (dev == NULL) {
-	SendErrorToClient(client, IReqCode, X_SetDeviceValuators, 0, BadDevice);
-	return Success;
-    }
-    if (dev->valuator == NULL) {
-	SendErrorToClient(client, IReqCode, X_SetDeviceValuators, 0, BadMatch);
-	return Success;
-    }
 
-    if (stuff->first_valuator + stuff->num_valuators > dev->valuator->numAxes) {
+    dev = LookupDeviceIntRec(stuff->deviceid);
-	SendErrorToClient(client, IReqCode, X_SetDeviceValuators, 0, BadValue);
+    if (dev == NULL)
-	return Success;
+	return BadDevice;
-    }
+    if (dev->valuator == NULL)
+	return BadMatch;
+
+    if (stuff->first_valuator + stuff->num_valuators > dev->valuator->numAxes)
+	return BadValue;
 
     if ((dev->deviceGrab.grab) && !SameClient(dev->deviceGrab.grab, client))
 	rep.status = AlreadyGrabbed;
@@ -133,11 +123,9 @@ ProcXSetDeviceValuators(ClientPtr client)
 					stuff->num_valuators);
 
     if (rep.status != Success && rep.status != AlreadyGrabbed)
-	SendErrorToClient(client, IReqCode, X_SetDeviceValuators, 0,
+	return rep.status;
-			  rep.status);
-    else
-	WriteReplyToClient(client, sizeof(xSetDeviceValuatorsReply), &rep);
 
+    WriteReplyToClient(client, sizeof(xSetDeviceValuatorsReply), &rep);
     return Success;
 }
 

Xi/setfocus.c

@@ -56,8 +56,6 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "windowstr.h"	/* focus struct      */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
@@ -65,7 +63,6 @@ SOFTWARE.
 
 #include "dixevents.h"
 
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
@@ -106,15 +103,11 @@ ProcXSetDeviceFocus(ClientPtr client)
     REQUEST_SIZE_MATCH(xSetDeviceFocusReq);
 
     dev = LookupDeviceIntRec(stuff->device);
-    if (dev == NULL || !dev->focus) {
+    if (dev == NULL || !dev->focus)
-	SendErrorToClient(client, IReqCode, X_SetDeviceFocus, 0, BadDevice);
+	return BadDevice;
-	return Success;
-    }
 
     ret = SetInputFocus(client, dev, stuff->focus, stuff->revertTo,
 			stuff->time, TRUE);
-    if (ret != Success)
-	SendErrorToClient(client, IReqCode, X_SetDeviceFocus, 0, ret);
 
-    return Success;
+    return ret;
 }

Xi/setmmap.c

@@ -56,13 +56,10 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "exevents.h"
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
@@ -103,11 +100,8 @@ ProcXSetDeviceModifierMapping(ClientPtr client)
     REQUEST_AT_LEAST_SIZE(xSetDeviceModifierMappingReq);
 
     dev = LookupDeviceIntRec(stuff->deviceid);
-    if (dev == NULL) {
+    if (dev == NULL)
-	SendErrorToClient(client, IReqCode, X_SetDeviceModifierMapping, 0,
+	return BadDevice;
-			  BadDevice);
-	return Success;
-    }
 
     rep.repType = X_Reply;
     rep.RepType = X_SetDeviceModifierMapping;
@@ -122,14 +116,11 @@ ProcXSetDeviceModifierMapping(ClientPtr client)
     if (ret == MappingSuccess || ret == MappingBusy || ret == MappingFailed) {
 	rep.success = ret;
 	if (ret == MappingSuccess)
-	    SendDeviceMappingNotify(MappingModifier, 0, 0, dev);
+	    SendDeviceMappingNotify(client, MappingModifier, 0, 0, dev);
 	WriteReplyToClient(client, sizeof(xSetDeviceModifierMappingReply),
 			   &rep);
-    } else {
+    } else if (ret == -1)
-	if (ret == -1)
+	return BadValue;
-	    ret = BadValue;
-	SendErrorToClient(client, IReqCode, X_SetDeviceModifierMapping, 0, ret);
-    }
 
     return Success;
 }

Xi/setmode.c

@@ -56,13 +56,10 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
 #include "XIstubs.h"
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
@@ -105,14 +102,10 @@ ProcXSetDeviceMode(ClientPtr client)
     rep.sequenceNumber = client->sequence;
 
     dev = LookupDeviceIntRec(stuff->deviceid);
-    if (dev == NULL) {
+    if (dev == NULL)
-	SendErrorToClient(client, IReqCode, X_SetDeviceMode, 0, BadDevice);
+	return BadDevice;
-	return Success;
+    if (dev->valuator == NULL)
-    }
+	return BadMatch;
-    if (dev->valuator == NULL) {
-	SendErrorToClient(client, IReqCode, X_SetDeviceMode, 0, BadMatch);
-	return Success;
-    }
     if ((dev->deviceGrab.grab) && !SameClient(dev->deviceGrab.grab, client))
 	rep.status = AlreadyGrabbed;
     else
@@ -120,10 +113,8 @@ ProcXSetDeviceMode(ClientPtr client)
 
     if (rep.status == Success)
 	dev->valuator->mode = stuff->mode;
-    else if (rep.status != AlreadyGrabbed) {
+    else if (rep.status != AlreadyGrabbed)
-	SendErrorToClient(client, IReqCode, X_SetDeviceMode, 0, rep.status);
+	return rep.status;
-	return Success;
-    }
 
     WriteReplyToClient(client, sizeof(xSetDeviceModeReply), &rep);
     return Success;

Xi/ungrdev.c

@@ -56,12 +56,9 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include "windowstr.h"	/* window structure  */
 #include <X11/extensions/XIproto.h>
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 
@@ -102,10 +99,8 @@ ProcXUngrabDevice(ClientPtr client)
     REQUEST_SIZE_MATCH(xUngrabDeviceReq);
 
     dev = LookupDeviceIntRec(stuff->deviceid);
-    if (dev == NULL) {
+    if (dev == NULL)
-	SendErrorToClient(client, IReqCode, X_UngrabDevice, 0, BadDevice);
+	return BadDevice;
-	return Success;
-    }
     grab = dev->deviceGrab.grab;
 
     time = ClientTimeToServerTime(stuff->time);

Xi/ungrdevb.c

@@ -56,13 +56,10 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include "windowstr.h"	/* window structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 #include "dixgrabs.h"
@@ -111,41 +108,27 @@ ProcXUngrabDeviceButton(ClientPtr client)
     REQUEST_SIZE_MATCH(xUngrabDeviceButtonReq);
 
     dev = LookupDeviceIntRec(stuff->grabbed_device);
-    if (dev == NULL) {
+    if (dev == NULL)
-	SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, BadDevice);
+	return BadDevice;
-	return Success;
+    if (dev->button == NULL)
-    }
+	return BadMatch;
-    if (dev->button == NULL) {
-	SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, BadMatch);
-	return Success;
-    }
 
     if (stuff->modifier_device != UseXKeyboard) {
 	mdev = LookupDeviceIntRec(stuff->modifier_device);
-	if (mdev == NULL) {
+	if (mdev == NULL)
-	    SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0,
+	    return BadDevice;
-			      BadDevice);
+	if (mdev->key == NULL)
-	    return Success;
+	    return BadMatch;
-	}
-	if (mdev->key == NULL) {
-	    SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0,
-			      BadMatch);
-	    return Success;
-	}
     } else
 	mdev = PickKeyboard(client);
 
     rc = dixLookupWindow(&pWin, stuff->grabWindow, client, DixUnknownAccess);
-    if (rc != Success) {
+    if (rc != Success)
-	SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, rc);
+	return rc;
-	return Success;
-    }
 
     if ((stuff->modifiers != AnyModifier) &&
-	(stuff->modifiers & ~AllModifiersMask)) {
+	(stuff->modifiers & ~AllModifiersMask))
-	SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, BadValue);
+	return BadValue;
-	return Success;
-    }
 
     temporaryGrab.resource = client->clientAsMask;
     temporaryGrab.device = dev;

Xi/ungrdevk.c

@@ -56,13 +56,10 @@ SOFTWARE.
 #include <dix-config.h>
 #endif
 
-#include <X11/X.h>	/* for inputstr.h    */
-#include <X11/Xproto.h>	/* Request macro     */
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include "windowstr.h"	/* window structure  */
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#include "extnsionst.h"
 #include "extinit.h"	/* LookupDeviceIntRec */
 #include "exglobals.h"
 #include "dixgrabs.h"
@@ -111,45 +108,32 @@ ProcXUngrabDeviceKey(ClientPtr client)
     REQUEST_SIZE_MATCH(xUngrabDeviceKeyReq);
 
     dev = LookupDeviceIntRec(stuff->grabbed_device);
-    if (dev == NULL) {
+    if (dev == NULL)
-	SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadDevice);
+	return BadDevice;
-	return Success;
+    if (dev->key == NULL)
-    }
+	return BadMatch;
-    if (dev->key == NULL) {
-	SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadMatch);
-	return Success;
-    }
 
     if (stuff->modifier_device != UseXKeyboard) {
 	mdev = LookupDeviceIntRec(stuff->modifier_device);
-	if (mdev == NULL) {
+	if (mdev == NULL)
-	    SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0,
+	    return BadDevice;
-			      BadDevice);
+	if (mdev->key == NULL)
-	    return Success;
+	    return BadMatch;
-	}
-	if (mdev->key == NULL) {
-	    SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadMatch);
-	    return Success;
-	}
     } else
 	mdev = PickKeyboard(client);
 
     rc = dixLookupWindow(&pWin, stuff->grabWindow, client, DixUnknownAccess);
-    if (rc != Success) {
+    if (rc != Success)
-	SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, rc);
+	return rc;
-	return Success;
+
-    }
     if (((stuff->key > dev->key->curKeySyms.maxKeyCode) ||
 	 (stuff->key < dev->key->curKeySyms.minKeyCode))
-	&& (stuff->key != AnyKey)) {
+	&& (stuff->key != AnyKey))
-	SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadValue);
+	return BadValue;
-	return Success;
+
-    }
     if ((stuff->modifiers != AnyModifier) &&
-	(stuff->modifiers & ~AllModifiersMask)) {
+	(stuff->modifiers & ~AllModifiersMask))
-	SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadValue);
+	return BadValue;
-	return Success;
-    }
 
     temporaryGrab.resource = client->clientAsMask;
     temporaryGrab.device = dev;

afb/Makefile.am

@@ -6,11 +6,11 @@ libafb_gen_sources = afbbltC.c afbbltX.c afbbltCI.c afbbltO.c afbbltG.c afbtileC
 
 DISTCLEANFILES = $(libafb_gen_sources)
 
-libafb_la_SOURCES = afbgc.c afbwindow.c afbfont.c afbfillrct.c afbpntwin.c afbpixmap.c \
+libafb_la_SOURCES = afbgc.c afbwindow.c afbfont.c afbfillrct.c afbpixmap.c \
 	 afbimage.c afbline.c afbbres.c afbhrzvert.c afbbresd.c afbpushpxl.c afbply1rct.c \
 	 afbzerarc.c afbfillarc.c afbfillsp.c afbsetsp.c afbscrinit.c afbplygblt.c \
 	 afbclip.c afbgetsp.c afbpolypnt.c afbbitblt.c afbcmap.c afbimggblt.c afbpntarea.c \
-	 afbmisc.c afbbstore.c afbtegblt.c $(libafb_gen_sources)
+	 afbmisc.c afbtegblt.c $(libafb_gen_sources)
 
 INCLUDES = -I$(top_srcdir)/mfb -I$(top_srcdir)/hw/xfree86/os-support
 

afb/afb.h

@@ -182,23 +182,7 @@ extern void afbBresD(
 	unsigned char * /*rrops*/,
 	unsigned char * /*bgrrops*/
 );
-/* afbbstore.c */
 
-extern void afbSaveAreas(
-	PixmapPtr /*pPixmap*/,
-	RegionPtr /*prgnSave*/,
-	int /*xorg*/,
-	int /*yorg*/,
-	WindowPtr /*pWin*/
-);
-
-extern void afbRestoreAreas(
-	PixmapPtr /*pPixmap*/,
-	RegionPtr /*prgnRestore*/,
-	int /*xorg*/,
-	int /*yorg*/,
-	WindowPtr /*pWin*/
-);
 /* afbclip.c */
 
 extern RegionPtr afbPixmapToRegion(
@@ -499,7 +483,8 @@ extern PixmapPtr afbCreatePixmap(
 	ScreenPtr /*pScreen*/,
 	int /*width*/,
 	int /*height*/,
-	int /*depth*/
+	int /*depth*/,
+	unsigned /*usage_hint*/
 );
 
 extern Bool afbDestroyPixmap(
@@ -522,11 +507,6 @@ extern void afbCopyRotatePixmap(
 	int /*xrot*/,
 	int /*yrot*/
 );
-extern void afbPaintWindow(
-	WindowPtr /*pWin*/,
-	RegionPtr /*pRegion*/,
-	int /*what*/
-);
 /* afbpolypnt.c */
 
 extern void afbPolyPoint(
@@ -760,16 +740,6 @@ extern int frameWindowPrivateIndex;		/* index into Window private array */
 #define afbGetGCPrivate(pGC) \
 	((afbPrivGC *)((pGC)->devPrivates[afbGCPrivateIndex].ptr))
 
-/* private field of window */
-typedef struct {
-	unsigned char fastBorder;	/* non-zero if border tile is 32 bits wide */
-	unsigned char fastBackground;
-	unsigned short unused; /* pad for alignment with Sun compiler */
-	DDXPointRec oldRotate;
-	PixmapPtr pRotatedBackground;
-	PixmapPtr pRotatedBorder;
-} afbPrivWin;
-
 /* Common macros for extracting drawing information */
 
 #define afbGetTypedWidth(pDrawable,wtype)( \

afb/afbbitblt.c

@@ -279,7 +279,7 @@ afbBitBlt(register DrawablePtr pSrcDrawable, register DrawablePtr pDstDrawable,
 	/* Do bit blitting */
 	numRects = REGION_NUM_RECTS(&rgnDst);
 	if (numRects && width && height) {
-		if(!(pptSrc = (DDXPointPtr)ALLOCATE_LOCAL(numRects *
+		if(!(pptSrc = (DDXPointPtr)xalloc(numRects *
 												  sizeof(DDXPointRec)))) {
 			REGION_UNINIT(pGC->pScreen, &rgnDst);
 			if (freeSrcClip)
@@ -296,7 +296,7 @@ afbBitBlt(register DrawablePtr pSrcDrawable, register DrawablePtr pDstDrawable,
 		(*doBitBlt)(pSrcDrawable, pDstDrawable, pGC->alu, &rgnDst, pptSrc,
 					 planemask);
 
-		DEALLOCATE_LOCAL(pptSrc);
+		xfree(pptSrc);
 	}
 
 	prgnExposed = NULL;

afb/afbblt.c

@@ -132,12 +132,12 @@ MROP_NAME(afbDoBitblt)(pSrc, pDst, alu, prgnDst, pptSrc, planemask)
 
 		if (nbox > 1) {
 			/* keep ordering in each band, reverse order of bands */
-			pboxNew1 = (BoxPtr)ALLOCATE_LOCAL(sizeof(BoxRec)*nbox);
+			pboxNew1 = (BoxPtr)xalloc(sizeof(BoxRec)*nbox);
 			if(!pboxNew1)
 				return;
-			pptNew1 = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec)*nbox);
+			pptNew1 = (DDXPointPtr)xalloc(sizeof(DDXPointRec)*nbox);
 			if(!pptNew1) {
-				DEALLOCATE_LOCAL(pboxNew1);
+				xfree(pboxNew1);
 				return;
 			}
 			pboxBase = pboxNext = pbox+nbox-1;
@@ -169,16 +169,16 @@ MROP_NAME(afbDoBitblt)(pSrc, pDst, alu, prgnDst, pptSrc, planemask)
 
 		if (nbox > 1) {
 			/* reverse order of rects in each band */
-			pboxNew2 = (BoxPtr)ALLOCATE_LOCAL(sizeof(BoxRec) * nbox);
+			pboxNew2 = (BoxPtr)xalloc(sizeof(BoxRec) * nbox);
-			pptNew2 = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec) * nbox);
+			pptNew2 = (DDXPointPtr)xalloc(sizeof(DDXPointRec) * nbox);
 			if(!pboxNew2 || !pptNew2) {
 				if (pptNew2)
-					DEALLOCATE_LOCAL(pptNew2);
+					xfree(pptNew2);
 				if (pboxNew2)
-					DEALLOCATE_LOCAL(pboxNew2);
+					xfree(pboxNew2);
 				if (pboxNew1) {
-					DEALLOCATE_LOCAL(pptNew1);
+					xfree(pptNew1);
-					DEALLOCATE_LOCAL(pboxNew1);
+					xfree(pboxNew1);
 				}
 				return;
 			}
@@ -553,11 +553,11 @@ bits1 = *--psrc; --pdst; \
 		pptSrc++;
 	}
 	if (pboxNew2) {
-		DEALLOCATE_LOCAL(pptNew2);
+		xfree(pptNew2);
-		DEALLOCATE_LOCAL(pboxNew2);
+		xfree(pboxNew2);
 	}
 	if (pboxNew1) {
-		DEALLOCATE_LOCAL(pptNew1);
+		xfree(pptNew1);
-		DEALLOCATE_LOCAL(pboxNew1);
+		xfree(pboxNew1);
 	}
 }

afb/afbbstore.c

@@ -1,154 +0,0 @@
-/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
-/*
-
-Copyright (c) 1987  X Consortium
-
-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 THE X CONSORTIUM 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 the X Consortium shall
-not be used in advertising or otherwise to promote the sale, use or
-other dealings in this Software without prior written authorization
-from the X Consortium.
-
-*/
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include	"afb.h"
-#include	<X11/X.h>
-#include	"mibstore.h"
-#include	"regionstr.h"
-#include	"scrnintstr.h"
-#include	"pixmapstr.h"
-#include	"windowstr.h"
-
-/*-
- *-----------------------------------------------------------------------
- * afbSaveAreas --
- *		Function called by miSaveAreas to actually fetch the areas to be
- *		saved into the backing pixmap. This is very simple to do, since
- *		afbDoBitblt is designed for this very thing. The region to save is
- *		already destination-relative and we're given the offset to the
- *		window origin, so we have only to create an array of points of the
- *		u.l. corners of the boxes in the region translated to the screen
- *		coordinate system and fetch the screen pixmap out of its devPrivate
- *		field....
- *
- * Results:
- *		None.
- *
- * Side Effects:
- *		Data are copied from the screen into the pixmap.
- *
- *-----------------------------------------------------------------------
- */
-void
-afbSaveAreas(pPixmap, prgnSave, xorg, yorg, pWin)
-	PixmapPtr		  		pPixmap;  		/* Backing pixmap */
-	RegionPtr		  		prgnSave; 		/* Region to save (pixmap-relative) */
-	int					  		xorg;					/* X origin of region */
-	int					  		yorg;					/* Y origin of region */
-	WindowPtr				pWin;
-{
-	register DDXPointPtr pPt;
-	DDXPointPtr				pPtsInit;
-	register BoxPtr		pBox;
-	register int		numRects;
-
-	numRects = REGION_NUM_RECTS(prgnSave);
-	pPtsInit = (DDXPointPtr)ALLOCATE_LOCAL(numRects * sizeof(DDXPointRec));
-	if (!pPtsInit)
-		return;
-
-	pBox = REGION_RECTS(prgnSave);
-	pPt = pPtsInit;
-	while (numRects--) {
-		pPt->x = pBox->x1 + xorg;
- 		pPt->y = pBox->y1 + yorg;
- 		pPt++;
- 		pBox++;
-	}
-
-	afbDoBitblt((DrawablePtr)pPixmap->drawable.pScreen->devPrivates[afbScreenPrivateIndex].ptr,
-				(DrawablePtr)pPixmap,
-				GXcopy,
-				prgnSave,
-				pPtsInit, wBackingBitPlanes (pWin));
-
-	DEALLOCATE_LOCAL(pPtsInit);
-}
-
-/*-
- *-----------------------------------------------------------------------
- * afbRestoreAreas --
- *		Function called by miRestoreAreas to actually fetch the areas to be
- *		restored from the backing pixmap. This is very simple to do, since
- *		afbDoBitblt is designed for this very thing. The region to restore is
- *		already destination-relative and we're given the offset to the
- *		window origin, so we have only to create an array of points of the
- *		u.l. corners of the boxes in the region translated to the pixmap
- *		coordinate system and fetch the screen pixmap out of its devPrivate
- *		field....
- *
- * Results:
- *		None.
- *
- * Side Effects:
- *		Data are copied from the pixmap into the screen.
- *
- *-----------------------------------------------------------------------
- */
-void
-afbRestoreAreas(pPixmap, prgnRestore, xorg, yorg, pWin)
-	PixmapPtr		  		pPixmap;  		/* Backing pixmap */
-	RegionPtr		  		prgnRestore; 		/* Region to restore (screen-relative)*/
-	int					  		xorg;					/* X origin of window */
-	int					  		yorg;					/* Y origin of window */
-	WindowPtr				pWin;
-{
-	register DDXPointPtr pPt;
-	DDXPointPtr				pPtsInit;
-	register BoxPtr		pBox;
-	register int		numRects;
-
-	numRects = REGION_NUM_RECTS(prgnRestore);
-	pPtsInit = (DDXPointPtr)ALLOCATE_LOCAL(numRects*sizeof(DDXPointRec));
-	if (!pPtsInit)
-		return;
-
-	pBox = REGION_RECTS(prgnRestore);
-	pPt = pPtsInit;
-	while (numRects--) {
-		pPt->x = pBox->x1 - xorg;
- 		pPt->y = pBox->y1 - yorg;
- 		pPt++;
- 		pBox++;
-	}
-
-	afbDoBitblt((DrawablePtr)pPixmap,
-				(DrawablePtr)pPixmap->drawable.pScreen->devPrivates[afbScreenPrivateIndex].ptr,
-				GXcopy,
-				prgnRestore,
-				pPtsInit, wBackingBitPlanes (pWin));
-
-	DEALLOCATE_LOCAL(pPtsInit);
-}

afb/afbfillrct.c

@@ -111,7 +111,7 @@ afbPolyFillRect(DrawablePtr pDrawable, GCPtr pGC, int nrectFill, xRectangle *pre
 
 	numRects = REGION_NUM_RECTS(prgnClip) * nrectFill;
 	if (numRects > NUM_STACK_RECTS) {
-		pboxClippedBase = (BoxPtr)ALLOCATE_LOCAL(numRects * sizeof(BoxRec));
+		pboxClippedBase = (BoxPtr)xalloc(numRects * sizeof(BoxRec));
 		if (!pboxClippedBase)
 			return;
 	}
@@ -287,5 +287,5 @@ afbPolyFillRect(DrawablePtr pDrawable, GCPtr pGC, int nrectFill, xRectangle *pre
 		}
 	}
 	if (pboxClippedBase != stackRects)
-			DEALLOCATE_LOCAL(pboxClippedBase);
+			xfree(pboxClippedBase);
 }

afb/afbfillsp.c

@@ -109,11 +109,11 @@ afbSolidFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
 	unsigned char *rrops;
 
 	n = nInit * miFindMaxBand(pGC->pCompositeClip);
-	pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
+	pwidthFree = (int *)xalloc(n * sizeof(int));
-	pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
+	pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
 	if(!pptFree || !pwidthFree) {
-		if (pptFree) DEALLOCATE_LOCAL(pptFree);
+		if (pptFree) xfree(pptFree);
-		if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
+		if (pwidthFree) xfree(pwidthFree);
 		return;
 	}
 	pwidth = pwidthFree;
@@ -183,8 +183,8 @@ afbSolidFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
 		pwidth++;
 		ppt++;
 	}
-	DEALLOCATE_LOCAL(pptFree);
+	xfree(pptFree);
-	DEALLOCATE_LOCAL(pwidthFree);
+	xfree(pwidthFree);
 }
 
 void 
@@ -219,11 +219,11 @@ afbStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
 	unsigned char *rrops;
 
 	n = nInit * miFindMaxBand(pGC->pCompositeClip);
-	pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
+	pwidthFree = (int *)xalloc(n * sizeof(int));
-	pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
+	pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
 	if(!pptFree || !pwidthFree) {
-		if (pptFree) DEALLOCATE_LOCAL(pptFree);
+		if (pptFree) xfree(pptFree);
-		if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
+		if (pwidthFree) xfree(pwidthFree);
 		return;
 	}
 	pwidth = pwidthFree;
@@ -297,8 +297,8 @@ afbStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
 		pwidth++;
 		ppt++;
 	}
-	DEALLOCATE_LOCAL(pptFree);
+	xfree(pptFree);
-	DEALLOCATE_LOCAL(pwidthFree);
+	xfree(pwidthFree);
 }
 
 void
@@ -333,11 +333,11 @@ afbTileFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
 	int d;
 
 	n = nInit * miFindMaxBand(pGC->pCompositeClip);
-	pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
+	pwidthFree = (int *)xalloc(n * sizeof(int));
-	pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
+	pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
 	if(!pptFree || !pwidthFree) {
-		if (pptFree) DEALLOCATE_LOCAL(pptFree);
+		if (pptFree) xfree(pptFree);
-		if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
+		if (pwidthFree) xfree(pwidthFree);
 		return;
 	}
 	pwidth = pwidthFree;
@@ -428,8 +428,8 @@ afbTileFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
 				break;
 			}
 	}
-	DEALLOCATE_LOCAL(pptFree);
+	xfree(pptFree);
-	DEALLOCATE_LOCAL(pwidthFree);
+	xfree(pwidthFree);
 }
 
 void
@@ -465,11 +465,11 @@ afbOpaqueStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
 	int d;
 
 	n = nInit * miFindMaxBand(pGC->pCompositeClip);
-	pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
+	pwidthFree = (int *)xalloc(n * sizeof(int));
-	pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
+	pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
 	if(!pptFree || !pwidthFree) {
-		if (pptFree) DEALLOCATE_LOCAL(pptFree);
+		if (pptFree) xfree(pptFree);
-		if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
+		if (pwidthFree) xfree(pwidthFree);
 		return;
 	}
 	pwidth = pwidthFree;
@@ -587,8 +587,8 @@ afbOpaqueStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
 				break;
 			}
 	} /* switch (rop) */
-	DEALLOCATE_LOCAL(pptFree);
+	xfree(pptFree);
-	DEALLOCATE_LOCAL(pwidthFree);
+	xfree(pwidthFree);
 }
 
 /* Fill spans with tiles that aren't PPW bits wide */
@@ -626,11 +626,11 @@ afbUnnaturalTileFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
 	register int d;
 
 	n = nInit * miFindMaxBand(pGC->pCompositeClip);
-	pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
+	pwidthFree = (int *)xalloc(n * sizeof(int));
-	pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
+	pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
 	if(!pptFree || !pwidthFree) {
-		if (pptFree) DEALLOCATE_LOCAL(pptFree);
+		if (pptFree) xfree(pptFree);
-		if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
+		if (pwidthFree) xfree(pwidthFree);
 		return;
 	}
 	pwidth = pwidthFree;
@@ -732,8 +732,8 @@ afbUnnaturalTileFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
 		ppt++;
 		pwidth++;
 	}
-	DEALLOCATE_LOCAL(pptFree);
+	xfree(pptFree);
-	DEALLOCATE_LOCAL(pwidthFree);
+	xfree(pwidthFree);
 }
 
 /* Fill spans with stipples that aren't PPW bits wide */
@@ -772,11 +772,11 @@ afbUnnaturalStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
 	int depthDst;
 
 	n = nInit * miFindMaxBand(pGC->pCompositeClip);
-	pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
+	pwidthFree = (int *)xalloc(n * sizeof(int));
-	pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
+	pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
 	if(!pptFree || !pwidthFree) {
-		if (pptFree) DEALLOCATE_LOCAL(pptFree);
+		if (pptFree) xfree(pptFree);
-		if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
+		if (pwidthFree) xfree(pwidthFree);
 		return;
 	}
 	pwidth = pwidthFree;
@@ -877,8 +877,8 @@ afbUnnaturalStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
 		ppt++;
 		pwidth++;
 	}
-	DEALLOCATE_LOCAL(pptFree);
+	xfree(pptFree);
-	DEALLOCATE_LOCAL(pwidthFree);
+	xfree(pwidthFree);
 }
 
 /* Fill spans with OpaqueStipples that aren't PPW bits wide */
@@ -918,11 +918,11 @@ afbUnnaturalOpaqueStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
 	int depthDst;
 
 	n = nInit * miFindMaxBand(pGC->pCompositeClip);
-	pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
+	pwidthFree = (int *)xalloc(n * sizeof(int));
-	pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
+	pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
 	if(!pptFree || !pwidthFree) {
-		if (pptFree) DEALLOCATE_LOCAL(pptFree);
+		if (pptFree) xfree(pptFree);
-		if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
+		if (pwidthFree) xfree(pwidthFree);
 		return;
 	}
 	pwidth = pwidthFree;
@@ -1124,6 +1124,6 @@ afbUnnaturalOpaqueStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
 		ppt++;
 		pwidth++;
 	}
-	DEALLOCATE_LOCAL(pptFree);
+	xfree(pptFree);
-	DEALLOCATE_LOCAL(pwidthFree);
+	xfree(pwidthFree);
 }

afb/afbimage.c

@@ -72,7 +72,8 @@ afbPutImage(pDraw, pGC, depth, x, y, width, height, leftPad, format, pImage)
 		int depthDst;
 
 		/* Create a tmp pixmap */
-		pPixmap = (pScreen->CreatePixmap)(pScreen, width, height, depth);
+		pPixmap = (pScreen->CreatePixmap)(pScreen, width, height, depth,
+						  CREATE_PIXMAP_USAGE_SCRATCH);
 		if (!pPixmap)
 			return;
 

afb/afbimggblt.c

@@ -298,7 +298,7 @@ afbImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
 				int getWidth;				/* bits to get from glyph */
 #endif
 
-				if(!(ppos = (afbTEXTPOS *)ALLOCATE_LOCAL(nglyph * sizeof(afbTEXTPOS))))
+				if(!(ppos = (afbTEXTPOS *)xalloc(nglyph * sizeof(afbTEXTPOS))))
 					return;
 
 				pdstBase = afbScanlineNoBankSwitch(pdstBase, x, y, widthDst);
@@ -462,7 +462,7 @@ afbImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
 						} /* depth */
 					} /* for each glyph */
 				} /* while nbox-- */
-				DEALLOCATE_LOCAL(ppos);
+				xfree(ppos);
 				break;
 			}
 

afb/afbpixmap.c

@@ -70,11 +70,12 @@ SOFTWARE.
 #include "mfb.h"
 
 PixmapPtr
-afbCreatePixmap(pScreen, width, height, depth)
+afbCreatePixmap(pScreen, width, height, depth, usage_hint)
 	ScreenPtr		pScreen;
 	int				width;
 	int				height;
 	int				depth;
+	unsigned			usage_hint;
 {
 	PixmapPtr pPixmap;
 	size_t datasize;
@@ -127,8 +128,10 @@ afbCopyPixmap(PixmapPtr pSrc)
 
 	size = pSrc->drawable.height * pSrc->devKind * pSrc->drawable.depth;
 	pScreen = pSrc->drawable.pScreen;
-	pDst = (*pScreen->CreatePixmap)(pScreen, pSrc->drawable.width,
+	pDst = (*pScreen->CreatePixmap)(pScreen,
-											  pSrc->drawable.height, pSrc->drawable.depth);
+					pSrc->drawable.width,
+					pSrc->drawable.height,
+					pSrc->drawable.depth, 0);
 	if (!pDst)
 		return(NullPixmap);
 	memmove((char *)pDst->devPrivate.ptr, (char *)pSrc->devPrivate.ptr, size);
@@ -248,7 +251,7 @@ afbYRotatePixmap(pPix, rh)
 	nbyDown = rh * pPix->devKind;
 	nbyUp = (pPix->devKind * height) - nbyDown;
 
-	if(!(ptmp = (char *)ALLOCATE_LOCAL(nbyUp)))
+	if(!(ptmp = (char *)xalloc(nbyUp)))
 		return;
 
 	for (d = 0; d < pPix->drawable.depth; d++) {
@@ -258,7 +261,7 @@ afbYRotatePixmap(pPix, rh)
 		memmove(pbase, pbase+nbyUp, nbyDown);		/* slide the top rows down */
 		memmove(pbase+nbyDown, ptmp, nbyUp);		/* move lower rows up to row rh */
 	}
-	DEALLOCATE_LOCAL(ptmp);
+	xfree(ptmp);
 }
 
 void

afb/afbplygblt.c

@@ -278,7 +278,7 @@ afbPolyGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
 				int getWidth;				/* bits to get from glyph */
 #endif
 
-				if(!(ppos = (afbTEXTPOS *)ALLOCATE_LOCAL(nglyph * sizeof(afbTEXTPOS))))
+				if(!(ppos = (afbTEXTPOS *)xalloc(nglyph * sizeof(afbTEXTPOS))))
 					return;
 
 				pdstBase = afbScanlineNoBankSwitch(pdstBase, x, y, widthDst);
@@ -453,7 +453,7 @@ afbPolyGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
 						} /* depth */
 					} /* for each glyph */
 				} /* while nbox-- */
-				DEALLOCATE_LOCAL(ppos);
+				xfree(ppos);
 				break;
 			}
 

afb/afbpntwin.c

@@ -1,126 +0,0 @@
-/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
-/***********************************************************
-
-Copyright (c) 1987  X Consortium
-
-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 THE
-X CONSORTIUM 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 the X Consortium shall not be
-used in advertising or otherwise to promote the sale, use or other dealings
-in this Software without prior written authorization from the X Consortium.
-
-
-Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
-
-                        All Rights Reserved
-
-Permission to use, copy, modify, and distribute this software and its
-documentation for any purpose and without fee is hereby granted,
-provided that the above copyright notice appear in all copies and that
-both that copyright notice and this permission notice appear in
-supporting documentation, and that the name of Digital not be
-used in advertising or publicity pertaining to distribution of the
-software without specific, written prior permission.
-
-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
-SOFTWARE.
-
-******************************************************************/
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include <X11/X.h>
-
-#include "windowstr.h"
-#include "regionstr.h"
-#include "pixmapstr.h"
-#include "scrnintstr.h"
-
-#include "afb.h"
-#include "maskbits.h"
-#include "mi.h"
-
-void
-afbPaintWindow(pWin, pRegion, what)
-	WindowPtr		pWin;
-	RegionPtr		pRegion;
-	int				what;
-{
-	register afbPrivWin		*pPrivWin;
-	unsigned char rrops[AFB_MAX_DEPTH];
-
-	pPrivWin = (afbPrivWin *)(pWin->devPrivates[afbWindowPrivateIndex].ptr);
-
-	switch (what) {
-		case PW_BACKGROUND:
-			switch (pWin->backgroundState) {
-				case None:
-					return;
-				case ParentRelative:
-					do {
-						pWin = pWin->parent;
-					} while (pWin->backgroundState == ParentRelative);
-					(*pWin->drawable.pScreen->PaintWindowBackground)(pWin, pRegion,
-																					 what);
-					return;
-				case BackgroundPixmap:
-					if (pPrivWin->fastBackground) {
-						afbTileAreaPPWCopy((DrawablePtr)pWin,
-												  REGION_NUM_RECTS(pRegion),
-												  REGION_RECTS(pRegion), GXcopy,
-												  pPrivWin->pRotatedBackground, ~0);
-						return;
-					} else {
-						afbTileAreaCopy((DrawablePtr)pWin, REGION_NUM_RECTS(pRegion),
-											  REGION_RECTS(pRegion), GXcopy,
-											  pWin->background.pixmap, 0, 0, ~0);
-						return;
-					}
-					break;
-				case BackgroundPixel:
-					afbReduceRop(GXcopy, pWin->background.pixel, ~0,
-									  pWin->drawable.depth, rrops);
-					afbSolidFillArea((DrawablePtr)pWin, REGION_NUM_RECTS(pRegion),
-											REGION_RECTS(pRegion), rrops);
-					return;
-			}
-			break;
-		case PW_BORDER:
-			if (pWin->borderIsPixel) {
-				afbReduceRop(GXcopy, pWin->border.pixel, ~0, pWin->drawable.depth,
-								  rrops);
-				afbSolidFillArea((DrawablePtr)pWin, REGION_NUM_RECTS(pRegion),
-										REGION_RECTS(pRegion), rrops);
-				return;
-			} else if (pPrivWin->fastBorder) {
-				afbTileAreaPPWCopy((DrawablePtr)pWin, REGION_NUM_RECTS(pRegion),
-										  REGION_RECTS(pRegion), GXcopy,
-										  pPrivWin->pRotatedBorder, ~0);
-				return;
-			}
-			break;
-	}
-	miPaintWindow(pWin, pRegion, what);
-}

afb/afbscrinit.c

@@ -71,20 +71,11 @@ SOFTWARE.
 #ifdef PIXMAP_PER_WINDOW
 int frameWindowPrivateIndex;
 #endif
-int afbWindowPrivateIndex;
 int afbGCPrivateIndex;
 int afbScreenPrivateIndex;
 
 static unsigned long afbGeneration = 0;
 
-static BSFuncRec afbBSFuncRec = {
-	afbSaveAreas,
-	afbRestoreAreas,
-	(BackingStoreSetClipmaskRgnProcPtr) 0,
-	(BackingStoreGetImagePixmapProcPtr) 0,
-	(BackingStoreGetSpansPixmapProcPtr) 0,
-};
-
 static Bool
 afbCloseScreen(int index, ScreenPtr pScreen)
 {
@@ -148,20 +139,16 @@ afbAllocatePrivates(ScreenPtr pScreen, int *pWinIndex, int *pGCIndex)
 #ifdef PIXMAP_PER_WINDOW
 		frameWindowPrivateIndex = AllocateWindowPrivateIndex();
 #endif
-		afbWindowPrivateIndex = AllocateWindowPrivateIndex();
 		afbGCPrivateIndex = AllocateGCPrivateIndex();
 		afbGeneration = serverGeneration;
 	}
-	if (pWinIndex)
-		*pWinIndex = afbWindowPrivateIndex;
 	if (pGCIndex)
 		*pGCIndex = afbGCPrivateIndex;
 
 	afbScreenPrivateIndex = AllocateScreenPrivateIndex();
 	pScreen->GetWindowPixmap = afbGetWindowPixmap;
 	pScreen->SetWindowPixmap = afbSetWindowPixmap;
-	return(AllocateWindowPrivate(pScreen, afbWindowPrivateIndex, sizeof(afbPrivWin)) &&
+	return(AllocateGCPrivate(pScreen, afbGCPrivateIndex, sizeof(afbPrivGC)));
-	       AllocateGCPrivate(pScreen, afbGCPrivateIndex, sizeof(afbPrivGC)));
 }
 
 /* dts * (inch/dot) * (25.4 mm / inch) = mm */
@@ -206,8 +193,6 @@ afbScreenInit(register ScreenPtr pScreen, pointer pbits, int xsize, int ysize, i
 	pScreen->ChangeWindowAttributes = afbChangeWindowAttributes;
 	pScreen->RealizeWindow = afbMapWindow;
 	pScreen->UnrealizeWindow = afbUnmapWindow;
-	pScreen->PaintWindowBackground = afbPaintWindow;
-	pScreen->PaintWindowBorder = afbPaintWindow;
 	pScreen->CopyWindow = afbCopyWindow;
 	pScreen->CreatePixmap = afbCreatePixmap;
 	pScreen->DestroyPixmap = afbDestroyPixmap;
@@ -231,7 +216,6 @@ afbScreenInit(register ScreenPtr pScreen, pointer pbits, int xsize, int ysize, i
 
 	pScreen->CloseScreen = afbCloseScreen;
 	pScreen->CreateScreenResources = afbCreateScreenResources;
-	pScreen->BackingStoreFuncs = afbBSFuncRec;
 
 	pScreen->devPrivates[afbScreenPrivateIndex].ptr = pScreen->devPrivate;
 	pScreen->devPrivate = oldDevPrivate;

afb/afbwindow.c

@@ -62,39 +62,16 @@ SOFTWARE.
 #include "maskbits.h"
 
 Bool
-afbCreateWindow(pWin)
+afbCreateWindow(WindowPtr pWin)
-	register WindowPtr pWin;
 {
-	register afbPrivWin *pPrivWin;
-
-	pPrivWin = (afbPrivWin *)(pWin->devPrivates[afbWindowPrivateIndex].ptr);
-	pPrivWin->pRotatedBorder = NullPixmap;
-	pPrivWin->pRotatedBackground = NullPixmap;
-	pPrivWin->fastBackground = FALSE;
-	pPrivWin->fastBorder = FALSE;
-#ifdef PIXMAP_PER_WINDOW
-	pWin->devPrivates[frameWindowPrivateIndex].ptr =
-			pWin->pDrawable.pScreen->devPrivates[afbScreenPrivateIndex].ptr;
-#endif
-
 	return (TRUE);
 }
 
 /* This always returns true, because Xfree can't fail.  It might be possible
  * on some devices for Destroy to fail */
 Bool
-afbDestroyWindow(pWin)
+afbDestroyWindow(WindowPtr pWin)
-	WindowPtr pWin;
 {
-	register afbPrivWin *pPrivWin;
-
-	pPrivWin = (afbPrivWin *)(pWin->devPrivates[afbWindowPrivateIndex].ptr);
-
-	if (pPrivWin->pRotatedBorder)
-		(*pWin->drawable.pScreen->DestroyPixmap)(pPrivWin->pRotatedBorder);
-	if (pPrivWin->pRotatedBackground)
-		(*pWin->drawable.pScreen->DestroyPixmap)(pPrivWin->pRotatedBackground);
-
 	return (TRUE);
 }
 
@@ -106,46 +83,10 @@ afbMapWindow(pWindow)
 	return (TRUE);
 }
 
-/* (x, y) is the upper left corner of the window on the screen
-   do we really need to pass this?  (is it a;ready in pWin->absCorner?)
-   we only do the rotation for pixmaps that are 32 bits wide (padded
-or otherwise.)
-   afbChangeWindowAttributes() has already put a copy of the pixmap
-in pPrivWin->pRotated*
-*/
-
 /*ARGSUSED*/
 Bool
-afbPositionWindow(pWin, x, y)
+afbPositionWindow(WindowPtr pWin, int x, int y)
-	WindowPtr pWin;
-	int x, y;
 {
-	register afbPrivWin *pPrivWin;
-	int		reset = 0;
-
-	pPrivWin = (afbPrivWin *)(pWin->devPrivates[afbWindowPrivateIndex].ptr);
-	if (pWin->backgroundState == BackgroundPixmap && pPrivWin->fastBackground) {
-		afbXRotatePixmap(pPrivWin->pRotatedBackground,
-								pWin->drawable.x - pPrivWin->oldRotate.x);
-		afbYRotatePixmap(pPrivWin->pRotatedBackground,
-								pWin->drawable.y - pPrivWin->oldRotate.y);
-		reset = 1;
-	}
-
-	if (!pWin->borderIsPixel && pPrivWin->fastBorder) {
-		while (pWin->backgroundState == ParentRelative)
-			pWin = pWin->parent;
-		afbXRotatePixmap(pPrivWin->pRotatedBorder,
-								pWin->drawable.x - pPrivWin->oldRotate.x);
-		afbYRotatePixmap(pPrivWin->pRotatedBorder,
-								pWin->drawable.y - pPrivWin->oldRotate.y);
-		reset = 1;
-	}
-	if (reset) {
-		pPrivWin->oldRotate.x = pWin->drawable.x;
-		pPrivWin->oldRotate.y = pWin->drawable.y;
-	}
-
 	/* This is the "wrong" fix to the right problem, but it doesn't really
 	 * cost very much.  When the window is moved, we need to invalidate any
 	 * RotatedPixmap that exists in any GC currently validated against this
@@ -200,7 +141,7 @@ afbCopyWindow(pWin, ptOldOrg, prgnSrc)
 
 	pbox = REGION_RECTS(prgnDst);
 	nbox = REGION_NUM_RECTS(prgnDst);
-	if(!(pptSrc = (DDXPointPtr )ALLOCATE_LOCAL(nbox * sizeof(DDXPointRec))))
+	if(!(pptSrc = (DDXPointPtr )xalloc(nbox * sizeof(DDXPointRec))))
 		return;
 	ppt = pptSrc;
 
@@ -211,108 +152,12 @@ afbCopyWindow(pWin, ptOldOrg, prgnSrc)
 
 	afbDoBitblt((DrawablePtr)pwinRoot, (DrawablePtr)pwinRoot, GXcopy, prgnDst,
 					 pptSrc, ~0);
-	DEALLOCATE_LOCAL(pptSrc);
+	xfree(pptSrc);
 	REGION_DESTROY(pWin->drawable.pScreen, prgnDst);
 }
 
-
-
-/* swap in correct PaintWindow* routine.  If we can use a fast output
-routine (i.e. the pixmap is paddable to 32 bits), also pre-rotate a copy
-of it in devPrivate.
-*/
 Bool
-afbChangeWindowAttributes(pWin, mask)
+afbChangeWindowAttributes(WindowPtr pWin, unsigned long mask)
-	register WindowPtr pWin;
-	register unsigned long mask;
 {
-	register unsigned long index;
-	register afbPrivWin *pPrivWin;
-	WindowPtr		pBgWin;
-
-	pPrivWin = (afbPrivWin *)(pWin->devPrivates[afbWindowPrivateIndex].ptr);
-	/*
-	 * When background state changes from ParentRelative and
-	 * we had previously rotated the fast border pixmap to match
-	 * the parent relative origin, rerotate to match window
-	 */
-	if (mask & (CWBackPixmap | CWBackPixel) &&
-		 pWin->backgroundState != ParentRelative && pPrivWin->fastBorder &&
-		 (pPrivWin->oldRotate.x != pWin->drawable.x ||
-		  pPrivWin->oldRotate.y != pWin->drawable.y)) {
-		afbXRotatePixmap(pPrivWin->pRotatedBorder,
-								pWin->drawable.x - pPrivWin->oldRotate.x);
-		afbYRotatePixmap(pPrivWin->pRotatedBorder,
-								pWin->drawable.y - pPrivWin->oldRotate.y);
-		pPrivWin->oldRotate.x = pWin->drawable.x;
-		pPrivWin->oldRotate.y = pWin->drawable.y;
-	}
-	while(mask) {
-		index = lowbit (mask);
-		mask &= ~index;
-		switch(index) {
-			case CWBackPixmap:
-				if (pWin->backgroundState == None)
-					pPrivWin->fastBackground = FALSE;
-				else if (pWin->backgroundState == ParentRelative) {
-					pPrivWin->fastBackground = FALSE;
-					/* Rotate border to match parent origin */
-					if (pPrivWin->pRotatedBorder) {
-						for (pBgWin = pWin->parent;
-							  pBgWin->backgroundState == ParentRelative;
-							  pBgWin = pBgWin->parent);
-						afbXRotatePixmap(pPrivWin->pRotatedBorder,
-												pBgWin->drawable.x - pPrivWin->oldRotate.x);
-						afbYRotatePixmap(pPrivWin->pRotatedBorder,
-												pBgWin->drawable.y - pPrivWin->oldRotate.y);
-						pPrivWin->oldRotate.x = pBgWin->drawable.x;
-						pPrivWin->oldRotate.y = pBgWin->drawable.y;
-					}
-				} else if ((pWin->background.pixmap->drawable.width <= PPW) &&
-							  !(pWin->background.pixmap->drawable.width &
-								 (pWin->background.pixmap->drawable.width - 1))) {
-					afbCopyRotatePixmap(pWin->background.pixmap,
-												&pPrivWin->pRotatedBackground,
-												pWin->drawable.x, pWin->drawable.y);
-					if (pPrivWin->pRotatedBackground) {
-						pPrivWin->fastBackground = TRUE;
-						pPrivWin->oldRotate.x = pWin->drawable.x;
-						pPrivWin->oldRotate.y = pWin->drawable.y;
-					} else
-						pPrivWin->fastBackground = FALSE;
-				} else
-					pPrivWin->fastBackground = FALSE;
-					break;
-
-			case CWBackPixel:
-				pPrivWin->fastBackground = FALSE;
-				break;
-
-			case CWBorderPixmap:
-				if ((pWin->border.pixmap->drawable.width <= PPW) &&
-					 !(pWin->border.pixmap->drawable.width &
-						(pWin->border.pixmap->drawable.width - 1))) {
-					for (pBgWin = pWin;
-						  pBgWin->backgroundState == ParentRelative;
-						  pBgWin = pBgWin->parent);
-					afbCopyRotatePixmap(pWin->border.pixmap,
-												&pPrivWin->pRotatedBorder,
-												pBgWin->drawable.x, pBgWin->drawable.y);
-					if (pPrivWin->pRotatedBorder) {
-						pPrivWin->fastBorder = TRUE;
-						pPrivWin->oldRotate.x = pBgWin->drawable.x;
-						pPrivWin->oldRotate.y = pBgWin->drawable.y;
-					} else
-						pPrivWin->fastBorder = FALSE;
-				} else
-					pPrivWin->fastBorder = FALSE;
-				break;
-			case CWBorderPixel:
-				pPrivWin->fastBorder = FALSE;
-				break;
-		}
-	}
-	/* Again, we have no failure modes indicated by any of the routines
-	 * we've called, so we have to assume it worked */
 	return (TRUE);
 }

cfb/Makefile.am.inc

@@ -8,14 +8,14 @@ DISTCLEANFILES = $(libcfb_gen_sources)
 CFB_INCLUDES = -I$(top_srcdir)/mfb -I$(top_srcdir)/cfb
 
 libcfb_common_sources =  $(top_srcdir)/cfb/cfbgc.c $(top_srcdir)/cfb/cfbrrop.c \
-	$(top_srcdir)/cfb/cfbwindow.c $(top_srcdir)/cfb/cfbpntwin.c \
+	$(top_srcdir)/cfb/cfbwindow.c \
 	$(top_srcdir)/cfb/cfbmskbits.c $(top_srcdir)/cfb/cfbpixmap.c \
 	$(top_srcdir)/cfb/cfbbitblt.c $(top_srcdir)/cfb/cfbfillsp.c \
 	$(top_srcdir)/cfb/cfbsetsp.c $(top_srcdir)/cfb/cfbscrinit.c \
 	$(top_srcdir)/cfb/cfballpriv.c $(top_srcdir)/cfb/cfbgetsp.c \
 	$(top_srcdir)/cfb/cfbfillrct.c $(top_srcdir)/cfb/cfbigblt8.c \
 	$(top_srcdir)/cfb/cfbglblt8.c $(top_srcdir)/cfb/cfbtegblt.c \
-	$(top_srcdir)/cfb/cfbbstore.c $(top_srcdir)/cfb/cfbpolypnt.c \
+	$(top_srcdir)/cfb/cfbpolypnt.c \
 	$(top_srcdir)/cfb/cfbbres.c $(top_srcdir)/cfb/cfbline.c \
 	$(top_srcdir)/cfb/cfbhrzvert.c $(top_srcdir)/cfb/cfbbresd.c \
 	$(top_srcdir)/cfb/cfbimage.c $(top_srcdir)/cfb/cfbcppl.c \

cfb/cfb.h

@@ -56,7 +56,6 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 extern int  cfbGCPrivateIndex;
-extern int  cfbWindowPrivateIndex;
 
 /* private field of GC */
 typedef struct {
@@ -81,20 +80,6 @@ typedef struct {
     CfbBits	xor, and;
 } cfbRRopRec, *cfbRRopPtr;
 
-/* private field of window */
-typedef struct {
-    unsigned	char fastBorder; /* non-zero if border is 32 bits wide */
-    unsigned	char fastBackground;
-    unsigned short unused; /* pad for alignment with Sun compiler */
-    DDXPointRec	oldRotate;
-    PixmapPtr	pRotatedBackground;
-    PixmapPtr	pRotatedBorder;
-    } cfbPrivWin;
-
-#define cfbGetWindowPrivate(_pWin) ((cfbPrivWin *)\
-	(_pWin)->devPrivates[cfbWindowPrivateIndex].ptr)
-
-
 /* cfb8bit.c */
 
 extern int cfbSetStipple(
@@ -313,7 +298,6 @@ extern int cfb8SegmentSS1RectXor(
 
 extern Bool cfbAllocatePrivates(
     ScreenPtr /*pScreen*/,
-    int * /*window_index*/,
     int * /*gc_index*/
 );
 /* cfbbitblt.c */
@@ -486,23 +470,7 @@ extern void cfbBresD(
     int /*e2*/,
     int /*len*/
 );
-/* cfbbstore.c */
 
-extern void cfbSaveAreas(
-    PixmapPtr /*pPixmap*/,
-    RegionPtr /*prgnSave*/,
-    int /*xorg*/,
-    int /*yorg*/,
-    WindowPtr /*pWin*/
-);
-
-extern void cfbRestoreAreas(
-    PixmapPtr /*pPixmap*/,
-    RegionPtr /*prgnRestore*/,
-    int /*xorg*/,
-    int /*yorg*/,
-    WindowPtr /*pWin*/
-);
 /* cfbcmap.c */
 
 #ifndef CFB_PROTOTYPES_ONLY
@@ -771,7 +739,8 @@ extern PixmapPtr cfbCreatePixmap(
     ScreenPtr /*pScreen*/,
     int /*width*/,
     int /*height*/,
-    int /*depth*/
+    int /*depth*/,
+    unsigned /*usage_hint*/
 );
 
 extern Bool cfbDestroyPixmap(
@@ -822,27 +791,6 @@ extern void cfbFillPoly1RectGeneral(
     int /*count*/,
     DDXPointPtr /*ptsIn*/
 );
-/* cfbpntwin.c */
-
-extern void cfbPaintWindow(
-    WindowPtr /*pWin*/,
-    RegionPtr /*pRegion*/,
-    int /*what*/
-);
-
-extern void cfbFillBoxSolid(
-    DrawablePtr /*pDrawable*/,
-    int /*nBox*/,
-    BoxPtr /*pBox*/,
-    unsigned long /*pixel*/
-);
-
-extern void cfbFillBoxTile32(
-    DrawablePtr /*pDrawable*/,
-    int /*nBox*/,
-    BoxPtr /*pBox*/,
-    PixmapPtr /*tile*/
-);
 /* cfbpolypnt.c */
 
 extern void cfbPolyPoint(

cfb/cfballpriv.c

@@ -45,7 +45,6 @@ in this Software without prior written authorization from The Open Group.
 #include "mibstore.h"
 
 #if 1 || PSZ==8
-int cfbWindowPrivateIndex = -1;
 int cfbGCPrivateIndex = -1;
 #endif
 #ifdef CFB_NEED_SCREEN_PRIVATE
@@ -55,29 +54,20 @@ static unsigned long cfbGeneration = 0;
 
 
 Bool
-cfbAllocatePrivates(pScreen, window_index, gc_index)
+cfbAllocatePrivates(ScreenPtr pScreen, int *gc_index)
-    ScreenPtr	pScreen;
-    int		*window_index, *gc_index;
 {
-    if (!window_index || !gc_index ||
+    if (!gc_index || *gc_index == -1)
-	(*window_index == -1 && *gc_index == -1))
     {
-    	if (!mfbAllocatePrivates(pScreen,
+    	if (!mfbAllocatePrivates(pScreen, &cfbGCPrivateIndex))
-			     	 &cfbWindowPrivateIndex, &cfbGCPrivateIndex))
 	    return FALSE;
-    	if (window_index)
-	    *window_index = cfbWindowPrivateIndex;
     	if (gc_index)
 	    *gc_index = cfbGCPrivateIndex;
     }
     else
     {
-	cfbWindowPrivateIndex = *window_index;
 	cfbGCPrivateIndex = *gc_index;
     }
-    if (!AllocateWindowPrivate(pScreen, cfbWindowPrivateIndex,
+    if (!AllocateGCPrivate(pScreen, cfbGCPrivateIndex, sizeof(cfbPrivGC)))
-			       sizeof(cfbPrivWin)) ||
-	!AllocateGCPrivate(pScreen, cfbGCPrivateIndex, sizeof(cfbPrivGC)))
 	return FALSE;
 #ifdef CFB_NEED_SCREEN_PRIVATE
     if (cfbGeneration != serverGeneration)

cfb/cfbbitblt.c

@@ -296,7 +296,7 @@ cfbBitBlt (
     numRects = REGION_NUM_RECTS(&rgnDst);
     if (numRects && width && height)
     {
-	if(!(pptSrc = (DDXPointPtr)ALLOCATE_LOCAL(numRects *
+	if(!(pptSrc = (DDXPointPtr)xalloc(numRects *
 						  sizeof(DDXPointRec))))
 	{
 	    REGION_UNINIT(pGC->pScreen, &rgnDst);
@@ -313,7 +313,7 @@ cfbBitBlt (
 	}
 
 	(*doBitBlt) (pSrcDrawable, pDstDrawable, pGC->alu, &rgnDst, pptSrc, pGC->planemask);
-	DEALLOCATE_LOCAL(pptSrc);
+	xfree(pptSrc);
     }
 
     prgnExposed = NULL;
@@ -559,7 +559,7 @@ cfbCopyPlaneReduce (
     numRects = REGION_NUM_RECTS(&rgnDst);
     if (numRects && width && height)
     {
-	if(!(pptSrc = (DDXPointPtr)ALLOCATE_LOCAL(numRects *
+	if(!(pptSrc = (DDXPointPtr)xalloc(numRects *
 						  sizeof(DDXPointRec))))
 	{
 	    REGION_UNINIT(pGC->pScreen, &rgnDst);
@@ -576,7 +576,7 @@ cfbCopyPlaneReduce (
 	}
 
 	(*doCopyPlane) (pSrcDrawable, pDstDrawable, pGC->alu, &rgnDst, pptSrc, pGC->planemask, bitPlane);
-	DEALLOCATE_LOCAL(pptSrc);
+	xfree(pptSrc);
     }
 
     prgnExposed = NULL;
@@ -1407,7 +1407,8 @@ RegionPtr cfbCopyPlane(pSrcDrawable, pDstDrawable,
 	ScreenPtr	pScreen = pSrcDrawable->pScreen;
 	GCPtr		pGC1;
 
-	pBitmap = (*pScreen->CreatePixmap) (pScreen, width, height, 1);
+	pBitmap = (*pScreen->CreatePixmap) (pScreen, width, height, 1,
+					    CREATE_PIXMAP_USAGE_SCRATCH);
 	if (!pBitmap)
 	    return NULL;
 	pGC1 = GetScratchGC (1, pScreen);

cfb/cfbblt.c

@@ -207,13 +207,13 @@ MROP_NAME(cfbDoBitblt)(
 	if (nbox > 1)
 	{
 	    /* keep ordering in each band, reverse order of bands */
-	    pboxNew1 = (BoxPtr)ALLOCATE_LOCAL(sizeof(BoxRec) * nbox);
+	    pboxNew1 = (BoxPtr)xalloc(sizeof(BoxRec) * nbox);
 	    if(!pboxNew1)
 		return;
-	    pptNew1 = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec) * nbox);
+	    pptNew1 = (DDXPointPtr)xalloc(sizeof(DDXPointRec) * nbox);
 	    if(!pptNew1)
 	    {
-	        DEALLOCATE_LOCAL(pboxNew1);
+	        xfree(pboxNew1);
 	        return;
 	    }
 	    pboxBase = pboxNext = pbox+nbox-1;
@@ -251,16 +251,16 @@ MROP_NAME(cfbDoBitblt)(
 	if (nbox > 1)
 	{
 	    /* reverse order of rects in each band */
-	    pboxNew2 = (BoxPtr)ALLOCATE_LOCAL(sizeof(BoxRec) * nbox);
+	    pboxNew2 = (BoxPtr)xalloc(sizeof(BoxRec) * nbox);
-	    pptNew2 = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec) * nbox);
+	    pptNew2 = (DDXPointPtr)xalloc(sizeof(DDXPointRec) * nbox);
 	    if(!pboxNew2 || !pptNew2)
 	    {
-		if (pptNew2) DEALLOCATE_LOCAL(pptNew2);
+		if (pptNew2) xfree(pptNew2);
-		if (pboxNew2) DEALLOCATE_LOCAL(pboxNew2);
+		if (pboxNew2) xfree(pboxNew2);
 		if (pboxNew1)
 		{
-		    DEALLOCATE_LOCAL(pptNew1);
+		    xfree(pptNew1);
-		    DEALLOCATE_LOCAL(pboxNew1);
+		    xfree(pboxNew1);
 		}
 	        return;
 	    }
@@ -922,12 +922,12 @@ bits1 = *--psrc; --pdst; \
     }
     if (pboxNew2)
     {
-	DEALLOCATE_LOCAL(pptNew2);
+	xfree(pptNew2);
-	DEALLOCATE_LOCAL(pboxNew2);
+	xfree(pboxNew2);
     }
     if (pboxNew1)
     {
-	DEALLOCATE_LOCAL(pptNew1);
+	xfree(pptNew1);
-	DEALLOCATE_LOCAL(pboxNew1);
+	xfree(pboxNew1);
     }
 }

cfb/cfbbstore.c

@@ -1,143 +0,0 @@
-/*-
- * cfbbstore.c --
- *	Functions required by the backing-store implementation in MI.
- *
- * Copyright (c) 1987 by the Regents of the University of California
- *
- * Permission to use, copy, modify, and distribute this
- * software and its documentation for any purpose and without
- * fee is hereby granted, provided that the above copyright
- * notice appear in all copies.  The University of California
- * makes no representations about the suitability of this
- * software for any purpose.  It is provided "as is" without
- * express or implied warranty.
- *
- *
- */
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include    "cfb.h"
-#include    <X11/X.h>
-#include    "mibstore.h"
-#include    "regionstr.h"
-#include    "scrnintstr.h"
-#include    "pixmapstr.h"
-#include    "windowstr.h"
-
-/*-
- *-----------------------------------------------------------------------
- * cfbSaveAreas --
- *	Function called by miSaveAreas to actually fetch the areas to be
- *	saved into the backing pixmap. This is very simple to do, since
- *	cfbDoBitblt is designed for this very thing. The region to save is
- *	already destination-relative and we're given the offset to the
- *	window origin, so we have only to create an array of points of the
- *	u.l. corners of the boxes in the region translated to the screen
- *	coordinate system and fetch the screen pixmap out of its devPrivate
- *	field....
- *
- * Results:
- *	None.
- *
- * Side Effects:
- *	Data are copied from the screen into the pixmap.
- *
- *-----------------------------------------------------------------------
- */
-void
-cfbSaveAreas(pPixmap, prgnSave, xorg, yorg, pWin)
-    PixmapPtr	  	pPixmap;  	/* Backing pixmap */
-    RegionPtr	  	prgnSave; 	/* Region to save (pixmap-relative) */
-    int	    	  	xorg;	    	/* X origin of region */
-    int	    	  	yorg;	    	/* Y origin of region */
-    WindowPtr		pWin;
-{
-    register DDXPointPtr pPt;
-    DDXPointPtr		pPtsInit;
-    register BoxPtr	pBox;
-    register int	i;
-    ScreenPtr		pScreen = pPixmap->drawable.pScreen;
-    PixmapPtr		pScrPix;
-    
-    i = REGION_NUM_RECTS(prgnSave);
-    pPtsInit = (DDXPointPtr)ALLOCATE_LOCAL(i * sizeof(DDXPointRec));
-    if (!pPtsInit)
-	return;
-    
-    pBox = REGION_RECTS(prgnSave);
-    pPt = pPtsInit;
-    while (--i >= 0) {
-	pPt->x = pBox->x1 + xorg;
-	pPt->y = pBox->y1 + yorg;
-	pPt++;
-	pBox++;
-    }
-
-    pScrPix = (*pScreen->GetWindowPixmap)(pWin);
-
-
-    cfbDoBitbltCopy((DrawablePtr) pScrPix, (DrawablePtr)pPixmap,
-		    GXcopy, prgnSave, pPtsInit, ~0L);
-
-    DEALLOCATE_LOCAL (pPtsInit);
-}
-
-/*-
- *-----------------------------------------------------------------------
- * cfbRestoreAreas --
- *	Function called by miRestoreAreas to actually fetch the areas to be
- *	restored from the backing pixmap. This is very simple to do, since
- *	cfbDoBitblt is designed for this very thing. The region to restore is
- *	already destination-relative and we're given the offset to the
- *	window origin, so we have only to create an array of points of the
- *	u.l. corners of the boxes in the region translated to the pixmap
- *	coordinate system and fetch the screen pixmap out of its devPrivate
- *	field....
- *
- * Results:
- *	None.
- *
- * Side Effects:
- *	Data are copied from the pixmap into the screen.
- *
- *-----------------------------------------------------------------------
- */
-void
-cfbRestoreAreas(pPixmap, prgnRestore, xorg, yorg, pWin)
-    PixmapPtr	  	pPixmap;  	/* Backing pixmap */
-    RegionPtr	  	prgnRestore; 	/* Region to restore (screen-relative)*/
-    int	    	  	xorg;	    	/* X origin of window */
-    int	    	  	yorg;	    	/* Y origin of window */
-    WindowPtr		pWin;
-{
-    register DDXPointPtr pPt;
-    DDXPointPtr		pPtsInit;
-    register BoxPtr	pBox;
-    register int	i;
-    ScreenPtr		pScreen = pPixmap->drawable.pScreen;
-    PixmapPtr		pScrPix;
-    
-    i = REGION_NUM_RECTS(prgnRestore);
-    pPtsInit = (DDXPointPtr)ALLOCATE_LOCAL(i*sizeof(DDXPointRec));
-    if (!pPtsInit)
-	return;
-    
-    pBox = REGION_RECTS(prgnRestore);
-    pPt = pPtsInit;
-    while (--i >= 0) {
-	pPt->x = pBox->x1 - xorg;
-	pPt->y = pBox->y1 - yorg;
-	pPt++;
-	pBox++;
-    }
-
-    pScrPix = (*pScreen->GetWindowPixmap)(pWin);
-
-    cfbDoBitbltCopy((DrawablePtr)pPixmap, (DrawablePtr) pScrPix,
-		    GXcopy, prgnRestore, pPtsInit, ~0L);
-
-    DEALLOCATE_LOCAL (pPtsInit);
-}

cfb/cfbfillrct.c

@@ -196,7 +196,7 @@ cfbPolyFillRect(pDrawable, pGC, nrectFill, prectInit)
     numRects = REGION_NUM_RECTS(prgnClip) * nrectFill;
     if (numRects > NUM_STACK_RECTS)
     {
-	pboxClippedBase = (BoxPtr)ALLOCATE_LOCAL(numRects * sizeof(BoxRec));
+	pboxClippedBase = (BoxPtr)xalloc(numRects * sizeof(BoxRec));
 	if (!pboxClippedBase)
 	    return;
     }
@@ -301,5 +301,5 @@ cfbPolyFillRect(pDrawable, pGC, nrectFill, prectInit)
 	(*BoxFill) (pDrawable, pGC,
 		    pboxClipped-pboxClippedBase, pboxClippedBase);
     if (pboxClippedBase != stackRects)
-    	DEALLOCATE_LOCAL(pboxClippedBase);
+    	xfree(pboxClippedBase);
 }

cfb/cfbfillsp.c

@@ -186,12 +186,12 @@ int fSorted;
     n = nInit * miFindMaxBand( cfbGetCompositeClip(pGC) );
     if ( n == 0 )
 	return;
-    pwidth = (int *)ALLOCATE_LOCAL(n * sizeof(int));
+    pwidth = (int *)xalloc(n * sizeof(int));
-    ppt = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
+    ppt = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
     if(!ppt || !pwidth)
     {
-	if (ppt) DEALLOCATE_LOCAL(ppt);
+	if (ppt) xfree(ppt);
-	if (pwidth) DEALLOCATE_LOCAL(pwidth);
+	if (pwidth) xfree(pwidth);
 	return;
     }
     n = miClipSpans( cfbGetCompositeClip(pGC),
@@ -203,8 +203,8 @@ int fSorted;
 
     (*fill) (pDrawable, n, ppt, pwidth, pGC->tile.pixmap, xrot, yrot, pGC->alu, pGC->planemask);
 
-    DEALLOCATE_LOCAL(ppt);
+    xfree(ppt);
-    DEALLOCATE_LOCAL(pwidth);
+    xfree(pwidth);
 }
 
 #if PSZ == 8
@@ -251,12 +251,12 @@ int fSorted;
     n = nInit * miFindMaxBand( cfbGetCompositeClip(pGC) );
     if ( n == 0 )
 	return;
-    pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
+    pwidthFree = (int *)xalloc(n * sizeof(int));
-    pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
+    pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
     if(!pptFree || !pwidthFree)
     {
-	if (pptFree) DEALLOCATE_LOCAL(pptFree);
+	if (pptFree) xfree(pptFree);
-	if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
+	if (pwidthFree) xfree(pwidthFree);
 	return;
     }
 
@@ -392,8 +392,8 @@ int fSorted;
 	    }
 	}
     }
-    DEALLOCATE_LOCAL(pptFree);
+    xfree(pptFree);
-    DEALLOCATE_LOCAL(pwidthFree);
+    xfree(pwidthFree);
 }
 
 #else /* PSZ != 8 */
@@ -434,12 +434,12 @@ int fSorted;
     n = nInit * miFindMaxBand( cfbGetCompositeClip(pGC) );
     if ( n == 0 )
 	return;
-    pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
+    pwidthFree = (int *)xalloc(n * sizeof(int));
-    pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
+    pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
     if(!pptFree || !pwidthFree)
     {
-	if (pptFree) DEALLOCATE_LOCAL(pptFree);
+	if (pptFree) xfree(pptFree);
-	if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
+	if (pwidthFree) xfree(pwidthFree);
 	return;
     }
     pwidth = pwidthFree;
@@ -599,8 +599,8 @@ int fSorted;
 	ppt++;
 	pwidth++;
     }
-    DEALLOCATE_LOCAL(pptFree);
+    xfree(pptFree);
-    DEALLOCATE_LOCAL(pwidthFree);
+    xfree(pwidthFree);
 }
 
 #endif /* PSZ == 8 */
@@ -648,12 +648,12 @@ cfb8Stipple32FS (pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
     n = nInit * miFindMaxBand(pGC->pCompositeClip);
     if ( n == 0 )
 	return;
-    pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
+    pwidthFree = (int *)xalloc(n * sizeof(int));
-    pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
+    pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
     if(!pptFree || !pwidthFree)
     {
-	if (pptFree) DEALLOCATE_LOCAL(pptFree);
+	if (pptFree) xfree(pptFree);
-	if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
+	if (pwidthFree) xfree(pwidthFree);
 	return;
     }
     pwidth = pwidthFree;
@@ -816,8 +816,8 @@ cfb8Stipple32FS (pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
 	    }
 	}
     }
-    DEALLOCATE_LOCAL(pptFree);
+    xfree(pptFree);
-    DEALLOCATE_LOCAL(pwidthFree);
+    xfree(pwidthFree);
 }
 
 void
@@ -862,12 +862,12 @@ cfb8OpaqueStipple32FS (pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
     n = nInit * miFindMaxBand(pGC->pCompositeClip);
     if ( n == 0 )
 	return;
-    pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
+    pwidthFree = (int *)xalloc(n * sizeof(int));
-    pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
+    pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
     if(!pptFree || !pwidthFree)
     {
-	if (pptFree) DEALLOCATE_LOCAL(pptFree);
+	if (pptFree) xfree(pptFree);
-	if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
+	if (pwidthFree) xfree(pwidthFree);
 	return;
     }
     pwidth = pwidthFree;
@@ -997,8 +997,8 @@ cfb8OpaqueStipple32FS (pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
 	    }
 	}
     }
-    DEALLOCATE_LOCAL(pptFree);
+    xfree(pptFree);
-    DEALLOCATE_LOCAL(pwidthFree);
+    xfree(pwidthFree);
 }
 
 #endif /* PSZ == 8 */

cfb/cfbglblt8.c

@@ -355,7 +355,7 @@ cfbPolyGlyphBlt8Clipped(
     }
     if (!numRects)
 	return;
-    clips = (CARD32 *)ALLOCATE_LOCAL ((maxAscent + maxDescent) *
+    clips = (CARD32 *)xalloc ((maxAscent + maxDescent) *
 						sizeof (CARD32));
     while (nglyph--)
     {
@@ -471,7 +471,7 @@ cfbPolyGlyphBlt8Clipped(
 	    }
 	}
     }
-    DEALLOCATE_LOCAL (clips);
+    xfree (clips);
 }
 
 #endif /* FOUR_BIT_CODE */

cfb/cfbmap.h

@@ -71,8 +71,6 @@ in this Software without prior written authorization from The Open Group.
 #undef cfbDoBitbltGeneral
 #undef cfbDoBitbltOr
 #undef cfbDoBitbltXor
-#undef cfbFillBoxSolid
-#undef cfbFillBoxTile32
 #undef cfbFillBoxTile32sCopy
 #undef cfbFillBoxTile32sGeneral
 #undef cfbFillBoxTileOdd
@@ -108,7 +106,6 @@ in this Software without prior written authorization from The Open Group.
 #undef cfbNonTEOps
 #undef cfbNonTEOps1Rect
 #undef cfbPadPixmap
-#undef cfbPaintWindow
 #undef cfbPolyFillArcSolidCopy
 #undef cfbPolyFillArcSolidGeneral
 #undef cfbPolyFillRect
@@ -250,8 +247,6 @@ cfb can not hack PSZ yet
 #define cfbDoBitbltOr CFBNAME(DoBitbltOr)
 #define cfbDoBitbltXor CFBNAME(DoBitbltXor)
 #define cfbExpandDirectColors CFBNAME(cfbExpandDirectColors)
-#define cfbFillBoxSolid CFBNAME(FillBoxSolid)
-#define cfbFillBoxTile32 CFBNAME(FillBoxTile32)
 #define cfbFillBoxTile32sCopy CFBNAME(FillBoxTile32sCopy)
 #define cfbFillBoxTile32sGeneral CFBNAME(FillBoxTile32sGeneral)
 #define cfbFillBoxTileOdd CFBNAME(FillBoxTileOdd)
@@ -288,7 +283,6 @@ cfb can not hack PSZ yet
 #define cfbNonTEOps CFBNAME(NonTEOps)
 #define cfbNonTEOps1Rect CFBNAME(NonTEOps1Rect)
 #define cfbPadPixmap CFBNAME(PadPixmap)
-#define cfbPaintWindow CFBNAME(PaintWindow)
 #define cfbPolyFillArcSolidCopy CFBNAME(PolyFillArcSolidCopy)
 #define cfbPolyFillArcSolidGeneral CFBNAME(PolyFillArcSolidGeneral)
 #define cfbPolyFillRect CFBNAME(PolyFillRect)

cfb/cfbpixmap.c

@@ -65,11 +65,12 @@ SOFTWARE.
 #include "cfbmskbits.h"
 
 PixmapPtr
-cfbCreatePixmap (pScreen, width, height, depth)
+cfbCreatePixmap (pScreen, width, height, depth, usage_hint)
     ScreenPtr	pScreen;
     int		width;
     int		height;
     int		depth;
+    unsigned	usage_hint;
 {
     PixmapPtr pPixmap;
     size_t datasize;
@@ -122,7 +123,7 @@ cfbCopyPixmap(pSrc)
     size = pSrc->drawable.height * pSrc->devKind;
     pScreen = pSrc->drawable.pScreen;
     pDst = (*pScreen->CreatePixmap) (pScreen, pSrc->drawable.width, 
-				pSrc->drawable.height, pSrc->drawable.depth);
+				pSrc->drawable.height, pSrc->drawable.depth, 0);
     if (!pDst)
 	return NullPixmap;
     memmove((char *)pDst->devPrivate.ptr, (char *)pSrc->devPrivate.ptr, size);
@@ -269,7 +270,7 @@ cfbXRotatePixmap(pPix, rw)
 	int size, tsize;
 
 	tsize = PixmapBytePad(pPix->drawable.width - rot, pPix->drawable.depth);
-	pwTmp = (CfbBits *) ALLOCATE_LOCAL(pPix->drawable.height * tsize);
+	pwTmp = (CfbBits *) xalloc(pPix->drawable.height * tsize);
 	if (!pwTmp)
 	    return;
 	/* divide pw (the pixmap) in two vertically at (w - rot) and swap */
@@ -287,7 +288,7 @@ cfbXRotatePixmap(pPix, rw)
 		    0, 0, rot, 0,
 		    (int)pPix->drawable.width - rot, (int)pPix->drawable.height,
 		    tsize, size);
-	DEALLOCATE_LOCAL(pwTmp);
+	xfree(pwTmp);
 #endif
     }
 }
@@ -327,13 +328,13 @@ cfbYRotatePixmap(pPix, rh)
 
     nbyDown = rot * pPix->devKind;
     nbyUp = (pPix->devKind * pPix->drawable.height) - nbyDown;
-    if(!(ptmp = (char *)ALLOCATE_LOCAL(nbyUp)))
+    if(!(ptmp = (char *)xalloc(nbyUp)))
 	return;
 
     memmove(ptmp, pbase, nbyUp);		/* save the low rows */
     memmove(pbase, pbase+nbyUp, nbyDown);	/* slide the top rows down */
     memmove(pbase+nbyDown, ptmp, nbyUp);	/* move lower rows up to row rot */
-    DEALLOCATE_LOCAL(ptmp);
+    xfree(ptmp);
 }
 
 void

cfb/cfbpntwin.c

@@ -1,768 +0,0 @@
-/***********************************************************
-
-Copyright 1987, 1998  The Open Group
-
-Permission to use, copy, modify, distribute, and sell this software and its
-documentation for any purpose is hereby granted without fee, provided that
-the above copyright notice appear in all copies and that both that
-copyright notice and this permission notice appear in supporting
-documentation.
-
-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 THE
-OPEN GROUP 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 The Open Group shall not be
-used in advertising or otherwise to promote the sale, use or other dealings
-in this Software without prior written authorization from The Open Group.
-
-
-Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
-
-                        All Rights Reserved
-
-Permission to use, copy, modify, and distribute this software and its 
-documentation for any purpose and without fee is hereby granted, 
-provided that the above copyright notice appear in all copies and that
-both that copyright notice and this permission notice appear in 
-supporting documentation, and that the name of Digital not be
-used in advertising or publicity pertaining to distribution of the
-software without specific, written prior permission.  
-
-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
-SOFTWARE.
-
-******************************************************************/
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include <X11/X.h>
-
-#include "windowstr.h"
-#include "regionstr.h"
-#include "pixmapstr.h"
-#include "scrnintstr.h"
-
-#include "cfb.h"
-#include "cfbmskbits.h"
-#include "mi.h"
-
-#ifdef PANORAMIX
-#include "panoramiX.h"
-#include "panoramiXsrv.h"
-#endif
-
-void
-cfbPaintWindow(pWin, pRegion, what)
-    WindowPtr	pWin;
-    RegionPtr	pRegion;
-    int		what;
-{
-    register cfbPrivWin	*pPrivWin;
-    WindowPtr	pBgWin;
-
-    pPrivWin = cfbGetWindowPrivate(pWin);
-
-
-    switch (what) {
-    case PW_BACKGROUND:
-	switch (pWin->backgroundState) {
-	case None:
-	    break;
-	case ParentRelative:
-	    do {
-		pWin = pWin->parent;
-	    } while (pWin->backgroundState == ParentRelative);
-	    (*pWin->drawable.pScreen->PaintWindowBackground)(pWin, pRegion,
-							     what);
-	    break;
-	case BackgroundPixmap:
-	    if (pPrivWin->fastBackground)
-	    {
-		cfbFillBoxTile32 ((DrawablePtr)pWin,
-				  (int)REGION_NUM_RECTS(pRegion),
-				  REGION_RECTS(pRegion),
-				  pPrivWin->pRotatedBackground);
-	    }
-	    else
-	    {
-		int xorg = pWin->drawable.x;
-		int yorg = pWin->drawable.y;
-#ifdef PANORAMIX
-		if(!noPanoramiXExtension) {
-		    int index = pWin->drawable.pScreen->myNum;
-		    if(WindowTable[index] == pWin) {
-			xorg -= panoramiXdataPtr[index].x;
-			yorg -= panoramiXdataPtr[index].y;
-		    }
-		}
-#endif
-		cfbFillBoxTileOdd ((DrawablePtr)pWin,
-				   (int)REGION_NUM_RECTS(pRegion),
-				   REGION_RECTS(pRegion),
-				   pWin->background.pixmap,
-				   xorg, yorg);
-	    }
-	    break;
-	case BackgroundPixel:
-	    cfbFillBoxSolid ((DrawablePtr)pWin,
-			     (int)REGION_NUM_RECTS(pRegion),
-			     REGION_RECTS(pRegion),
-			     pWin->background.pixel);
-	    break;
-    	}
-    	break;
-    case PW_BORDER:
-	if (pWin->borderIsPixel)
-	{
-	    cfbFillBoxSolid ((DrawablePtr)pWin,
-			     (int)REGION_NUM_RECTS(pRegion),
-			     REGION_RECTS(pRegion),
-			     pWin->border.pixel);
-	}
-	else if (pPrivWin->fastBorder)
-	{
-	    cfbFillBoxTile32 ((DrawablePtr)pWin,
-			      (int)REGION_NUM_RECTS(pRegion),
-			      REGION_RECTS(pRegion),
-			      pPrivWin->pRotatedBorder);
-	}
-	else
-	{
-	    int xorg, yorg;
-
-	    for (pBgWin = pWin;
-		 pBgWin->backgroundState == ParentRelative;
-		 pBgWin = pBgWin->parent);
-
-	    xorg = pBgWin->drawable.x;
-	    yorg = pBgWin->drawable.y;
-
-#ifdef PANORAMIX
-	    if(!noPanoramiXExtension) {
-		int index = pWin->drawable.pScreen->myNum;
-		if(WindowTable[index] == pBgWin) {
-		    xorg -= panoramiXdataPtr[index].x;
-		    yorg -= panoramiXdataPtr[index].y;
-		}
-	    }
-#endif
-
-	    cfbFillBoxTileOdd ((DrawablePtr)pWin,
-			       (int)REGION_NUM_RECTS(pRegion),
-			       REGION_RECTS(pRegion),
-			       pWin->border.pixmap,
-			       xorg, yorg);
-	}
-	break;
-    }
-}
-
-/*
- * Use the RROP macros in copy mode
- */
-
-#define RROP GXcopy
-#include "cfbrrop.h"
-
-#ifdef RROP_UNROLL
-# define Expand(left,right,leftAdjust) {\
-    int part = nmiddle & RROP_UNROLL_MASK; \
-    int widthStep; \
-    widthStep = widthDst - nmiddle - leftAdjust; \
-    nmiddle >>= RROP_UNROLL_SHIFT; \
-    while (h--) { \
-	left \
-	pdst += part; \
-	switch (part) { \
-	    RROP_UNROLL_CASE(pdst) \
-	} \
-	m = nmiddle; \
-	while (m) { \
-	    pdst += RROP_UNROLL; \
-	    RROP_UNROLL_LOOP(pdst) \
-	    m--; \
-	} \
-	right \
-	pdst += widthStep; \
-    } \
-}
-
-#else
-# define Expand(left, right, leftAdjust) { \
-    int widthStep; \
-    widthStep = widthDst - nmiddle - leftAdjust; \
-    while (h--) { \
-	left \
-	m = nmiddle; \
-	while (m--) {\
-	    RROP_SOLID(pdst); \
-	    pdst++; \
-	} \
-	right \
-	pdst += widthStep; \
-    } \
-}
-#endif
-
-void
-cfbFillBoxSolid (pDrawable, nBox, pBox, pixel)
-    DrawablePtr	    pDrawable;
-    int		    nBox;
-    BoxPtr	    pBox;
-    unsigned long   pixel;
-{
-    CfbBits   *pdstBase;
-    int		    widthDst;
-    register int    h;
-    register CfbBits   *pdst;
-    int		    nmiddle;
-    int		    w;
-#if PSZ == 24
-    int leftIndex, rightIndex;
-    CfbBits piQxelArray[3], *pdstULC; /*upper left corner*/
-
-    piQxelArray[0] = (pixel&0xFFFFFF) | ((pixel&0xFF)<<24);
-    piQxelArray[1] = ((pixel&0xFFFF00)>>8) | ((pixel&0xFFFF)<<16);
-    piQxelArray[2] = ((pixel&0xFFFFFF)<<8) | ((pixel&0xFF0000)>>16);
-#else
-    register CfbBits   rrop_xor;
-    register CfbBits   leftMask, rightMask;
-    register int    m;
-#endif
-
-    cfbGetLongWidthAndPointer(pDrawable, widthDst, pdstBase);
-
-#if PSZ != 24
-    rrop_xor = PFILL(pixel);
-#endif
-    for (; nBox; nBox--, pBox++)
-    {
-    	pdst = pdstBase + pBox->y1 * widthDst;
-    	h = pBox->y2 - pBox->y1;
-	w = pBox->x2 - pBox->x1;
-#if PSZ == 8
-	if (w == 1)
-	{
-	    register char    *pdstb = ((char *) pdst) + pBox->x1;
-	    int	    incr = widthDst * PGSZB;
-
-	    while (h--)
-	    {
-		*pdstb = rrop_xor;
-		pdstb += incr;
-	    }
-	}
-	else
-	{
-#endif
-#if PSZ == 24
-/* _Box has x1, y1, x2, y2*/
-	  leftIndex = pBox->x1 & 3;
-	  rightIndex = ((leftIndex+w)<5)?0:(pBox->x2 &3);
-	  nmiddle = w - rightIndex;
-	  if(leftIndex){
-	      nmiddle -= (4 - leftIndex);
-	  }
-	  nmiddle >>= 2;
-	  if(nmiddle < 0)
-	    nmiddle = 0;
-
-	  pdst = pdstBase + pBox->y1 * widthDst + ((pBox->x1*3) >> 2);
-
-	  switch(leftIndex+w){
-	  case 4:
-	    switch(leftIndex){
-	    case 0:
-	      while(h--){
-		*pdst++ = piQxelArray[0];
-		*pdst++ = piQxelArray[1];
-		*pdst   = piQxelArray[2];
-		pdst -=2;
-		pdst += widthDst;
-	      }
-	      break;
-	    case 1:
-	      while(h--){
-		*pdst = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
-		pdst++;
-		*pdst++ = piQxelArray[1];
-		*pdst   = piQxelArray[2];
-		pdst -=2;
-		pdst += widthDst;
-	      }
-	      break;
-	    case 2:
-	      while(h--){
-		*pdst = ((*pdst) & 0xFFFF) | (piQxelArray[1] & 0xFFFF0000);
-		pdst++;
-		*pdst-- = piQxelArray[2];
-		pdst += widthDst;
-	      }
-	      break;
-	    case 3:
-	      while(h--){
-		*pdst = ((*pdst) & 0xFF) | (piQxelArray[2] & 0xFFFFFF00);
-		pdst += widthDst;
-	      }
-	      break;
-	    }
-	    break;
-	  case 3:
-	    switch(leftIndex){
-	    case 0:
-	      while(h--){
-		*pdst++ = piQxelArray[0];
-		*pdst++ = piQxelArray[1];
-		*pdst = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
-		pdst--;
-		pdst--;
-		pdst += widthDst;
-	      }
-	      break;
-	    case 1:
-	      while(h--){
-		*pdst = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
-		pdst++;
-		*pdst++ = piQxelArray[1];
-		*pdst = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
-		pdst--;
-		pdst--;
-		pdst += widthDst;
-	      }
-	      break;
-	    case 2:
-	      while(h--){
-		*pdst = ((*pdst) & 0xFFFF) | (piQxelArray[1] & 0xFFFF0000);
-		pdst++;
-		*pdst = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
-		pdst--;
-		pdst += widthDst;
-	      }
-	      break;
-	    }
-	    break;
-	  case 2:
-	    while(h--){
-	      if(leftIndex){
-		*pdst = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
-		pdst++;
-	      }
-	      else{
-		*pdst++ = piQxelArray[0];
-	      }
-		*pdst = ((*pdst) & 0xFFFF0000) | (piQxelArray[1] & 0xFFFF);
-		pdst--;
-		pdst += widthDst;
-	    }
-	    break;
-	  case 1: /*only if leftIndex = 0 and w = 1*/
-	    while(h--){
-		*pdst = ((*pdst) & 0xFF000000) | (piQxelArray[0] & 0xFFFFFF);
-		pdst += widthDst;
-	      }
-	    break;
-	  case 0: /*never*/
-	    break;
-	  default:
-	  {
-	    w = nmiddle;
-	    pdstULC = pdst;
-/*	    maskbits (pBox->x1, w, leftMask, rightMask, nmiddle);*/
-	    while(h--){
-	      nmiddle = w;
-	      pdst = pdstULC;
-	      switch(leftIndex){
-	      case 0:
-		break;
-	      case 1:
-		*pdst = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
-		pdst++;
-		*pdst++ = piQxelArray[1];
-		*pdst++ = piQxelArray[2];
-	        break;
-	      case 2:
-		*pdst = ((*pdst) & 0xFFFF) | (piQxelArray[1] & 0xFFFF0000);
-		pdst++;
-		*pdst++ = piQxelArray[2];
-	        break;
-	      case 3:
-		*pdst = ((*pdst) & 0xFF) | (piQxelArray[2] & 0xFFFFFF00);
-		pdst++;
-	        break;
-	      }
-	      while(nmiddle--){
-		*pdst++ = piQxelArray[0];
-		*pdst++ = piQxelArray[1];
-		*pdst++ = piQxelArray[2];
-	      }
-	      switch(rightIndex){
-	      case 0:
-		break;
-	      case 1:
-		*pdst = ((*pdst) & 0xFF000000) | (piQxelArray[0] & 0xFFFFFF);
-	        break;
-	      case 2:
-		*pdst++ = piQxelArray[0];
-		*pdst = ((*pdst) & 0xFFFF0000) | (piQxelArray[1] & 0xFFFF);
-	        break;
-	      case 3:
-		*pdst++ = piQxelArray[0];
-		*pdst++ = piQxelArray[1];
-		*pdst = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
-	        break;
-	    }
-	    pdstULC += widthDst;
-	    }
-
-	  }
-	}
-#else
-	pdst += (pBox->x1 >> PWSH);
-	if ((pBox->x1 & PIM) + w <= PPW)
-	{
-	    maskpartialbits(pBox->x1, w, leftMask);
-	    while (h--) {
-		*pdst = (*pdst & ~leftMask) | (rrop_xor & leftMask);
-		pdst += widthDst;
-	    }
-	}
-	else
-	{
-	    maskbits (pBox->x1, w, leftMask, rightMask, nmiddle);
-	    if (leftMask)
-	    {
-		if (rightMask)
-		{
-		    Expand (RROP_SOLID_MASK (pdst, leftMask); pdst++; ,
-			    RROP_SOLID_MASK (pdst, rightMask); ,
-			    1)
-		}
-		else
-		{
-		    Expand (RROP_SOLID_MASK (pdst, leftMask); pdst++;,
-			    ;,
-			    1)
-		}
-	    }
-	    else
-	    {
-		if (rightMask)
-		{
-		    Expand (;,
-			    RROP_SOLID_MASK (pdst, rightMask);,
-			    0)
-		}
-		else
-		{
-		    Expand (;,
-			    ;,
-			    0)
-		}
-	    }
-	}
-#endif
-#if PSZ == 8
-	}
-#endif
-    }
-}
-
-void
-cfbFillBoxTile32 (pDrawable, nBox, pBox, tile)
-    DrawablePtr	    pDrawable;
-    int		    nBox;	/* number of boxes to fill */
-    BoxPtr 	    pBox;	/* pointer to list of boxes to fill */
-    PixmapPtr	    tile;	/* rotated, expanded tile */
-{
-    register CfbBits  *pdst;
-    CfbBits	    *psrc;
-    int			    tileHeight;
-
-    int			    widthDst;
-    int			    w;
-    int			    h;
-    int			    nmiddle;
-    int			    y;
-    int			    srcy;
-
-    CfbBits	    *pdstBase;
-#if PSZ == 24
-    int			    leftIndex, rightIndex;
-    CfbBits piQxelArray[3], *pdstULC;
-#else
-    register CfbBits  rrop_xor;	
-    register CfbBits  leftMask;
-    register CfbBits  rightMask;
-    register int      m;
-#endif
-
-    tileHeight = tile->drawable.height;
-    psrc = (CfbBits *)tile->devPrivate.ptr;
-
-    cfbGetLongWidthAndPointer (pDrawable, widthDst, pdstBase);
-
-    while (nBox--)
-    {
-#if PSZ == 24
-	w = pBox->x2 - pBox->x1;
-	h = pBox->y2 - pBox->y1;
-	y = pBox->y1;
-	leftIndex = pBox->x1 & 3;
-/*	rightIndex = ((leftIndex+w)<5)?0:pBox->x2 &3;*/
-	rightIndex = pBox->x2 &3;
-	nmiddle = w - rightIndex;
-	if(leftIndex){
-	  nmiddle -= (4 - leftIndex);
-	}
-	nmiddle >>= 2;
-	if(nmiddle < 0)
-	  nmiddle = 0;
-
-	pdst = pdstBase + ((pBox->x1 *3)>> 2) +  pBox->y1 * widthDst;
-	srcy = y % tileHeight;
-
-#define StepTile    piQxelArray[0] = (psrc[srcy] & 0xFFFFFF) | ((psrc[srcy] & 0xFF)<<24); \
-		    piQxelArray[1] = (psrc[srcy] & 0xFFFF00) | ((psrc[srcy] & 0xFFFF)<<16); \
-		    piQxelArray[2] = ((psrc[srcy] & 0xFF0000)>>16) | \
-		    		     ((psrc[srcy] & 0xFFFFFF)<<8); \
-		    /*rrop_xor = psrc[srcy];*/ \
-		    ++srcy; \
-		    if (srcy == tileHeight) \
-		        srcy = 0;
-
-	  switch(leftIndex+w){
-	  case 4:
-	    switch(leftIndex){
-	    case 0:
-	      while(h--){
-		  StepTile
-		*pdst++ = piQxelArray[0];
-		*pdst++ = piQxelArray[1];
-		*pdst   = piQxelArray[2];
-		pdst-=2;
-		pdst += widthDst;
-	      }
-	      break;
-	    case 1:
-	      while(h--){
-		  StepTile
-		*pdst = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
-		pdst++;
-		*pdst++ = piQxelArray[1];
-		*pdst   = piQxelArray[2];
-		pdst-=2;
-		pdst += widthDst;
-	      }
-	      break;
-	    case 2:
-	      while(h--){
-		  StepTile
-		*pdst = ((*pdst) & 0xFFFF) | (piQxelArray[1] & 0xFFFF0000);
-		pdst++;
-		*pdst--   = piQxelArray[2];
-		pdst += widthDst;
-	      }
-	      break;
-	    case 3:
-	      while(h--){
-		  StepTile
-		*pdst = ((*pdst) & 0xFF) | (piQxelArray[2] & 0xFFFFFF00);
-		pdst += widthDst;
-	      }
-	      break;
-	    }
-	    break;
-	  case 3:
-	    switch(leftIndex){
-	    case 0:
-	      while(h--){
-		  StepTile
-		*pdst++ = piQxelArray[0];
-		*pdst++ = piQxelArray[1];
-		*pdst = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
-		pdst--;
-		pdst--;
-		pdst += widthDst;
-	      }
-	      break;
-	    case 1:
-	      while(h--){
-		  StepTile
-		*pdst = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
-		pdst++;
-		*pdst++ = piQxelArray[1];
-		*pdst = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
-		pdst--;
-		pdst--;
-		pdst += widthDst;
-	      }
-	      break;
-	    case 2:
-	      while(h--){
-		  StepTile
-		*pdst = ((*pdst) & 0xFFFF) | (piQxelArray[1] & 0xFFFF0000);
-		pdst++;
-		*pdst = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
-		pdst--;
-		pdst += widthDst;
-	      }
-	      break;
-	    }
-	    break;
-	  case 2:
-	    while(h--){
-		  StepTile
-	      if(leftIndex){
-		*pdst = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
-		pdst++;
-	      }
-	      else{
-		*pdst++ = piQxelArray[0];
-	      }
-		*pdst = ((*pdst) & 0xFFFF0000) | (piQxelArray[1] & 0xFFFF);
-		pdst--;
-		pdst += widthDst;
-	    }
-	    break;
-	  case 1: /*only if leftIndex = 0 and w = 1*/
-	    while(h--){
-		  StepTile
-		*pdst = ((*pdst) & 0xFF000000) | (piQxelArray[0] & 0xFFFFFF);
-		pdst += widthDst;
-	      }
-	    break;
-	  case 0: /*never*/
-	    break;
-	  default:
-	  {
-	    w = nmiddle;
-	    pdstULC = pdst;
-
-	    while(h--){
-	      StepTile
-	      nmiddle = w;
-	      pdst = pdstULC;
-	      switch(leftIndex){
-	      case 0:
-		break;
-	      case 1:
-		*pdst = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
-		pdst++;
-		*pdst++ = piQxelArray[1];
-		*pdst++ = piQxelArray[2];
-	        break;
-	      case 2:
-		*pdst = ((*pdst) & 0xFFFF) | (piQxelArray[1] & 0xFFFF0000);
-		pdst++;
-		*pdst++ = piQxelArray[2];
-	        break;
-	      case 3:
-		*pdst = ((*pdst) & 0xFF) | (piQxelArray[2] & 0xFFFFFF00);
-		pdst++;
-	        break;
-	      }
-	      while(nmiddle--){
-		*pdst++ = piQxelArray[0];
-		*pdst++ = piQxelArray[1];
-		*pdst++ = piQxelArray[2];
-	      }
-	      switch(rightIndex){
-	      case 0:
-		break;
-	      case 1:
-		*pdst = ((*pdst) & 0xFF000000) | (piQxelArray[0] & 0xFFFFFF);
-		break;
-	      case 2:
-		*pdst++ = piQxelArray[0];
-		*pdst = ((*pdst) & 0xFFFF0000) | (piQxelArray[1] & 0xFFFF);
-		break;
-	      case 3:
-		*pdst++ = piQxelArray[0];
-		*pdst++ = piQxelArray[1];
-		*pdst = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
-		break;
-	      }
-	      pdstULC += widthDst;
-	    }
-	  }
-	  }
-#else
-	w = pBox->x2 - pBox->x1;
-	h = pBox->y2 - pBox->y1;
-	y = pBox->y1;
-	pdst = pdstBase + (pBox->y1 * widthDst) + (pBox->x1 >> PWSH);
-	srcy = y % tileHeight;
-
-#define StepTile    rrop_xor = psrc[srcy]; \
-		    ++srcy; \
-		    if (srcy == tileHeight) \
-		        srcy = 0;
-
-	if ( ((pBox->x1 & PIM) + w) < PPW)
-	{
-	    maskpartialbits(pBox->x1, w, leftMask);
-	    rightMask = ~leftMask;
-	    while (h--)
-	    {
-		StepTile
-		*pdst = (*pdst & rightMask) | (rrop_xor & leftMask);
-		pdst += widthDst;
-	    }
-	}
-	else
-	{
-	    maskbits(pBox->x1, w, leftMask, rightMask, nmiddle);
-
-	    if (leftMask)
-	    {
-		if (rightMask)
-		{
-		    Expand (StepTile
-			    RROP_SOLID_MASK(pdst, leftMask); pdst++;,
-			    RROP_SOLID_MASK(pdst, rightMask);,
-			    1)
-		}
-		else
-		{
-		    Expand (StepTile
-			    RROP_SOLID_MASK(pdst, leftMask); pdst++;,
-			    ;,
-			    1)
-		}
-	    }
-	    else
-	    {
-		if (rightMask)
-		{
-		    Expand (StepTile
-			    ,
-			    RROP_SOLID_MASK(pdst, rightMask);,
-			    0)
-		}
-		else
-		{
-		    Expand (StepTile
-			    ,
-			    ;,
-			    0)
-		}
-	    }
-	}
-#endif
-        pBox++;
-    }
-}

cfb/cfbscrinit.c

@@ -46,14 +46,6 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include "cfbmskbits.h"
 #include "mibstore.h"
 
-BSFuncRec cfbBSFuncRec = {
-    cfbSaveAreas,
-    cfbRestoreAreas,
-    (BackingStoreSetClipmaskRgnProcPtr) 0,
-    (BackingStoreGetImagePixmapProcPtr) 0,
-    (BackingStoreGetSpansPixmapProcPtr) 0,
-};
-
 Bool
 cfbCloseScreen (index, pScreen)
     int		index;
@@ -96,7 +88,7 @@ cfbSetupScreen(pScreen, pbits, xsize, ysize, dpix, dpiy, width)
     int dpix, dpiy;		/* dots per inch */
     int width;			/* pixel width of frame buffer */
 {
-    if (!cfbAllocatePrivates(pScreen, (int *) 0, (int *) 0))
+    if (!cfbAllocatePrivates(pScreen, NULL))
 	return FALSE;
     pScreen->defColormap = FakeClientID(0);
     /* let CreateDefColormap do whatever it wants for pixels */ 
@@ -111,8 +103,6 @@ cfbSetupScreen(pScreen, pbits, xsize, ysize, dpix, dpiy, width)
     pScreen->ChangeWindowAttributes = cfbChangeWindowAttributes;
     pScreen->RealizeWindow = cfbMapWindow;
     pScreen->UnrealizeWindow = cfbUnmapWindow;
-    pScreen->PaintWindowBackground = cfbPaintWindow;
-    pScreen->PaintWindowBorder = cfbPaintWindow;
     pScreen->CopyWindow = cfbCopyWindow;
     pScreen->CreatePixmap = cfbCreatePixmap;
     pScreen->DestroyPixmap = cfbDestroyPixmap;
@@ -184,7 +174,6 @@ cfbFinishScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width)
     pScreen->devPrivates[cfbScreenPrivateIndex].ptr = pScreen->devPrivate;
     pScreen->devPrivate = oldDevPrivate;
 #endif
-    pScreen->BackingStoreFuncs = cfbBSFuncRec;
     pScreen->GetScreenPixmap = cfbGetScreenPixmap;
     pScreen->SetScreenPixmap = cfbSetScreenPixmap;
     return TRUE;