DRI trunk-20040613 import

GL/glx/g_disptab.c

@@ -54,18 +54,18 @@ __GLXdispatchSingleProcPtr __glXSingleTable[__GLX_SINGLE_TABLE_SIZE] = {
 	__glXQueryExtensionsString,
 	__glXQueryServerString,
 	__glXClientInfo,
-	__glXNoSuchSingleOpcode, /* glXGetFBConfigs */
+	__glXGetFBConfigs,
-	__glXNoSuchSingleOpcode, /* glXCreatePixmap */
+	__glXCreatePixmap,
-	__glXNoSuchSingleOpcode, /* glXDestroyPixmap */
+	__glXDestroyGLXPixmap, /* glXDestroyPixmap */
-	__glXNoSuchSingleOpcode, /* glXCreateNewContext */
+	__glXCreateNewContext,
 	__glXNoSuchSingleOpcode, /* glXQueryContext */
 	__glXMakeContextCurrent,
-	__glXNoSuchSingleOpcode,
+	__glXNoSuchSingleOpcode, /* glXCreatePbuffer */
-	__glXNoSuchSingleOpcode,
+	__glXNoSuchSingleOpcode, /* glXDestroyPbuffer */
-	__glXNoSuchSingleOpcode,
+	__glXNoSuchSingleOpcode, /* glXGetDrawableAttributes */
-	__glXNoSuchSingleOpcode,
+	__glXNoSuchSingleOpcode, /* glXChangeDrawableAttributes */
-	__glXNoSuchSingleOpcode,
+	__glXNoSuchSingleOpcode, /* glXCreateWindow */
-	__glXNoSuchSingleOpcode,
+	__glXNoSuchSingleOpcode, /* glXDestroyWindow */
 	__glXNoSuchSingleOpcode,
 	__glXNoSuchSingleOpcode,
 	__glXNoSuchSingleOpcode,
@@ -425,7 +425,7 @@ __GLXdispatchRenderProcPtr __glXRenderTable[] = {
 	__glXNoSuchRenderOpcode,
 	__glXNoSuchRenderOpcode,
 	__glXNoSuchRenderOpcode,
-	__glXNoSuchRenderOpcode,
+	__glXDisp_SampleCoverageARB,
 	__glXDisp_WindowPos3fARB /* 230 */
 };
 
@@ -451,18 +451,18 @@ __GLXdispatchSingleProcPtr __glXSwapSingleTable[__GLX_SINGLE_TABLE_SIZE] = {
 	__glXSwapQueryExtensionsString,
 	__glXSwapQueryServerString,
 	__glXSwapClientInfo,
-	__glXNoSuchSingleOpcode, /* glXGetFBConfigs */
+	__glXSwapGetFBConfigs,
-	__glXNoSuchSingleOpcode, /* glXCreatePixmap */
+	__glXSwapCreatePixmap,
-	__glXNoSuchSingleOpcode, /* glXDestroyPixmap */
+	__glXSwapDestroyGLXPixmap, /* glXDestroyPixmap */
-	__glXNoSuchSingleOpcode, /* glXCreateNewContext */
+	__glXSwapCreateNewContext,
 	__glXNoSuchSingleOpcode, /* glXQueryContext */
 	__glXSwapMakeContextCurrent,
-	__glXNoSuchSingleOpcode,
+	__glXNoSuchSingleOpcode, /* glXCreatePbuffer */
-	__glXNoSuchSingleOpcode,
+	__glXNoSuchSingleOpcode, /* glXDestroyPbuffer */
-	__glXNoSuchSingleOpcode,
+	__glXNoSuchSingleOpcode, /* glXGetDrawableAttributes */
-	__glXNoSuchSingleOpcode,
+	__glXNoSuchSingleOpcode, /* glXChangeDrawableAttributes */
-	__glXNoSuchSingleOpcode,
+	__glXNoSuchSingleOpcode, /* glXCreateWindow */
-	__glXNoSuchSingleOpcode,
+	__glXNoSuchSingleOpcode, /* glXDestroyWindow */
 	__glXNoSuchSingleOpcode,
 	__glXNoSuchSingleOpcode,
 	__glXNoSuchSingleOpcode,
@@ -822,6 +822,6 @@ __GLXdispatchRenderProcPtr __glXSwapRenderTable[__GLX_RENDER_TABLE_SIZE] = {
 	__glXNoSuchRenderOpcode,
 	__glXNoSuchRenderOpcode,
 	__glXNoSuchRenderOpcode,
-	__glXNoSuchRenderOpcode,
+	__glXDispSwap_SampleCoverageARB,
 	__glXDispSwap_WindowPos3fARB /* 230 */
 };

GL/glx/g_disptab.h

@@ -52,6 +52,9 @@ extern int __glXQueryExtensionsString(__GLXclientState*, GLbyte*);
 extern int __glXQueryServerString(__GLXclientState*, GLbyte*);
 extern int __glXClientInfo(__GLXclientState*, GLbyte*);
 extern int __glXMakeContextCurrent(__GLXclientState*, GLbyte*);
+extern int __glXGetFBConfigs(__GLXclientState*, GLbyte*);
+extern int __glXCreateNewContext(__GLXclientState*, GLbyte*);
+extern int __glXCreatePixmap(__GLXclientState*, GLbyte*);
 
 extern int __glXDisp_NewList(__GLXclientState*, GLbyte*);
 extern int __glXDisp_EndList(__GLXclientState*, GLbyte*);
@@ -325,6 +328,7 @@ extern void __glXDisp_MultiTexCoord4dvARB(GLbyte*);
 extern void __glXDisp_MultiTexCoord4fvARB(GLbyte*);
 extern void __glXDisp_MultiTexCoord4ivARB(GLbyte*);
 extern void __glXDisp_MultiTexCoord4svARB(GLbyte*);
+extern void __glXDisp_SampleCoverageARB(GLbyte *);
 extern void __glXDisp_WindowPos3fARB(GLbyte *);
 
 extern int __glXSwapRender(__GLXclientState*, GLbyte*);
@@ -348,6 +352,9 @@ extern int __glXSwapQueryExtensionsString(__GLXclientState*, GLbyte*);
 extern int __glXSwapQueryServerString(__GLXclientState*, GLbyte*);
 extern int __glXSwapClientInfo(__GLXclientState*, GLbyte*);
 extern int __glXSwapMakeContextCurrent(__GLXclientState*, GLbyte*);
+extern int __glXSwapGetFBConfigs(__GLXclientState*, GLbyte*);
+extern int __glXSwapCreateNewContext(__GLXclientState*, GLbyte*);
+extern int __glXSwapCreatePixmap(__GLXclientState*, GLbyte*);
 
 extern int __glXDispSwap_NewList(__GLXclientState*, GLbyte*);
 extern int __glXDispSwap_EndList(__GLXclientState*, GLbyte*);
@@ -621,6 +628,7 @@ extern void __glXDispSwap_MultiTexCoord4dvARB(GLbyte*);
 extern void __glXDispSwap_MultiTexCoord4fvARB(GLbyte*);
 extern void __glXDispSwap_MultiTexCoord4ivARB(GLbyte*);
 extern void __glXDispSwap_MultiTexCoord4svARB(GLbyte*);
+extern void __glXDispSwap_SampleCoverageARB(GLbyte *);
 extern void __glXDispSwap_WindowPos3fARB(GLbyte *);
 
 #define __GLX_MIN_GLXCMD_OPCODE 1

GL/glx/g_disptab_EXT.c

@@ -2104,22 +2104,22 @@ __GLXdispatchRenderProcPtr __glXRenderTable_EXT[__GLX_MAX_RENDER_OPCODE_EXT - __
 	__glXDisp_CopyTexSubImage1D,  /* 4121 */
 	__glXDisp_CopyTexSubImage2D,  /* 4122 */
 	__glXDisp_CopyTexSubImage3D,  /* 4123 */
-	__glXNoSuchRenderOpcode, /* 4124 */
+	__glXDisp_FogCoordfv,         /* 4124 */
-	__glXNoSuchRenderOpcode,
+	__glXDisp_FogCoorddv,         /* 4125 */
-	__glXNoSuchRenderOpcode,
+	__glXDisp_SecondaryColor3bv,  /* 4126 */
-	__glXNoSuchRenderOpcode,
+	__glXDisp_SecondaryColor3sv,  /* 4127 */
-	__glXNoSuchRenderOpcode,
+	__glXDisp_SecondaryColor3iv,  /* 4128 */
-	__glXNoSuchRenderOpcode,
+	__glXDisp_SecondaryColor3fv,  /* 4129 */
-	__glXNoSuchRenderOpcode, /* 4130 */
+	__glXDisp_SecondaryColor3dv,  /* 4130 */
-	__glXNoSuchRenderOpcode,
+	__glXDisp_SecondaryColor3ubv, /* 4131 */
-	__glXNoSuchRenderOpcode,
+	__glXDisp_SecondaryColor3usv, /* 4132 */
-	__glXNoSuchRenderOpcode,
+	__glXDisp_SecondaryColor3uiv, /* 4133 */
-	__glXNoSuchRenderOpcode,
+	__glXDisp_BlendFuncSeparate,  /* 4134 */
-	__glXNoSuchRenderOpcode,
+	__glXNoSuchRenderOpcode,      /* 4135 */
-	__glXNoSuchRenderOpcode,
+	__glXNoSuchRenderOpcode,      /* 4136 */
-	__glXNoSuchRenderOpcode,
+	__glXNoSuchRenderOpcode,      /* 4137 */
-	__glXNoSuchRenderOpcode,
+	__glXNoSuchRenderOpcode,      /* 4138 */
-	__glXNoSuchRenderOpcode,
+	__glXNoSuchRenderOpcode,      /* 4139 */
 	__glXNoSuchRenderOpcode, /* 4140 */
 	__glXNoSuchRenderOpcode,
 	__glXNoSuchRenderOpcode,
@@ -2201,6 +2201,8 @@ __GLXdispatchRenderProcPtr __glXRenderTable_EXT[__GLX_MAX_RENDER_OPCODE_EXT - __
 	__glXNoSuchRenderOpcode,
 	__glXNoSuchRenderOpcode, /* 4219 */
 	__glXDisp_ActiveStencilFaceEXT, /* 4220 */
+	__glXDisp_PointParameteri,      /* 4221 */
+	__glXDisp_PointParameteriv,     /* 4222 */
 };
 __GLXdispatchVendorPrivProcPtr __glXVendorPrivTable_EXT[__GLX_MAX_VENDPRIV_OPCODE_EXT - __GLX_MIN_VENDPRIV_OPCODE_EXT + 1] = {
 	__glXDisp_AreTexturesResidentEXT, /* 11 */
@@ -4282,22 +4284,22 @@ __GLXdispatchRenderProcPtr __glXSwapRenderTable_EXT[__GLX_MAX_RENDER_OPCODE_EXT
 	__glXDispSwap_CopyTexSubImage1D,  /* 4121 */
 	__glXDispSwap_CopyTexSubImage2D,  /* 4122 */
 	__glXDispSwap_CopyTexSubImage3D,  /* 4123 */
-	__glXNoSuchRenderOpcode, /* 4124 */
+	__glXDispSwap_FogCoordfv,         /* 4124 */
-	__glXNoSuchRenderOpcode,
+	__glXDispSwap_FogCoorddv,         /* 4125 */
-	__glXNoSuchRenderOpcode,
+	__glXDispSwap_SecondaryColor3bv,  /* 4126 */
-	__glXNoSuchRenderOpcode,
+	__glXDispSwap_SecondaryColor3sv,  /* 4127 */
-	__glXNoSuchRenderOpcode,
+	__glXDispSwap_SecondaryColor3iv,  /* 4128 */
-	__glXNoSuchRenderOpcode,
+	__glXDispSwap_SecondaryColor3fv,  /* 4129 */
-	__glXNoSuchRenderOpcode, /* 4130 */
+	__glXDispSwap_SecondaryColor3dv,  /* 4130 */
-	__glXNoSuchRenderOpcode,
+	__glXDispSwap_SecondaryColor3ubv, /* 4131 */
-	__glXNoSuchRenderOpcode,
+	__glXDispSwap_SecondaryColor3usv, /* 4132 */
-	__glXNoSuchRenderOpcode,
+	__glXDispSwap_SecondaryColor3uiv, /* 4133 */
-	__glXNoSuchRenderOpcode,
+	__glXDisp_BlendFuncSeparate,      /* 4134 */
-	__glXNoSuchRenderOpcode,
+	__glXNoSuchRenderOpcode,          /* 4135 */
-	__glXNoSuchRenderOpcode,
+	__glXNoSuchRenderOpcode,          /* 4136 */
-	__glXNoSuchRenderOpcode,
+	__glXNoSuchRenderOpcode,          /* 4137 */
-	__glXNoSuchRenderOpcode,
+	__glXNoSuchRenderOpcode,          /* 4138 */
-	__glXNoSuchRenderOpcode,
+	__glXNoSuchRenderOpcode,          /* 4139 */
 	__glXNoSuchRenderOpcode, /* 4140 */
 	__glXNoSuchRenderOpcode,
 	__glXNoSuchRenderOpcode,
@@ -4379,6 +4381,8 @@ __GLXdispatchRenderProcPtr __glXSwapRenderTable_EXT[__GLX_MAX_RENDER_OPCODE_EXT
 	__glXNoSuchRenderOpcode,
 	__glXNoSuchRenderOpcode, /* 4219 */
 	__glXDispSwap_ActiveStencilFaceEXT, /* 4220 */
+	__glXDispSwap_PointParameteri,      /* 4221 */
+	__glXDispSwap_PointParameteriv,     /* 4222 */
 };
 __GLXdispatchVendorPrivProcPtr __glXSwapVendorPrivTable_EXT[__GLX_MAX_VENDPRIV_OPCODE_EXT - __GLX_MIN_VENDPRIV_OPCODE_EXT + 1] = {
 	__glXDispSwap_AreTexturesResidentEXT, /* 11 */

GL/glx/g_disptab_EXT.h

@@ -69,6 +69,37 @@ extern void __glXDisp_CopyTexSubImage2D(GLbyte*);
 extern void __glXDisp_CopyTexSubImage3D(GLbyte*);
 extern void __glXDisp_PointParameterfARB(GLbyte*);
 extern void __glXDisp_PointParameterfvARB(GLbyte*);
+
+extern void __glXDisp_FogCoordfv(GLbyte *);
+extern void __glXDisp_FogCoorddv(GLbyte *);
+extern void __glXDispSwap_FogCoordfv(GLbyte *);
+extern void __glXDispSwap_FogCoorddv(GLbyte *);
+
+extern void __glXDisp_SecondaryColor3bv(GLbyte *);
+extern void __glXDisp_SecondaryColor3sv(GLbyte *);
+extern void __glXDisp_SecondaryColor3iv(GLbyte *);
+extern void __glXDisp_SecondaryColor3ubv(GLbyte *);
+extern void __glXDisp_SecondaryColor3usv(GLbyte *);
+extern void __glXDisp_SecondaryColor3uiv(GLbyte *);
+extern void __glXDisp_SecondaryColor3fv(GLbyte *);
+extern void __glXDisp_SecondaryColor3dv(GLbyte *);
+extern void __glXDispSwap_SecondaryColor3bv(GLbyte *);
+extern void __glXDispSwap_SecondaryColor3sv(GLbyte *);
+extern void __glXDispSwap_SecondaryColor3iv(GLbyte *);
+extern void __glXDispSwap_SecondaryColor3ubv(GLbyte *);
+extern void __glXDispSwap_SecondaryColor3usv(GLbyte *);
+extern void __glXDispSwap_SecondaryColor3uiv(GLbyte *);
+extern void __glXDispSwap_SecondaryColor3fv(GLbyte *);
+extern void __glXDispSwap_SecondaryColor3dv(GLbyte *);
+
+extern void __glXDisp_BlendFuncSeparate(GLbyte *);
+extern void __glXDispSwap_BlendFuncSeparate(GLbyte *);
+
+extern void __glXDisp_PointParameteri(GLbyte *);
+extern void __glXDisp_PointParameteriv(GLbyte *);
+extern void __glXDispSwap_PointParameteri(GLbyte *);
+extern void __glXDispSwap_PointParameteriv(GLbyte *);
+
 extern void __glXDisp_ActiveStencilFaceEXT(GLbyte*);
 
 extern int __glXDispSwap_AreTexturesResidentEXT(__GLXclientState*, GLbyte*);
@@ -112,7 +143,7 @@ extern void __glXDispSwap_PointParameterfvARB(GLbyte*);
 extern void __glXDispSwap_ActiveStencilFaceEXT(GLbyte*);
 
 #define __GLX_MIN_RENDER_OPCODE_EXT 2053
-#define __GLX_MAX_RENDER_OPCODE_EXT 4220
+#define __GLX_MAX_RENDER_OPCODE_EXT 4222
 #define __GLX_MIN_VENDPRIV_OPCODE_EXT 11
 #define __GLX_MAX_VENDPRIV_OPCODE_EXT 14
 #define __GLX_VENDPRIV_TABLE_SIZE_EXT (__GLX_MAX_VENDPRIV_OPCODE_EXT - __GLX_MIN_VENDPRIV_OPCODE_EXT + 1)

GL/glx/g_render.c

@@ -59,6 +59,155 @@ void __glXDisp_Begin(GLbyte *pc)
 	);
 }
 
+#define __GLX_SWAP_GLbyte(ptr)
+#define __GLX_SWAP_GLshort(ptr)  __GLX_SWAP_SHORT(ptr)
+#define __GLX_SWAP_GLint(ptr)    __GLX_SWAP_INT(ptr)
+#define __GLX_SWAP_GLubyte(ptr)
+#define __GLX_SWAP_GLushort(ptr) __GLX_SWAP_SHORT(ptr)
+#define __GLX_SWAP_GLuint(ptr)   __GLX_SWAP_INT(ptr)
+#define __GLX_SWAP_GLdouble(ptr) __GLX_SWAP_DOUBLE(ptr)
+#define __GLX_SWAP_GLfloat(ptr)  __GLX_SWAP_FLOAT(ptr)
+
+#define __GLX_SWAP_GLbyte_ARRAY(ptr,count)   (void) swapEnd; (void) swapPC; (void) sw;
+#define __GLX_SWAP_GLshort_ARRAY(ptr,count)  __GLX_SWAP_SHORT_ARRAY(ptr,count)
+#define __GLX_SWAP_GLint_ARRAY(ptr,count)    __GLX_SWAP_INT_ARRAY(ptr,count)
+#define __GLX_SWAP_GLenum_ARRAY(ptr,count)   __GLX_SWAP_INT_ARRAY(ptr,count)
+#define __GLX_SWAP_GLubyte_ARRAY(ptr,count)  (void) swapEnd; (void) swapPC; (void) sw;
+#define __GLX_SWAP_GLushort_ARRAY(ptr,count) __GLX_SWAP_SHORT_ARRAY(ptr,count)
+#define __GLX_SWAP_GLuint_ARRAY(ptr,count)   __GLX_SWAP_INT_ARRAY(ptr,count)
+#define __GLX_SWAP_GLdouble_ARRAY(ptr,count) __GLX_SWAP_DOUBLE_ARRAY(ptr,count)
+#define __GLX_SWAP_GLfloat_ARRAY(ptr,count)  __GLX_SWAP_FLOAT_ARRAY(ptr,count)
+
+#ifdef __GLX_ALIGN64
+/* If type is not GLdouble, the compiler should optimize this away.
+ */
+# define GLX_DO_ALIGN_MAGIC(count, type) \
+	do { \
+	    if ( (sizeof(type) == 8) && ((unsigned long)(pc) & 7)) \
+	    { \
+	       	__GLX_MEM_COPY(pc-4, pc, (count * sizeof( type ) )); \
+	    	pc -= 4; \
+	    } \
+	} while( 0 )
+#else
+# define GLX_DO_ALIGN_MAGIC(count, type)
+#endif
+
+#define dispatch_template_1( name, type ) \
+    void __glXDisp_ ## name ( GLbyte * pc ) \
+    { \
+	GLX_DO_ALIGN_MAGIC( 1, type ); \
+	gl ## name ( (type *) pc ); \
+    } \
+    void __glXDispSwap_ ## name ( GLbyte * pc ) \
+    { \
+	__GLX_DECLARE_SWAP_VARIABLES; \
+	GLX_DO_ALIGN_MAGIC( 1, type ); \
+	__GLX_SWAP_ ## type ( pc ); \
+	gl ## name ( (type *) pc ); \
+    }
+
+#define dispatch_template_3( name, type ) \
+    void __glXDisp_ ## name ( GLbyte * pc ) \
+    { \
+	GLX_DO_ALIGN_MAGIC( 3, type ); \
+	gl ## name ( (type *) pc ); \
+    } \
+    void __glXDispSwap_ ## name ( GLbyte * pc ) \
+    { \
+	__GLX_DECLARE_SWAP_VARIABLES; \
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES; \
+	GLX_DO_ALIGN_MAGIC( 3, type ); \
+	__GLX_SWAP_ ## type ## _ARRAY(pc, 3); \
+	gl ## name ( (type *) pc ); \
+    }
+
+#define dispatch_template_4( name, type ) \
+    void __glXDisp_ ## name ( GLbyte * pc ) \
+    { \
+	GLX_DO_ALIGN_MAGIC( 4, type ); \
+	gl ## name ( (type *) pc ); \
+    } \
+    void __glXDispSwap_ ## name ( GLbyte * pc ) \
+    { \
+	__GLX_DECLARE_SWAP_VARIABLES; \
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES; \
+	GLX_DO_ALIGN_MAGIC( 4, type ); \
+	__GLX_SWAP_ ## type ## _ARRAY(pc, 4); \
+	gl ## name ( (type *) pc ); \
+    }
+
+#define dispatch_template_4s( name, type ) \
+    void __glXDisp_ ## name ( GLbyte * pc ) \
+    { \
+	GLX_DO_ALIGN_MAGIC( 4, type ); \
+	gl ## name ( ((type *) pc)[0], ((type *) pc)[1], \
+		     ((type *) pc)[2], ((type *) pc)[3] ); \
+    } \
+    void __glXDispSwap_ ## name ( GLbyte * pc ) \
+    { \
+	__GLX_DECLARE_SWAP_VARIABLES; \
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES; \
+	GLX_DO_ALIGN_MAGIC( 4, type ); \
+	__GLX_SWAP_ ## type ## _ARRAY(pc, 4); \
+	gl ## name ( ((type *) pc)[0], ((type *) pc)[1], \
+		     ((type *) pc)[2], ((type *) pc)[3] ); \
+    }
+
+/**
+ * \bug All of the enum1 templates need to be updated to handle the case where
+ * \c type is \c GLdouble.  When the type is a double, the data comes before
+ * the enum.  This is also the reason the invocation of the
+ * \c GLX_DO_ALIGN_MAGIC macro was removed.
+ */
+#define dispatch_template_enum1_1s( name, type ) \
+    void __glXDisp_ ## name ( GLbyte * pc ) \
+    { \
+	gl ## name ( *(GLenum *) (pc + 0), \
+		     *(type *)   (pc + 4) ); \
+    } \
+    void __glXDispSwap_ ## name ( GLbyte * pc ) \
+    { \
+	__GLX_DECLARE_SWAP_VARIABLES; \
+	__GLX_SWAP_INT      (pc + 0); \
+	__GLX_SWAP_ ## type (pc + 4); \
+	gl ## name ( *(GLenum *) (pc + 0), \
+		     *(type *)   (pc + 4) ); \
+    }
+
+#define dispatch_template_enum1_Vv( name, type ) \
+    void __glXDisp_ ## name ( GLbyte * pc ) \
+    { \
+	gl ## name ( *(GLenum *) (pc + 0), \
+		      (type *)   (pc + 4) ); \
+    } \
+    void __glXDispSwap_ ## name ( GLbyte * pc ) \
+    { \
+	GLenum pname; GLint compsize; \
+	__GLX_DECLARE_SWAP_VARIABLES; \
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES; \
+	__GLX_SWAP_INT(pc + 0); \
+	pname = *(GLenum *)(pc + 0); \
+	compsize = __gl ## name ## _size(pname); \
+	if (compsize < 0) compsize = 0; \
+	__GLX_SWAP_ ## type ## _ARRAY(pc + 4, compsize); \
+	gl ## name ( *(GLenum *) (pc + 0), \
+		      (type *)   (pc + 4) ); \
+    }
+
+dispatch_template_1( FogCoordfv,         GLfloat )
+dispatch_template_1( FogCoorddv,         GLdouble )
+dispatch_template_3( SecondaryColor3bv,  GLbyte )
+dispatch_template_3( SecondaryColor3sv,  GLshort )
+dispatch_template_3( SecondaryColor3iv,  GLint )
+dispatch_template_3( SecondaryColor3ubv, GLubyte )
+dispatch_template_3( SecondaryColor3usv, GLushort )
+dispatch_template_3( SecondaryColor3uiv, GLuint )
+dispatch_template_3( SecondaryColor3fv,  GLfloat )
+dispatch_template_3( SecondaryColor3dv,  GLdouble )
+
+dispatch_template_4s( BlendFuncSeparate,  GLenum )
+
 void __glXDisp_Color3bv(GLbyte *pc)
 {
 	glColor3bv( 
@@ -2097,6 +2246,9 @@ void __glXDisp_PointParameterfvARB(GLbyte *pc)
 	);
 }
 
+dispatch_template_enum1_1s(PointParameteri,  GLint)
+dispatch_template_enum1_Vv(PointParameteriv, GLint)
+
 void __glXDisp_ActiveStencilFaceEXT(GLbyte *pc)
 {
 	glActiveStencilFaceEXT(
@@ -2112,3 +2264,11 @@ void __glXDisp_WindowPos3fARB(GLbyte *pc)
 		*(GLfloat *)(pc + 8)
 	);
 }
+
+void __glXDisp_SampleCoverageARB(GLbyte *pc)
+{
+	glSampleCoverageARB(
+		*(GLfloat *)(pc + 0),
+		*(GLboolean *)(pc + 4)
+	);
+}

GL/glx/g_renderswap.c

@@ -3364,3 +3364,15 @@ void __glXDispSwap_WindowPos3fARB(GLbyte *pc)
 		*(GLfloat *)(pc + 8)
 	);
 }
+
+void __glXDispSwap_SampleCoverageARB(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_SWAP_FLOAT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+
+	glSampleCoverageARB(
+		*(GLfloat *)(pc + 0),
+		*(GLboolean *)(pc + 4)
+	);
+}

GL/glx/glxcmds.c

@@ -47,6 +47,7 @@
 #include "glxutil.h"
 #include "glxext.h"
 #include "GL/glx_ansic.h"
+#include "glcontextmodes.h"
 
 /************************************************************************/
 
@@ -68,29 +69,32 @@ static __GLimports imports = {
     NULL
 };
 
-static int DoMakeCurrent( __GLXclientState *cl, GLXDrawable drawId,
+static int __glXGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc);
- GLXDrawable readId, GLXContextID contextId, GLXContextTag tag );
+static int __glXCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc);
+static int __glXCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc);
+static int __glXMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc);
 
 /************************************************************************/
 
-/*
+/**
-** Create a GL context with the given properties.
+ * Create a GL context with the given properties.  This routine is used
-*/
+ * to implement \c glXCreateContext, \c glXCreateNewContext, and
-int __glXCreateContext(__GLXclientState *cl, GLbyte *pc)
+ * \c glXCreateContextWithConfigSGIX.  This works becuase of the hack way
+ * that GLXFBConfigs are implemented.  Basically, the FBConfigID is the
+ * same as the VisualID.
+ */
+
+int DoCreateContext(__GLXclientState *cl, GLXContextID gcId,
+		    GLXContextID shareList, VisualID visual,
+		    GLuint screen, GLboolean isDirect)
 {
     ClientPtr client = cl->client;
-    xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;
     VisualPtr pVisual;
     ScreenPtr pScreen;
     __GLXcontext *glxc, *shareglxc;
-    __GLXvisualConfig *pGlxVisual;
+    __GLcontextModes *modes;
     __GLXscreenInfo *pGlxScreen;
     __GLinterface *shareGC;
-    GLXContextID gcId = req->context;
-    GLXContextID shareList = req->shareList;
-    VisualID visual = req->visual;
-    GLuint screen = req->screen;
-    GLboolean isDirect = req->isDirect;
     GLint i;
     
     /*
@@ -123,13 +127,9 @@ int __glXCreateContext(__GLXclientState *cl, GLbyte *pc)
     ** subset of Visuals that are supported by this implementation of the
     ** OpenGL.
     */
-    pGlxVisual = pGlxScreen->pGlxVisual;
+
-    for (i = 0; i < pGlxScreen->numVisuals; i++, pGlxVisual++) {
+    modes = _gl_context_modes_find_visual( pGlxScreen->modes, visual );
-	if (pGlxVisual->vid == visual) {
+    if (modes == NULL) {
-	    break;
-	}
-    }
-    if (i == pGlxScreen->numVisuals) {
 	/*
 	** Visual not support on this screen by this OpenGL implementation.
 	*/
@@ -192,22 +192,15 @@ int __glXCreateContext(__GLXclientState *cl, GLbyte *pc)
     glxc->pScreen = pScreen;
     glxc->pGlxScreen = pGlxScreen;
     glxc->pVisual = pVisual;
-    glxc->pGlxVisual = pGlxVisual;
+    glxc->modes = modes;
 
     if (!isDirect) {
-	__GLcontextModes *modes;
-	/*
-	** first build __GLcontextModes from __GLXvisualConfig
-	*/
-	modes = (__GLcontextModes *) __glXMalloc(sizeof(__GLcontextModes));
-	glxc->modes = modes;
-	__glXFormatGLModes(modes, pGlxVisual);
 
 	/*
 	** Allocate a GL context
 	*/
 	imports.other = (void *)glxc;
-	glxc->gc = (*pGlxScreen->createContext)(&imports, modes, shareGC);
+	glxc->gc = (*pGlxScreen->createContext)(&imports, glxc->modes, shareGC);
 	if (!glxc->gc) {
 	    __glXFree(glxc);
 	    client->errorValue = gcId;
@@ -245,6 +238,31 @@ int __glXCreateContext(__GLXclientState *cl, GLbyte *pc)
     return Success;
 }
 
+
+int __glXCreateContext(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;
+    return DoCreateContext( cl, req->context, req->shareList, req->visual,
+			    req->screen, req->isDirect );
+}
+
+
+int __glXCreateNewContext(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreateNewContextReq *req = (xGLXCreateNewContextReq *) pc;
+    return DoCreateContext( cl, req->context, req->shareList, req->fbconfig,
+			    req->screen, req->isDirect );
+}
+
+
+int __glXCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreateContextWithConfigSGIXReq *req = 
+	(xGLXCreateContextWithConfigSGIXReq *) pc;
+    return DoCreateContext( cl, req->context, req->shareList, req->fbconfig,
+			    req->screen, req->isDirect );
+}
+
 /*
 ** Destroy a GL context as an X resource.
 */
@@ -449,7 +467,7 @@ static int GetDrawableOrPixmap( __GLXcontext *glxc, GLXDrawable drawId,
 	    ** Check if pixmap and context are similar.
 	    */
 	    if (drawPixmap->pScreen != glxc->pScreen ||
-		drawPixmap->pGlxVisual != glxc->pGlxVisual) {
+		drawPixmap->modes->visualID != glxc->modes->visualID) {
 		client->errorValue = drawId;
 		return BadMatch;
 	    }
@@ -471,7 +489,7 @@ static int GetDrawableOrPixmap( __GLXcontext *glxc, GLXDrawable drawId,
 }
 
 
-static int DoMakeCurrent( __GLXclientState *cl,
+int DoMakeCurrent( __GLXclientState *cl,
 		   GLXDrawable drawId, GLXDrawable readId,
 		   GLXContextID contextId, GLXContextTag tag )
 {
@@ -879,18 +897,19 @@ int __glXCopyContext(__GLXclientState *cl, GLbyte *pc)
     return Success;
 }
 
-int __glXGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
+
+int DoGetVisualConfigs(__GLXclientState *cl, unsigned screen,
+		       GLboolean do_swap)
 {
     ClientPtr client = cl->client;
-    xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;
     xGLXGetVisualConfigsReply reply;
     __GLXscreenInfo *pGlxScreen;
-    __GLXvisualConfig *pGlxVisual;
+    __GLcontextModes *modes;
     CARD32 buf[__GLX_TOTAL_CONFIG];
-    unsigned int screen;
+    int p;
-    int i, p;
+    __GLX_DECLARE_SWAP_VARIABLES;
+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 
-    screen = req->screen;
     if (screen >= screenInfo.numScreens) {
 	/* The client library must send a valid screen number. */
 	client->errorValue = screen;
@@ -905,77 +924,206 @@ int __glXGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
     reply.type = X_Reply;
     reply.sequenceNumber = client->sequence;
 
+    if ( do_swap ) {
+	__GLX_SWAP_SHORT(&reply.sequenceNumber);
+	__GLX_SWAP_INT(&reply.length);
+	__GLX_SWAP_INT(&reply.numVisuals);
+	__GLX_SWAP_INT(&reply.numProps);
+    }
+
     WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char *)&reply);
 
-    for (i=0; i < pGlxScreen->numVisuals; i++) {
+    for ( modes = pGlxScreen->modes ; modes != NULL ; modes = modes->next ) {
-	pGlxVisual = &pGlxScreen->pGlxVisual[i];
+	if (modes->visualID == 0) {
-	if (pGlxVisual->vid == 0) {
 	    /* not a usable visual */
 	    continue;
 	}
 	p = 0;
-	buf[p++] = pGlxVisual->vid;
+	buf[p++] = modes->visualID;
-	buf[p++] = pGlxVisual->class;
+	buf[p++] = _gl_convert_to_x_visual_type( modes->visualType );
-	buf[p++] = pGlxVisual->rgba;
+	buf[p++] = modes->rgbMode;
 
-	buf[p++] = pGlxVisual->redSize;
+	buf[p++] = modes->redBits;
-	buf[p++] = pGlxVisual->greenSize;
+	buf[p++] = modes->greenBits;
-	buf[p++] = pGlxVisual->blueSize;
+	buf[p++] = modes->blueBits;
-	buf[p++] = pGlxVisual->alphaSize;
+	buf[p++] = modes->alphaBits;
-	buf[p++] = pGlxVisual->accumRedSize;
+	buf[p++] = modes->accumRedBits;
-	buf[p++] = pGlxVisual->accumGreenSize;
+	buf[p++] = modes->accumGreenBits;
-	buf[p++] = pGlxVisual->accumBlueSize;
+	buf[p++] = modes->accumBlueBits;
-	buf[p++] = pGlxVisual->accumAlphaSize;
+	buf[p++] = modes->accumAlphaBits;
 
-	buf[p++] = pGlxVisual->doubleBuffer;
+	buf[p++] = modes->doubleBufferMode;
-	buf[p++] = pGlxVisual->stereo;
+	buf[p++] = modes->stereoMode;
 
-	buf[p++] = pGlxVisual->bufferSize;
+	buf[p++] = modes->rgbBits;
-	buf[p++] = pGlxVisual->depthSize;
+	buf[p++] = modes->depthBits;
-	buf[p++] = pGlxVisual->stencilSize;
+	buf[p++] = modes->stencilBits;
-	buf[p++] = pGlxVisual->auxBuffers;
+	buf[p++] = modes->numAuxBuffers;
-	buf[p++] = pGlxVisual->level;
+	buf[p++] = modes->level;
 	/* 
 	** Add token/value pairs for extensions.
 	*/
 	buf[p++] = GLX_VISUAL_CAVEAT_EXT;
-	buf[p++] = pGlxVisual->visualRating;
+	buf[p++] = modes->visualRating;
-	buf[p++] = GLX_TRANSPARENT_TYPE_EXT;
+	buf[p++] = GLX_TRANSPARENT_TYPE;
-	buf[p++] = pGlxVisual->transparentPixel;
+	buf[p++] = modes->transparentPixel;
-	buf[p++] = GLX_TRANSPARENT_RED_VALUE_EXT;
+	buf[p++] = GLX_TRANSPARENT_RED_VALUE;
-	buf[p++] = pGlxVisual->transparentRed;
+	buf[p++] = modes->transparentRed;
-	buf[p++] = GLX_TRANSPARENT_GREEN_VALUE_EXT;
+	buf[p++] = GLX_TRANSPARENT_GREEN_VALUE;
-	buf[p++] = pGlxVisual->transparentGreen;
+	buf[p++] = modes->transparentGreen;
-	buf[p++] = GLX_TRANSPARENT_BLUE_VALUE_EXT;
+	buf[p++] = GLX_TRANSPARENT_BLUE_VALUE;
-	buf[p++] = pGlxVisual->transparentBlue;
+	buf[p++] = modes->transparentBlue;
-	buf[p++] = GLX_TRANSPARENT_ALPHA_VALUE_EXT;
+	buf[p++] = GLX_TRANSPARENT_ALPHA_VALUE;
-	buf[p++] = pGlxVisual->transparentAlpha;
+	buf[p++] = modes->transparentAlpha;
-	buf[p++] = GLX_TRANSPARENT_INDEX_VALUE_EXT;
+	buf[p++] = GLX_TRANSPARENT_INDEX_VALUE;
-	buf[p++] = pGlxVisual->transparentIndex;
+	buf[p++] = modes->transparentIndex;
 
+	if ( do_swap ) {
+	    __GLX_SWAP_INT_ARRAY(buf, __GLX_TOTAL_CONFIG);
+	}
 	WriteToClient(client, __GLX_SIZE_CARD32 * __GLX_TOTAL_CONFIG, 
 		(char *)buf);
     }
     return Success;
 }
 
+int __glXGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;
+    return DoGetVisualConfigs( cl, req->screen, GL_FALSE );
+}
+
+
+
+#define __GLX_TOTAL_FBCONFIG_ATTRIBS (28)
+
+/**
+ * Send the set of GLXFBConfigs to the client.  There is not currently
+ * and interface into the driver on the server-side to get GLXFBConfigs,
+ * so we "invent" some based on the \c __GLXvisualConfig structures that
+ * the driver does supply.
+ * 
+ * The reply format for both \c glXGetFBConfigs and \c glXGetFBConfigsSGIX
+ * is the same, so this routine pulls double duty.
+ */
+
+int DoGetFBConfigs(__GLXclientState *cl, unsigned screen, GLboolean do_swap)
+{
+    ClientPtr client = cl->client;
+    xGLXGetFBConfigsReply reply;
+    __GLXscreenInfo *pGlxScreen;
+    CARD32 buf[__GLX_TOTAL_FBCONFIG_ATTRIBS * 2];
+    int p;
+    __GLcontextModes *modes;
+    __GLX_DECLARE_SWAP_VARIABLES;
+    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+
+    if (screen >= screenInfo.numScreens) {
+	/* The client library must send a valid screen number. */
+	client->errorValue = screen;
+	return BadValue;
+    }
+    pGlxScreen = &__glXActiveScreens[screen];
+
+    reply.numFBConfigs = pGlxScreen->numUsableVisuals;
+    reply.numAttribs = __GLX_TOTAL_FBCONFIG_ATTRIBS;
+    reply.length = (reply.numAttribs * reply.numFBConfigs);
+    reply.type = X_Reply;
+    reply.sequenceNumber = client->sequence;
+
+    if ( do_swap ) {
+	__GLX_SWAP_SHORT(&reply.sequenceNumber);
+	__GLX_SWAP_INT(&reply.length);
+	__GLX_SWAP_INT(&reply.numFBConfigs);
+	__GLX_SWAP_INT(&reply.numAttribs);
+    }
+
+    WriteToClient(client, sz_xGLXGetFBConfigsReply, (char *)&reply);
+
+    for ( modes = pGlxScreen->modes ; modes != NULL ; modes = modes->next ) {
+	if (modes->visualID == 0) {
+	    /* not a usable visual */
+	    continue;
+	}
+	p = 0;
+
+#define WRITE_PAIR(tag,value) \
+    do { buf[p++] = tag ; buf[p++] = value ; } while( 0 )
+
+	WRITE_PAIR( GLX_VISUAL_ID,        modes->visualID );
+	WRITE_PAIR( GLX_FBCONFIG_ID,      modes->visualID );
+	WRITE_PAIR( GLX_X_RENDERABLE,     GL_TRUE );
+
+	WRITE_PAIR( GLX_RGBA,             modes->rgbMode );
+	WRITE_PAIR( GLX_DOUBLEBUFFER,     modes->doubleBufferMode );
+	WRITE_PAIR( GLX_STEREO,           modes->stereoMode );
+
+	WRITE_PAIR( GLX_BUFFER_SIZE,      modes->rgbBits );
+	WRITE_PAIR( GLX_LEVEL,            modes->level );
+	WRITE_PAIR( GLX_AUX_BUFFERS,      modes->numAuxBuffers );
+	WRITE_PAIR( GLX_RED_SIZE,         modes->redBits );
+	WRITE_PAIR( GLX_GREEN_SIZE,       modes->greenBits );
+	WRITE_PAIR( GLX_BLUE_SIZE,        modes->blueBits );
+	WRITE_PAIR( GLX_ALPHA_SIZE,       modes->alphaBits );
+	WRITE_PAIR( GLX_ACCUM_RED_SIZE,   modes->accumRedBits );
+	WRITE_PAIR( GLX_ACCUM_GREEN_SIZE, modes->accumGreenBits );
+	WRITE_PAIR( GLX_ACCUM_BLUE_SIZE,  modes->accumBlueBits );
+	WRITE_PAIR( GLX_ACCUM_ALPHA_SIZE, modes->accumAlphaBits );
+	WRITE_PAIR( GLX_DEPTH_SIZE,       modes->depthBits );
+	WRITE_PAIR( GLX_STENCIL_SIZE,     modes->stencilBits );
+
+	WRITE_PAIR( GLX_X_VISUAL_TYPE,    modes->visualType );
+
+	/* 
+	** Add token/value pairs for extensions.
+	*/
+	WRITE_PAIR( GLX_CONFIG_CAVEAT, modes->visualRating );
+	WRITE_PAIR( GLX_TRANSPARENT_TYPE, modes->transparentPixel );
+	WRITE_PAIR( GLX_TRANSPARENT_RED_VALUE, modes->transparentRed );
+	WRITE_PAIR( GLX_TRANSPARENT_GREEN_VALUE, modes->transparentGreen );
+	WRITE_PAIR( GLX_TRANSPARENT_BLUE_VALUE, modes->transparentBlue );
+	WRITE_PAIR( GLX_TRANSPARENT_ALPHA_VALUE, modes->transparentAlpha );
+	WRITE_PAIR( GLX_TRANSPARENT_INDEX_VALUE, modes->transparentIndex );
+	WRITE_PAIR( GLX_SWAP_METHOD_OML, modes->swapMethod );
+
+	if ( do_swap ) {
+	    __GLX_SWAP_INT_ARRAY(buf, __GLX_TOTAL_FBCONFIG_ATTRIBS * 2);
+	}
+	WriteToClient(client, __GLX_SIZE_CARD32 * __GLX_TOTAL_FBCONFIG_ATTRIBS * 2,
+		      (char *)buf);
+    }
+    return Success;
+}
+
+
+int __glXGetFBConfigs(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXGetFBConfigsReq *req = (xGLXGetFBConfigsReq *) pc;
+    return DoGetFBConfigs( cl, req->screen, GL_FALSE );
+}
+
+
+int __glXGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *) pc;
+    return DoGetFBConfigs( cl, req->screen, GL_FALSE );
+}
+
+
 /*
 ** Create a GLX Pixmap from an X Pixmap.
 */
-int __glXCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
+int DoCreateGLXPixmap(__GLXclientState *cl, VisualID visual,
+		      GLuint screenNum, XID pixmapId, XID glxpixmapId)
 {
     ClientPtr client = cl->client;
-    xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc;
-    VisualID visual = req->visual;
-    GLuint screenNum = req->screen;
-    XID pixmapId = req->pixmap;
-    XID glxpixmapId = req->glxpixmap;
     DrawablePtr pDraw;
     ScreenPtr pScreen;
     VisualPtr pVisual;
     __GLXpixmap *pGlxPixmap;
     __GLXscreenInfo *pGlxScreen;
-    __GLXvisualConfig *pGlxVisual;
+    __GLcontextModes *modes;
     int i;
 
     pDraw = (DrawablePtr) LookupDrawable(pixmapId, client);
@@ -1016,13 +1164,8 @@ int __glXCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
     ** Get configuration of the visual.
     */
     pGlxScreen = &__glXActiveScreens[screenNum];
-    pGlxVisual = pGlxScreen->pGlxVisual;
+    modes = _gl_context_modes_find_visual( pGlxScreen->modes, visual );
-    for (i = 0; i < pGlxScreen->numVisuals; i++, pGlxVisual++) {
+    if (modes == NULL) {
-	if (pGlxVisual->vid == visual) {
-	    break;
-	}
-    }
-    if (i == pGlxScreen->numVisuals) {
 	/*
 	** Visual not support on this screen by this OpenGL implementation.
 	*/
@@ -1039,11 +1182,12 @@ int __glXCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
     }
     pGlxPixmap->pDraw = pDraw;
     pGlxPixmap->pGlxScreen = pGlxScreen;
-    pGlxPixmap->pGlxVisual = pGlxVisual;
     pGlxPixmap->pScreen = pScreen;
     pGlxPixmap->idExists = True;
     pGlxPixmap->refcnt = 0;
 
+    pGlxPixmap->modes = modes;
+
     /*
     ** Bump the ref count on the X pixmap so it won't disappear.
     */
@@ -1052,6 +1196,34 @@ int __glXCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
     return Success;
 }
 
+int __glXCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc;
+    return DoCreateGLXPixmap( cl, req->visual, req->screen,
+			      req->pixmap, req->glxpixmap );
+}
+
+int __glXCreatePixmap(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
+    return DoCreateGLXPixmap( cl, req->fbconfig, req->screen,
+			      req->pixmap, req->glxpixmap );
+}
+
+int __glXCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreateGLXPixmapWithConfigSGIXReq *req = 
+	(xGLXCreateGLXPixmapWithConfigSGIXReq *) pc;
+    return DoCreateGLXPixmap( cl, req->fbconfig, req->screen,
+			      req->pixmap, req->glxpixmap );
+}
+
+
+/**
+ * Destroy a GLX pixmap.  This function is used for both
+ * \c glXDestroyGLXPixmap and \c glXDestroyPixmap.
+ */
+
 int __glXDestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
 {
     ClientPtr client = cl->client;
@@ -1552,6 +1724,17 @@ int __glXVendorPrivate(__GLXclientState *cl, GLbyte *pc)
     req = (xGLXVendorPrivateReq *) pc;
     vendorcode = req->vendorCode;
 
+    switch( vendorcode ) {
+    case X_GLvop_SampleMaskSGIS:
+	glSampleMaskSGIS(*(GLfloat *)(pc + 4),
+			 *(GLboolean *)(pc + 8));
+	return Success;
+    case X_GLvop_SamplePatternSGIS:
+	glSamplePatternSGIS( *(GLenum *)(pc + 4));
+	return Success;
+    }
+
+
     if ((vendorcode >= __GLX_MIN_VENDPRIV_OPCODE_EXT) &&
           (vendorcode <= __GLX_MAX_VENDPRIV_OPCODE_EXT))  {
 	(*__glXVendorPrivTable_EXT[vendorcode-__GLX_MIN_VENDPRIV_OPCODE_EXT])
@@ -1578,6 +1761,12 @@ int __glXVendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
 	return __glXQueryContextInfoEXT(cl, pc);
       case X_GLXvop_MakeCurrentReadSGI:
 	return __glXMakeCurrentReadSGI(cl, pc);
+      case X_GLXvop_GetFBConfigsSGIX:
+	return __glXGetFBConfigsSGIX(cl, pc);
+      case X_GLXvop_CreateContextWithConfigSGIX:
+	return __glXCreateContextWithConfigSGIX(cl, pc);
+      case X_GLXvop_CreateGLXPixmapWithConfigSGIX:
+	return __glXCreateGLXPixmapWithConfigSGIX(cl, pc);
       default:
 	break;
     }

GL/glx/glxcmdsswap.c

@@ -47,6 +47,11 @@
 #include "glxext.h"
 #include "GL/glx_ansic.h"
 
+static int __glXSwapGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc);
+static int __glXSwapCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc);
+static int __glXSwapCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc);
+static int __glXSwapMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc);
+
 /************************************************************************/
 
 /*
@@ -67,7 +72,41 @@ int __glXSwapCreateContext(__GLXclientState *cl, GLbyte *pc)
     __GLX_SWAP_INT(&req->screen);
     __GLX_SWAP_INT(&req->shareList);
 
-    return __glXCreateContext(cl, pc);
+    return DoCreateContext( cl, req->context, req->shareList, req->visual,
+			    req->screen, req->isDirect );
+}
+
+int __glXSwapCreateNewContext(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreateNewContextReq *req = (xGLXCreateNewContextReq *) pc;
+    __GLX_DECLARE_SWAP_VARIABLES;
+
+    __GLX_SWAP_SHORT(&req->length);
+    __GLX_SWAP_INT(&req->context);
+    __GLX_SWAP_INT(&req->fbconfig);
+    __GLX_SWAP_INT(&req->screen);
+    __GLX_SWAP_INT(&req->renderType);
+    __GLX_SWAP_INT(&req->shareList);
+
+    return DoCreateContext( cl, req->context, req->shareList, req->fbconfig,
+			    req->screen, req->isDirect );
+}
+
+int __glXSwapCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreateContextWithConfigSGIXReq *req =
+	(xGLXCreateContextWithConfigSGIXReq *) pc;
+    __GLX_DECLARE_SWAP_VARIABLES;
+
+    __GLX_SWAP_SHORT(&req->length);
+    __GLX_SWAP_INT(&req->context);
+    __GLX_SWAP_INT(&req->fbconfig);
+    __GLX_SWAP_INT(&req->screen);
+    __GLX_SWAP_INT(&req->renderType);
+    __GLX_SWAP_INT(&req->shareList);
+
+    return DoCreateContext( cl, req->context, req->shareList, req->fbconfig,
+			    req->screen, req->isDirect );
 }
 
 int __glXSwapDestroyContext(__GLXclientState *cl, GLbyte *pc)
@@ -91,7 +130,8 @@ int __glXSwapMakeCurrent(__GLXclientState *cl, GLbyte *pc)
     __GLX_SWAP_INT(&req->context);
     __GLX_SWAP_INT(&req->oldContextTag);
 
-    return __glXMakeCurrent(cl, pc);
+    return DoMakeCurrent( cl, req->drawable, req->drawable,
+			  req->context, req->oldContextTag );
 }
 
 int __glXSwapMakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
@@ -105,7 +145,8 @@ int __glXSwapMakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
     __GLX_SWAP_INT(&req->context);
     __GLX_SWAP_INT(&req->oldContextTag);
 
-    return __glXMakeContextCurrent(cl, pc);
+    return DoMakeCurrent( cl, req->drawable, req->readdrawable,
+			  req->context, req->oldContextTag );
 }
 
 int __glXSwapMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
@@ -119,7 +160,8 @@ int __glXSwapMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
     __GLX_SWAP_INT(&req->context);
     __GLX_SWAP_INT(&req->oldContextTag);
 
-    return __glXMakeCurrentReadSGI(cl, pc);
+    return DoMakeCurrent( cl, req->drawable, req->readable,
+			  req->context, req->oldContextTag );
 }
 
 int __glXSwapIsDirect(__GLXclientState *cl, GLbyte *pc)
@@ -182,90 +224,29 @@ int __glXSwapCopyContext(__GLXclientState *cl, GLbyte *pc)
 
 int __glXSwapGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
 {
-    ClientPtr client = cl->client;
     xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;
-    xGLXGetVisualConfigsReply reply;
-    __GLXscreenInfo *pGlxScreen;
-    __GLXvisualConfig *pGlxVisual;
-    CARD32 buf[__GLX_TOTAL_CONFIG];
-    unsigned int screen;
-    int i, p;
     __GLX_DECLARE_SWAP_VARIABLES;
-    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
 
     __GLX_SWAP_INT(&req->screen);
-    screen = req->screen;
+    return DoGetVisualConfigs( cl, req->screen, GL_TRUE );
-    if (screen > screenInfo.numScreens) {
+}
-	/* The client library must send a valid screen number. */
-	client->errorValue = screen;
-	return BadValue;
-    }
-    pGlxScreen = &__glXActiveScreens[screen];
 
-    reply.numVisuals = pGlxScreen->numUsableVisuals;
+int __glXSwapGetFBConfigs(__GLXclientState *cl, GLbyte *pc)
-    reply.numProps = __GLX_TOTAL_CONFIG;
+{
-    reply.length = (pGlxScreen->numUsableVisuals * __GLX_SIZE_CARD32 *
+    xGLXGetFBConfigsReq *req = (xGLXGetFBConfigsReq *) pc;
-		    __GLX_TOTAL_CONFIG) >> 2;
+    __GLX_DECLARE_SWAP_VARIABLES;
-    reply.type = X_Reply;
-    reply.sequenceNumber = client->sequence;
 
-    __GLX_SWAP_SHORT(&reply.sequenceNumber);
+    __GLX_SWAP_INT(&req->screen);
-    __GLX_SWAP_INT(&reply.length);
+    return DoGetFBConfigs( cl, req->screen, GL_TRUE );
-    __GLX_SWAP_INT(&reply.numVisuals);
+}
-    __GLX_SWAP_INT(&reply.numProps);
-    WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char *)&reply);
 
-    for (i=0; i < pGlxScreen->numVisuals; i++) {
+int __glXSwapGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
-	pGlxVisual = &pGlxScreen->pGlxVisual[i];
+{
-	if (pGlxVisual->vid == 0) {
+    xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *) pc;
-	    /* not a usable visual */
+    __GLX_DECLARE_SWAP_VARIABLES;
-	    continue;
-	}
-	p = 0;
-	buf[p++] = pGlxVisual->vid;
-	buf[p++] = pGlxVisual->class;
-	buf[p++] = pGlxVisual->rgba;
 
-	buf[p++] = pGlxVisual->redSize;
+    __GLX_SWAP_INT(&req->screen);
-	buf[p++] = pGlxVisual->greenSize;
+    return DoGetFBConfigs( cl, req->screen, GL_TRUE );
-	buf[p++] = pGlxVisual->blueSize;
-	buf[p++] = pGlxVisual->alphaSize;
-	buf[p++] = pGlxVisual->accumRedSize;
-	buf[p++] = pGlxVisual->accumGreenSize;
-	buf[p++] = pGlxVisual->accumBlueSize;
-	buf[p++] = pGlxVisual->accumAlphaSize;
-
-	buf[p++] = pGlxVisual->doubleBuffer;
-	buf[p++] = pGlxVisual->stereo;
-
-	buf[p++] = pGlxVisual->bufferSize;
-	buf[p++] = pGlxVisual->depthSize;
-	buf[p++] = pGlxVisual->stencilSize;
-	buf[p++] = pGlxVisual->auxBuffers;
-	buf[p++] = pGlxVisual->level;
-        /*
-        ** Add token/value pairs for extensions.
-        */
-        buf[p++] = GLX_VISUAL_CAVEAT_EXT;
-        buf[p++] = pGlxVisual->visualRating;
-        buf[p++] = GLX_TRANSPARENT_TYPE_EXT;
-        buf[p++] = pGlxVisual->transparentPixel;
-        buf[p++] = GLX_TRANSPARENT_RED_VALUE_EXT;
-        buf[p++] = pGlxVisual->transparentRed;
-        buf[p++] = GLX_TRANSPARENT_GREEN_VALUE_EXT;
-        buf[p++] = pGlxVisual->transparentGreen;
-        buf[p++] = GLX_TRANSPARENT_BLUE_VALUE_EXT;
-        buf[p++] = pGlxVisual->transparentBlue;
-        buf[p++] = GLX_TRANSPARENT_ALPHA_VALUE_EXT;
-        buf[p++] = pGlxVisual->transparentAlpha;
-        buf[p++] = GLX_TRANSPARENT_INDEX_VALUE_EXT;
-        buf[p++] = pGlxVisual->transparentIndex;
-
-	__GLX_SWAP_INT_ARRAY(buf, __GLX_TOTAL_CONFIG);
-	WriteToClient(client, __GLX_SIZE_CARD32 * __GLX_TOTAL_CONFIG, 
-			(char *)buf);
-    }
-    return Success;
 }
 
 int __glXSwapCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
@@ -279,7 +260,39 @@ int __glXSwapCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
     __GLX_SWAP_INT(&req->pixmap);
     __GLX_SWAP_INT(&req->glxpixmap);
 
-    return __glXCreateGLXPixmap(cl, pc);
+    return DoCreateGLXPixmap( cl, req->visual, req->screen,
+			      req->pixmap, req->glxpixmap );
+}
+
+int __glXSwapCreatePixmap(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
+    __GLX_DECLARE_SWAP_VARIABLES;
+
+    __GLX_SWAP_SHORT(&req->length);
+    __GLX_SWAP_INT(&req->screen);
+    __GLX_SWAP_INT(&req->fbconfig);
+    __GLX_SWAP_INT(&req->pixmap);
+    __GLX_SWAP_INT(&req->glxpixmap);
+
+    return DoCreateGLXPixmap( cl, req->fbconfig, req->screen,
+			      req->pixmap, req->glxpixmap );
+}
+
+int __glXSwapCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+    xGLXCreateGLXPixmapWithConfigSGIXReq *req = 
+	(xGLXCreateGLXPixmapWithConfigSGIXReq *) pc;
+    __GLX_DECLARE_SWAP_VARIABLES;
+
+    __GLX_SWAP_SHORT(&req->length);
+    __GLX_SWAP_INT(&req->screen);
+    __GLX_SWAP_INT(&req->fbconfig);
+    __GLX_SWAP_INT(&req->pixmap);
+    __GLX_SWAP_INT(&req->glxpixmap);
+
+    return DoCreateGLXPixmap( cl, req->fbconfig, req->screen,
+			      req->pixmap, req->glxpixmap );
 }
 
 int __glXSwapDestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
@@ -357,7 +370,7 @@ int __glXSwapClientInfo(__GLXclientState *cl, GLbyte *pc)
     return __glXClientInfo(cl, pc);
 }
 
-int __glXSwapQueryContextInfoEXT(__GLXclientState *cl, char *pc)
+int __glXSwapQueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc)
 {
     xGLXQueryContextInfoEXTReq *req = (xGLXQueryContextInfoEXTReq *) pc;
     __GLX_DECLARE_SWAP_VARIABLES;
@@ -791,6 +804,20 @@ int __glXSwapVendorPrivate(__GLXclientState *cl, GLbyte *pc)
 
     vendorcode = req->vendorCode;
 
+    switch( vendorcode ) {
+    case X_GLvop_SampleMaskSGIS:
+	__GLX_SWAP_FLOAT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+	glSampleMaskSGIS(*(GLfloat *)(pc + 4),
+			 *(GLboolean *)(pc + 8));
+	return Success;
+    case X_GLvop_SamplePatternSGIS:
+	__GLX_SWAP_INT(pc + 4);
+	glSamplePatternSGIS( *(GLenum *)(pc + 4));
+	return Success;
+    }
+
+
     if ((vendorcode >= __GLX_MIN_VENDPRIV_OPCODE_EXT) &&
           (vendorcode <= __GLX_MAX_VENDPRIV_OPCODE_EXT))  {
 	(*__glXSwapVendorPrivTable_EXT[vendorcode-__GLX_MIN_VENDPRIV_OPCODE_EXT])(cl, (GLbyte*)req);
@@ -818,6 +845,12 @@ int __glXSwapVendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
 	return __glXSwapQueryContextInfoEXT(cl, pc);
       case X_GLXvop_MakeCurrentReadSGI:
 	return __glXSwapMakeCurrentReadSGI(cl, pc);
+      case X_GLXvop_GetFBConfigsSGIX:
+	return __glXSwapGetFBConfigsSGIX(cl, pc);
+      case X_GLXvop_CreateContextWithConfigSGIX:
+	return __glXSwapCreateContextWithConfigSGIX(cl, pc);
+      case X_GLXvop_CreateGLXPixmapWithConfigSGIX:
+	return __glXSwapCreateGLXPixmapWithConfigSGIX(cl, pc);
       default:
 	break;
     }

GL/glx/glxcontext.h

@@ -80,7 +80,6 @@ struct __GLXcontextRec {
     ** This context is created with respect to this visual.
     */
     VisualRec *pVisual;
-    __GLXvisualConfig *pGlxVisual;
 
     /*
     ** The XID of this context.

GL/glx/glxdrawable.h

@@ -40,7 +40,7 @@
 typedef struct {
 
     DrawablePtr pDraw;
-    __GLXvisualConfig *pGlxVisual;
+    __GLcontextModes *modes;
     __GLXscreenInfo *pGlxScreen;
     ScreenPtr pScreen;
     Bool idExists;
@@ -69,11 +69,12 @@ struct __GLXdrawablePrivateRec {
     /*
     ** Configuration of the visual to which this drawable was created.
     */
-    __GLXvisualConfig *pGlxVisual;
+    __GLcontextModes *modes;
 
     /*
     ** cached drawable size and origin
     */
+
     GLint xorigin, yorigin;
     GLint width, height;
 

GL/glx/glxext.c

@@ -31,6 +31,9 @@
 
 
 extern __GLXextensionInfo __glDDXExtensionInfo;
+void GlxWrapInitVisuals(miInitVisualsProcPtr *);
+void GlxSetVisualConfigs(int nconfigs, 
+                         __GLXvisualConfig *configs, void **privates);
 
 __GLXextensionInfo *__glXExt = &__glDDXExtensionInfo;
 

GL/glx/glxext.h

@@ -71,15 +71,26 @@ extern GLboolean __glXErrorOccured(void);
 extern void __glXResetLargeCommandStatus(__GLXclientState*);
 
 extern int __glXQueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc);
-extern int __glXSwapQueryContextInfoEXT(__GLXclientState *cl, char *pc);
+extern int __glXSwapQueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc);
 
-extern int __glXMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc);
+extern int DoMakeCurrent( __GLXclientState *cl, GLXDrawable drawId,
-extern int __glXSwapMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc);
+    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, VisualID visual,
+    GLuint screenNum, XID pixmapId, XID glxpixmapId);
 
 extern void GlxExtensionInit(void);
 
 extern Bool __glXCoreType(void);
 
+extern const char GLServerVersion[];
+extern int DoGetString(__GLXclientState *cl, GLbyte *pc, GLboolean need_swap);
+
 extern int GlxInitVisuals(
 #if NeedFunctionPrototypes
     VisualPtr *       visualp,

GL/glx/glxscreens.c

@@ -1,4 +1,4 @@
-/* $XFree86: xc/programs/Xserver/GL/glx/glxscreens.c,v 1.10 2002/04/04 14:05:36 eich Exp $ */
+/* $XFree86: xc/programs/Xserver/GL/glx/glxscreens.c,v 1.11 2003/06/23 17:35:44 eich Exp $ */
 /*
 ** License Applicability. Except to the extent portions of this file are
 ** made subject to an alternative license as permitted in the SGI Free
@@ -46,11 +46,13 @@
 #include "glxserver.h"
 #include "glxutil.h"
 
+const char GLServerVersion[] = "1.2";
 static const char GLServerExtensions[] = 
 			"GL_ARB_depth_texture "
 			"GL_ARB_imaging "
 			"GL_ARB_multitexture "
 			"GL_ARB_point_parameters "
+			"GL_ARB_point_sprite "
 			"GL_ARB_shadow "
 			"GL_ARB_shadow_ambient "
 			"GL_ARB_texture_border_clamp "
@@ -108,6 +110,7 @@ static const char GLServerExtensions[] =
 			"GL_MESA_pack_invert "
 			"GL_MESA_ycbcr_texture "
 			"GL_NV_blend_square "
+			"GL_NV_point_sprite "
 			"GL_NV_texgen_reflection "
 			"GL_NV_texture_rectangle "
 			"GL_SGIS_generate_mipmap "
@@ -126,10 +129,14 @@ static const char GLServerExtensions[] =
 static char GLXServerVendorName[] = "SGI";
 static char GLXServerVersion[] = "1.2";
 static char GLXServerExtensions[] =
+			"GLX_ARB_multisample "
 			"GLX_EXT_visual_info "
 			"GLX_EXT_visual_rating "
 			"GLX_EXT_import_context "
+			"GLX_OML_swap_method "
 			"GLX_SGI_make_current_read "
+			"GLX_SGIS_multisample "
+			"GLX_SGIX_fbconfig "
 			;
 
 /*
@@ -149,81 +156,6 @@ GLint __glXNumActiveScreens;
 
 RESTYPE __glXDrawableRes;
 
-#if 0
-static int
-CountBits(unsigned long mask)
-{
-    int count = 0;
-
-    while(mask) {
-	count += (mask&1);
-	mask >>= 1;
-    }
-
-    return count;
-}
-#endif
-
-#if 0
-/*
-** A typical implementation would not probably not run through the screen's
-** visuals to find ones that match the visual configs supplied by the DDX
-** Sample OpenGL as we do here; we have done this to make this code easy to
-** drop into an existing X server.
-*/
-static int matchVisuals(__GLXvisualConfig *pGlxVisual, int numVisuals,
-			 int screen)
-{
-    int i, j;
-    __GLXvisualConfig *pvis = pGlxVisual;
-    ScreenPtr pScreen = screenInfo.screens[screen];
-    VisualPtr pVisual;
-    int numMatchingVisuals = 0; 
-    int *used;
-
-    used = (int *)__glXMalloc(pScreen->numVisuals*sizeof(int));
-    __glXMemset(used, 0, pScreen->numVisuals*sizeof(int));
-
-    for (i=0; i < numVisuals; i++, pvis++) {
-	/*
-	** Look through all the server's visuals to see which match.
-	*/
-	pvis->vid = 0;
-	pVisual = pScreen->visuals;
-	for (j=0; j < pScreen->numVisuals; j++, pVisual++) {
-	    if (pvis->class == pVisual->class &&
-		pvis->bufferSize == pVisual->nplanes &&
-		!used[j]) {
-		int rBits, gBits, bBits, aBits;
-
-		/* count bits per rgb */
-		rBits = CountBits(pVisual->redMask);
-		gBits = CountBits(pVisual->greenMask);
-		bBits = CountBits(pVisual->blueMask);
-		aBits = 0;
-		if ((pvis->redSize == rBits) &&
-		    (pvis->greenSize == gBits) &&
-		    (pvis->blueSize == bBits) &&
-		    (pvis->alphaSize == aBits)) {
-		    /*
-		    ** We'll consider this a match.
-		    */
-		    pvis->vid = pVisual->vid;
-		    pvis->redMask = pVisual->redMask;
-		    pvis->greenMask = pVisual->greenMask;
-		    pvis->blueMask = pVisual->blueMask;
-		    pvis->alphaMask = 0;
-		    numMatchingVisuals++;
-		    used[j] = 1;
-		    break;
-		}
-	    }
-	}
-    }
-    __glXFree(used);
-    return numMatchingVisuals;
-}
-#endif
 
 /*
 ** Destroy routine that gets called when a drawable is freed.  A drawable
@@ -353,14 +285,7 @@ void __glXScreenInit(GLint numscreens)
 	    if ((*__glXScreens[j]->screenProbe)(i)) {
 		__glXActiveScreens[i] = *__glXScreens[j];
 
-#if 0
-                /* we don't use this since matchVisuals doesn't allow alpha */
-		__glXActiveScreens[i].numUsableVisuals =
-		    matchVisuals(__glXActiveScreens[i].pGlxVisual,
-			         __glXActiveScreens[i].numVisuals, i); 
-#else
 		__glXActiveScreens[i].numUsableVisuals = __glXActiveScreens[i].numVisuals;
-#endif
 		__glXActiveScreens[i].GLextensions = __glXStrdup(GLServerExtensions);
 		__glXActiveScreens[i].GLXvendor = __glXStrdup(GLXServerVendorName);
 		__glXActiveScreens[i].GLXversion = __glXStrdup(GLXServerVersion);

GL/glx/glxscreens.h

@@ -70,7 +70,11 @@ typedef struct {
     */
     void (*createBuffer)(__GLXdrawablePrivate *glxPriv);
 
-    __GLXvisualConfig *pGlxVisual;
+    /**
+     * Linked list of valid context modes for this screen.
+     */
+    __GLcontextModes *modes;
+
     void **pVisualPriv;
     GLint numVisuals;
     GLint numUsableVisuals;

GL/glx/glxserver.h

@@ -280,5 +280,6 @@ extern int __glXColorTableParameterfvSize(GLenum pname);
 extern int __glXColorTableParameterivSize(GLenum pname);
 
 extern int __glXPointParameterfvARBReqSize(GLbyte *pc, Bool swap);
+extern int __glXPointParameterivReqSize(GLbyte *pc, Bool swap);
 
 #endif /* !__GLX_server_h__ */

GL/glx/glxutil.c

@@ -44,6 +44,9 @@
 #include "glxutil.h"
 #include "glxbuf.h"
 #include "GL/glx_ansic.h"
+#include "GL/internal/glcore.h"
+#include "GL/glxint.h"
+#include "glcontextmodes.h"
 
 /************************************************************************/
 
@@ -214,53 +217,6 @@ __glXResizeDrawable(__GLdrawablePrivate *glPriv)
 }
 
 
-/************************************************************************/
-
-void
-__glXFormatGLModes(__GLcontextModes *modes, __GLXvisualConfig *config)
-{
-    __glXMemset(modes, 0, sizeof(__GLcontextModes));
-
-    modes->rgbMode = (config->rgba != 0);
-    modes->colorIndexMode = !(modes->rgbMode);
-    modes->doubleBufferMode = (config->doubleBuffer != 0);
-    modes->stereoMode = (config->stereo != 0);
-
-    modes->haveAccumBuffer = ((config->accumRedSize +
-			       config->accumGreenSize +
-			       config->accumBlueSize +
-			       config->accumAlphaSize) > 0);
-    modes->haveDepthBuffer = (config->depthSize > 0);
-    modes->haveStencilBuffer = (config->stencilSize > 0);
-
-    modes->redBits = config->redSize;
-    modes->greenBits = config->greenSize;
-    modes->blueBits = config->blueSize;
-    modes->alphaBits = config->alphaSize;
-    modes->redMask = config->redMask;
-    modes->greenMask = config->greenMask;
-    modes->blueMask = config->blueMask;
-    modes->alphaMask = config->alphaMask;
-#if 0
-    modes->rgbBits = modes->redBits + modes->greenBits + 
-	modes->blueBits + modes->alphaBits;
-#endif
-    assert( !modes->rgbMode || ((config->bufferSize & 0x7) == 0) );
-    modes->rgbBits = config->bufferSize;
-    modes->indexBits = config->bufferSize;
-
-    modes->accumRedBits = config->accumRedSize;
-    modes->accumGreenBits = config->accumGreenSize;
-    modes->accumBlueBits = config->accumBlueSize;
-    modes->accumAlphaBits = config->accumAlphaSize;
-    modes->depthBits = config->depthSize;
-    modes->stencilBits = config->stencilSize;
-
-    modes->numAuxBuffers = 0;	/* XXX: should be picked up from the visual */
-
-    modes->level = config->level;
-}
-
 /*****************************************************************************/
 /* accessing the drawable private */
 
@@ -382,21 +338,13 @@ __glXCreateDrawablePrivate(DrawablePtr pDraw, XID drawId,
 
     pGlxScreen = &__glXActiveScreens[pDraw->pScreen->myNum];
 
-    /* allocate the buffers */
     if (glxPriv->type == DRAWABLE_WINDOW) {
-	int i;
 	VisualID vid = wVisual((WindowPtr)pDraw);
-	__GLXvisualConfig *pGlxVisual = pGlxScreen->pGlxVisual;
 
-	for (i = 0; i < pGlxScreen->numVisuals; i++, pGlxVisual++) {
+	glxPriv->modes = _gl_context_modes_find_visual( pGlxScreen->modes, vid );
-	    if (pGlxVisual->vid == vid) {
-		glxPriv->pGlxVisual = pGlxVisual;
-		break;
-	    }
-	}
 	__glXFBInitDrawable(glxPriv, modes);
     } else {
-	glxPriv->pGlxVisual = glxPriv->pGlxPixmap->pGlxVisual;
+	glxPriv->modes = glxPriv->pGlxPixmap->modes;
 	__glXPixInitDrawable(glxPriv, modes);
     }
 

GL/glx/glxutil.h

@@ -55,7 +55,6 @@ extern void __glXGetDrawableSize(__GLdrawablePrivate *glPriv,
 				 GLuint *width, GLuint *height);
 extern GLboolean __glXResizeDrawable(__GLdrawablePrivate *glPriv);
 extern GLboolean __glXResizeDrawableBuffers(__GLXdrawablePrivate *glxPriv);
-extern void __glXFormatGLModes(__GLcontextModes *modes, __GLXvisualConfig *config);
 
 /* drawable management */
 extern void __glXRefDrawablePrivate(__GLXdrawablePrivate *glxPriv);

GL/glx/impsize.h

@@ -67,6 +67,7 @@ extern int __glTexParameterfv_size(GLenum e);
 extern int __glTexParameteriv_size(GLenum e);
 extern int __glEvalComputeK(GLenum target);
 
-extern int __glPointParameterfvARB_size(GLenum pname);
+extern int __glPointParameterfvARB_size(GLenum e);
+extern int __glPointParameteriv_size(GLenum e);
 
 #endif /* _impsize_h_ */

GL/glx/render2.c

@@ -220,6 +220,14 @@ void __glXDisp_DrawArrays(GLbyte *pc)
 	    glEnableClientState(GL_EDGE_FLAG_ARRAY);
 	    glEdgeFlagPointer(stride, (const GLboolean *)pc);
 	    break;
+	  case GL_SECONDARY_COLOR_ARRAY:
+	    glEnableClientState(GL_SECONDARY_COLOR_ARRAY);
+	    glSecondaryColorPointer(numVals, datatype, stride, pc);
+	    break;
+	  case GL_FOG_COORD_ARRAY:
+	    glEnableClientState(GL_FOG_COORD_ARRAY);
+	    glFogCoordPointer(datatype, stride, pc);
+	    break;
 	  default:
 	    break;
 	}
@@ -236,10 +244,11 @@ void __glXDisp_DrawArrays(GLbyte *pc)
     glDisableClientState(GL_INDEX_ARRAY);
     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
     glDisableClientState(GL_EDGE_FLAG_ARRAY);
+    glDisableClientState(GL_SECONDARY_COLOR_ARRAY);
+    glDisableClientState(GL_FOG_COORD_ARRAY);
 }
 
 void __glXDisp_DrawArraysEXT(GLbyte *pc)
 {
-#ifdef XXX_STUB
+   __glXDisp_DrawArrays(pc);
-#endif /*XXX_STUB*/
 }

GL/glx/render2swap.c

@@ -386,6 +386,5 @@ void __glXDispSwap_DrawArrays(GLbyte *pc)
 
 void __glXDispSwap_DrawArraysEXT(GLbyte *pc)
 {
-#ifdef XXX_STUB
+   __glXDispSwap_DrawArrays(pc);
-#endif /*XXX_STUB*/
 }

GL/glx/rensize.c

@@ -551,12 +551,14 @@ int __glXDrawArraysSize( GLbyte *pc, Bool swap )
 	  case GL_COLOR_ARRAY:
 	  case GL_TEXTURE_COORD_ARRAY:
 	    break;
+	  case GL_SECONDARY_COLOR_ARRAY:
 	  case GL_NORMAL_ARRAY:
 	    if (numVals != 3) {
 		/* bad size */
 		return -1;
 	    }
 	    break;
+	  case GL_FOG_COORD_ARRAY:
 	  case GL_INDEX_ARRAY:
 	    if (numVals != 1) {
 		/* bad size */
@@ -918,3 +920,9 @@ int __glXPointParameterfvARBReqSize(GLbyte *pc, Bool swap )
     }
     return 4 * __glPointParameterfvARB_size( pname );
 }
+
+int __glXPointParameterivReqSize(GLbyte *pc, Bool swap )
+{
+    /* no difference between fv and iv versions */
+    return __glXPointParameterfvARBReqSize(pc, swap);
+}

GL/glx/rensizetab.c

@@ -231,7 +231,7 @@ __GLXrenderSizeData __glXRenderSizeTable[__GLX_MAX_RENDER_OPCODE_EXT - __GLX_MIN
 	/* Translatef          */	{  16, 	0                         },
 	/* Viewport            */	{  20, 	0                         },
 	/* PolygonOffset       */	{  12, 	0                         },
-	/* no such opcode      */	{  0, 	0                         },
+	/* DrawArrays          */	{  16, 	__glXDrawArraysSize       },
 	/* Indexubv            */	{  8, 	0                         },
 	/* ColorSubTable       */       {  44,  __glXColorSubTableReqSize },
 	/* CopyColorSubTable   */       {  24,  0                         },
@@ -2342,17 +2342,17 @@ __GLXrenderSizeData __glXRenderSizeTable_EXT[__GLX_MAX_RENDER_OPCODE_EXT - __GLX
 	/* CopyTexSubImage1D   */	{  28, 	0 },
 	/* CopyTexSubImage2D   */	{  36, 	0 },
 	/* CopyTexSubImage3D    4123 */ {  40,  0 },
-	/* no such opcode      */	{   0, 	0                         },
+	/* FogCoordfv           4124 */	{   8, 	0 },
-	/* no such opcode      */	{   0, 	0                         },
+	/* FogCoorddv           4125 */	{  12, 	0 },
-	/* no such opcode      */	{   0, 	0                         },
+	/* SecondaryColor3bv    4126 */	{   8, 	0 },
-	/* no such opcode      */	{   0, 	0                         },
+	/* SecondaryColor3sv    4127 */	{  12, 	0 },
-	/* no such opcode      */	{   0, 	0                         },
+	/* SecondaryColor3iv    4128 */	{  16, 	0 },
-	/* no such opcode      */	{   0, 	0                         },
+	/* SecondaryColor3fv    4129 */	{  16, 	0 },
-	/* no such opcode      */	{   0, 	0                         },
+	/* SecondaryColor3dv    4130 */	{  28, 	0 },
-	/* no such opcode      */	{   0, 	0                         },
+	/* SecondaryColor3ubv   4131 */	{   8, 	0 },
-	/* no such opcode      */	{   0, 	0                         },
+	/* SecondaryColor3usv   4132 */	{  12, 	0 },
-	/* no such opcode      */	{   0, 	0                         },
+	/* SecondaryColor3uiv   4133 */	{  16, 	0 },
-	/* no such opcode      */	{   0, 	0                         },
+	/* BlendFuncSeparate    4134 */	{  20, 	0 },
 	/* no such opcode      */	{   0, 	0                         },
 	/* no such opcode      */	{   0, 	0                         },
 	/* no such opcode      */	{   0, 	0                         },
@@ -2439,4 +2439,6 @@ __GLXrenderSizeData __glXRenderSizeTable_EXT[__GLX_MAX_RENDER_OPCODE_EXT - __GLX
 	/* no such opcode      */	{   0, 	0                         },
 	/* no such opcode      */	{   0, 	0                         },
 	/* ActiveStencilFaceEXT 4220 */ {   8,  0 },
+	/* PointParameteri      4221 */	{  12, 	0 },
+	/* PointParameteriv     4222 */	{   8, 	__glXPointParameterivReqSize },
 };

GL/glx/single2.c

@@ -296,16 +296,25 @@ char *__glXcombine_strings(const char *cext_string, const char *sext_string)
    return combo_string;
 }
 
-int __glXDisp_GetString(__GLXclientState *cl, GLbyte *pc)
+int DoGetString(__GLXclientState *cl, GLbyte *pc, GLboolean need_swap)
 {
     ClientPtr client;
     __GLXcontext *cx;
     GLenum name;
     const char *string;
+    __GLX_DECLARE_SWAP_VARIABLES;
     int error;
     char *buf = NULL, *buf1 = NULL;
     GLint length = 0;
 
+    /* If the client has the opposite byte order, swap the contextTag and
+     * the name.
+     */
+    if ( need_swap ) {
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + __GLX_SINGLE_HDR_SIZE);
+    }
+
     cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
     if (!cx) {
 	return error;
@@ -331,12 +340,32 @@ int __glXDisp_GetString(__GLXclientState *cl, GLbyte *pc)
 	}
 	string = buf;
     }
+    else if ( name == GL_VERSION ) {
+	if ( xf86atof( string ) > xf86atof( GLServerVersion ) ) {
+	    buf = __glXMalloc( __glXStrlen( string ) 
+			       + __glXStrlen( GLServerVersion )
+			       + 4 );
+	    if ( buf == NULL ) {
+		string = GLServerVersion;
+	    }
+	    else {
+		__glXSprintf( buf, "%s (%s)", GLServerVersion, string );
+		string = buf;
+	    }
+	}
+    }
     if (string) {
 	length = __glXStrlen((const char *) string) + 1;
     }
 
     __GLX_BEGIN_REPLY(length);
     __GLX_PUT_SIZE(length);
+
+    if ( need_swap ) {
+	__GLX_SWAP_REPLY_SIZE();
+	__GLX_SWAP_REPLY_HEADER();
+    }
+
     __GLX_SEND_HEADER();
     WriteToClient(client, length, (char *) string); 
     if (buf != NULL) {
@@ -345,6 +374,11 @@ int __glXDisp_GetString(__GLXclientState *cl, GLbyte *pc)
     return Success;
 }
 
+int __glXDisp_GetString(__GLXclientState *cl, GLbyte *pc)
+{
+    return DoGetString(cl, pc, GL_FALSE);
+}
+
 int __glXDisp_GetClipPlane(__GLXclientState *cl, GLbyte *pc)
 {
     __GLXcontext *cx;

GL/glx/single2swap.c

@@ -262,58 +262,7 @@ int __glXDispSwap_Finish(__GLXclientState *cl, GLbyte *pc)
 
 int __glXDispSwap_GetString(__GLXclientState *cl, GLbyte *pc)
 {
-    ClientPtr client;
+    return DoGetString(cl, pc, GL_TRUE);
-    __GLXcontext *cx;
-    GLenum name;
-    const char *string;
-    __GLX_DECLARE_SWAP_VARIABLES;
-    int error;
-    char *buf = NULL, *buf1 = NULL;
-    GLint length = 0;
-
-    __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
-    cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
-    if (!cx) {
-	return error;
-    }
-
-    pc += __GLX_SINGLE_HDR_SIZE;
-    __GLX_SWAP_INT(pc + 0);
-    name = *(GLenum *)(pc + 0);
-    string = (const char *)glGetString(name);
-    client = cl->client;
-
-    /*
-    ** Restrict extensions to those that are supported by both the
-    ** implementation and the connection.  That is, return the
-    ** intersection of client, server, and core extension strings.
-    */
-    if (name == GL_EXTENSIONS) {
-	buf1 = __glXcombine_strings(string,
-				      cl->GLClientextensions);
-	buf = __glXcombine_strings(buf1,
-				      cx->pGlxScreen->GLextensions);
-	if (buf1 != NULL) {
-	    __glXFree(buf1);
-	}
-	string = buf;
-    }
-    if (string) {
-	length = __glXStrlen((const char *) string) + 1;
-    }
-
-    __GLX_BEGIN_REPLY(length);
-    __GLX_PUT_SIZE(length);
-
-    __GLX_SWAP_REPLY_SIZE();
-    __GLX_SWAP_REPLY_HEADER();
-    __GLX_SEND_HEADER();
-    WriteToClient(client, length, (char *) string); 
-    if (buf != NULL) {
-	__glXFree(buf);
-    }
-
-    return Success;
 }
 
 int __glXDispSwap_GetClipPlane(__GLXclientState *cl, GLbyte *pc)

GL/glx/singlesize.c

@@ -49,32 +49,48 @@ GLint __glReadPixels_size(GLenum format, GLenum type, GLint w, GLint h)
     return __glXImage3DSize( format, type, w, h, 1, 0, 0, 0, 0, 4 );
 }
 
+/**
+ * Determine the number of data elements that go with the specified \c pname
+ * to a \c glGetTexEnvfv or \c glGetTexEnviv call.
+ * 
+ * \todo
+ * Replace this function with a call to \c __glTexEnvfv_size.  Make that there
+ * aren't any values of \c pname that are valid for one but not the other.
+ */
 GLint __glGetTexEnvfv_size(GLenum pname)
 {
     switch (pname) {
       case GL_TEXTURE_ENV_MODE:
+      case GL_TEXTURE_LOD_BIAS:
+      case GL_COMBINE_RGB:
+      case GL_COMBINE_ALPHA:
+      case GL_SOURCE0_RGB:
+      case GL_SOURCE1_RGB:
+      case GL_SOURCE2_RGB:
+      case GL_SOURCE0_ALPHA:
+      case GL_SOURCE1_ALPHA:
+      case GL_SOURCE2_ALPHA:
+      case GL_OPERAND0_RGB:
+      case GL_OPERAND1_RGB:
+      case GL_OPERAND2_RGB:
+      case GL_OPERAND0_ALPHA:
+      case GL_OPERAND1_ALPHA:
+      case GL_OPERAND2_ALPHA:
+      case GL_RGB_SCALE:
+      case GL_ALPHA_SCALE:
+	
+      /* GL_ARB_point_sprite / GL_NV_point_sprite */
+      case GL_COORD_REPLACE_ARB:
+
+      /* GL_NV_texture_env_combine4 */
+      case GL_SOURCE3_RGB_NV:
+      case GL_SOURCE3_ALPHA_NV:
+      case GL_OPERAND3_RGB_NV:
+      case GL_OPERAND3_ALPHA_NV:
 	return 1;
+
       case GL_TEXTURE_ENV_COLOR:
 	return 4;
-      case GL_TEXTURE_LOD_BIAS_EXT:
-	return 1;
-      case GL_COMBINE_RGB_ARB:
-      case GL_COMBINE_ALPHA_ARB:
-      case GL_SOURCE0_RGB_ARB:
-      case GL_SOURCE1_RGB_ARB:
-      case GL_SOURCE2_RGB_ARB:
-      case GL_SOURCE0_ALPHA_ARB:
-      case GL_SOURCE1_ALPHA_ARB:
-      case GL_SOURCE2_ALPHA_ARB:
-      case GL_OPERAND0_RGB_ARB:
-      case GL_OPERAND1_RGB_ARB:
-      case GL_OPERAND2_RGB_ARB:
-      case GL_OPERAND0_ALPHA_ARB:
-      case GL_OPERAND1_ALPHA_ARB:
-      case GL_OPERAND2_ALPHA_ARB:
-      case GL_RGB_SCALE_ARB:
-      case GL_ALPHA_SCALE:
-	return 1;
       default:
 	return -1;
     }
@@ -139,6 +155,15 @@ GLint __glGetTexParameterfv_size(GLenum pname)
       case GL_TEXTURE_COMPARE_MODE:
       case GL_TEXTURE_COMPARE_FUNC:
 
+      /* GL_SGIS_generate_mipmap / GL 1.4 */
+      case GL_GENERATE_MIPMAP:
+
+      /* GL_ARB_depth_texture / GL 1.4 */
+      case GL_DEPTH_TEXTURE_MODE:
+
+      /* GL_EXT_texture_lod_bias / GL 1.4 */
+      case GL_TEXTURE_LOD_BIAS:
+
       /* GL_SGIX_shadow_ambient / GL_ARB_shadow_ambient */
       case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
 
@@ -150,6 +175,12 @@ GLint __glGetTexParameterfv_size(GLenum pname)
       case GL_TEXTURE_MAX_CLAMP_S_SGIX:
       case GL_TEXTURE_MAX_CLAMP_T_SGIX:
       case GL_TEXTURE_MAX_CLAMP_R_SGIX:
+
+      /* GL_EXT_texture_filter_anisotropic */
+      case GL_TEXTURE_MAX_ANISOTROPY_EXT:
+
+      /* GL_NV_texture_expand_normal */
+      case GL_TEXTURE_UNSIGNED_REMAP_MODE_NV:
 	return 1;
 
       default:
@@ -833,10 +864,6 @@ GLint __glGet_size(GLenum sq)
       case GL_MAX_CONVOLUTION_WIDTH:
       case GL_MAX_CONVOLUTION_HEIGHT:
 	return 1;
-      case GL_TEXTURE_CUBE_MAP_ARB:
-      case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
-      case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
-	return 1;
       case GL_OCCLUSION_TEST_RESULT_HP:
       case GL_OCCLUSION_TEST_HP:
 	return 1;
@@ -846,6 +873,223 @@ GLint __glGet_size(GLenum sq)
 	return 1;
       case GL_RASTER_POSITION_UNCLIPPED_IBM:
 	return 1;
+
+      /* GL_ARB_texture_cube_map / GL 1.3 */
+      case GL_TEXTURE_CUBE_MAP:
+      case GL_TEXTURE_BINDING_CUBE_MAP:
+      case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
+
+      /* GL_ARB_multisample / GL 1.3 */
+      case GL_MULTISAMPLE:
+      case GL_SAMPLE_ALPHA_TO_COVERAGE:
+      case GL_SAMPLE_ALPHA_TO_ONE:
+      case GL_SAMPLE_COVERAGE:
+      case GL_SAMPLE_BUFFERS:
+      case GL_SAMPLES:
+      case GL_SAMPLE_COVERAGE_VALUE:
+      case GL_SAMPLE_COVERAGE_INVERT:
+
+      /* GL_ARB_texture_comrpession / GL 1.3 */
+      case GL_TEXTURE_COMPRESSION_HINT:
+      case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
+	
+      /* GL_EXT_blend_func_separate / GL 1.4 */
+      case GL_BLEND_DST_RGB:
+      case GL_BLEND_SRC_RGB:
+      case GL_BLEND_DST_ALPHA:
+      case GL_BLEND_SRC_ALPHA:
+
+      /* GL_EXT_fog_coord / GL 1.4 */
+      case GL_CURRENT_FOG_COORD:
+      case GL_FOG_COORD_ARRAY_TYPE:
+      case GL_FOG_COORD_ARRAY_STRIDE:
+      case GL_FOG_COORD_ARRAY:
+      case GL_FOG_COORD_SOURCE:
+
+      /* GL_EXT_secondary_color / GL 1.4 */
+      case GL_COLOR_SUM:
+      case GL_SECONDARY_COLOR_ARRAY_SIZE:
+      case GL_SECONDARY_COLOR_ARRAY_TYPE:
+      case GL_SECONDARY_COLOR_ARRAY_STRIDE:
+      case GL_SECONDARY_COLOR_ARRAY:
+
+      /* GL_EXT_texture_lod_bias / GL 1.4 */
+      case GL_MAX_TEXTURE_LOD_BIAS:
+
+      /* GL_ARB_point_sprite */
+      case GL_POINT_SPRITE_ARB:
+
+      /* GL_ARB_vertex_blend */
+      case GL_MAX_VERTEX_UNITS_ARB:
+      case GL_ACTIVE_VERTEX_UNITS_ARB:
+      case GL_WEIGHT_SUM_UNITY_ARB:
+      case GL_VERTEX_BLEND_ARB:
+      case GL_CURRENT_WEIGHT_ARB:
+      case GL_WEIGHT_ARRAY_ARB:
+      case GL_WEIGHT_ARRAY_TYPE_ARB:
+      case GL_WEIGHT_ARRAY_STRIDE_ARB:
+      case GL_WEIGHT_ARRAY_SIZE_ARB:
+
+      /* GL_ARB_matrix_palette */
+      case GL_MATRIX_PALETTE_ARB:
+      case GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB:
+      case GL_MAX_PALETTE_MATRICES_ARB:
+      case GL_CURRENT_PALETTE_MATRIX_ARB:
+      case GL_CURRENT_MATRIX_INDEX_ARB:
+      case GL_MATRIX_INDEX_ARRAY_ARB:
+      case GL_MATRIX_INDEX_ARRAY_SIZE_ARB:
+      case GL_MATRIX_INDEX_ARRAY_TYPE_ARB:
+      case GL_MATRIX_INDEX_ARRAY_STRIDE_ARB:
+
+      /* GL_EXT_clip_volume_hint */
+      case GL_CLIP_VOLUME_CLIPPING_HINT_EXT:
+
+      /* GL_EXT_depth_bounds_test */
+      case GL_DEPTH_BOUNDS_TEST_EXT:
+
+      /* GL_EXT_stencil_two_size */
+      case GL_STENCIL_TEST_TWO_SIDE_EXT:
+      case GL_ACTIVE_STENCIL_FACE_EXT:
+
+      /* GL_EXT_vertex_weighting */
+      case GL_VERTEX_WEIGHTING_EXT:
+      case GL_MODELVIEW0_EXT:
+      case GL_MODELVIEW1_EXT:
+      case GL_CURRENT_VERTEX_WEIGHT_EXT:
+      case GL_VERTEX_WEIGHT_ARRAY_EXT:
+      case GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT:
+      case GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT:
+      case GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT:
+      /* case GL_MODELVIEW0_STACK_DEPTH_EXT: */ /* alias */
+      case GL_MODELVIEW1_STACK_DEPTH_EXT:
+
+      /* GL_EXT_blend_equation_separate */
+      /* case GL_BLEND_EQUATION_RGB_EXT: */ /* alias */
+      case GL_BLEND_EQUATION_ALPHA_EXT:
+
+      /* GL_ATI_vertex_streams */
+      case GL_MAX_VERTEX_STREAMS_ATI:
+
+      /* GL_ATI_draw_buffers */
+      case GL_MAX_DRAW_BUFFERS_ATI:
+      case GL_DRAW_BUFFER0_ATI:
+      case GL_DRAW_BUFFER1_ATI:
+      case GL_DRAW_BUFFER2_ATI:
+      case GL_DRAW_BUFFER3_ATI:
+      case GL_DRAW_BUFFER4_ATI:
+      case GL_DRAW_BUFFER5_ATI:
+      case GL_DRAW_BUFFER6_ATI:
+      case GL_DRAW_BUFFER7_ATI:
+      case GL_DRAW_BUFFER8_ATI:
+      case GL_DRAW_BUFFER9_ATI:
+      case GL_DRAW_BUFFER10_ATI:
+      case GL_DRAW_BUFFER11_ATI:
+      case GL_DRAW_BUFFER12_ATI:
+      case GL_DRAW_BUFFER13_ATI:
+      case GL_DRAW_BUFFER14_ATI:
+      case GL_DRAW_BUFFER15_ATI:
+
+      /* GL_ATI_separate_stencil */
+      case GL_STENCIL_BACK_FUNC_ATI:
+      case GL_STENCIL_BACK_FAIL_ATI:
+      case GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI:
+      case GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI:
+
+      /* GL_NV_depth_clamp */
+      case GL_DEPTH_CLAMP_NV:
+
+      /* GL_NV_fog_distance */
+      case GL_FOG_DISTANCE_MODE_NV:
+
+      /* GL_NV_light_max_exponent */
+      case GL_MAX_SHININESS_NV:
+      case GL_MAX_SPOT_EXPONENT_NV:
+
+      /* GL_NV_multisample_filter_hint */
+      case GL_MULTISAMPLE_FILTER_HINT_NV:
+
+      /* GL_NV_point_sprite */
+      /* case GL_POINT_SPRITE_NV: */ /* alias */
+      case GL_POINT_SPRITE_R_MODE_NV:
+
+      /* GL_NV_primitive_restart */
+      case GL_PRIMITIVE_RESTART_NV:
+      case GL_PRIMITIVE_RESTART_INDEX_NV:
+
+      /* GL_NV_register_combiners */
+      case GL_REGISTER_COMBINERS_NV:
+      case GL_NUM_GENERAL_COMBINERS_NV:
+      case GL_COLOR_SUM_CLAMP_NV:
+      case GL_MAX_GENERAL_COMBINERS_NV:
+
+      /* GL_NV_register_combiners2 */
+      case GL_PER_STAGE_CONSTANTS_NV:
+
+      /* GL_NV_texture_rectangle */
+      case GL_TEXTURE_RECTANGLE_NV:
+      case GL_TEXTURE_BINDING_RECTANGLE_NV:
+      case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
+	return 1;
+
+      /* GL_EXT_depth_bounds_test */
+      case GL_DEPTH_BOUNDS_EXT:
+	return 2;
+
+      /* GL_EXT_secondary_color / GL 1.4 */
+      case GL_CURRENT_SECONDARY_COLOR:
+
+      /* GL_NV_register_combiners */
+      case GL_CONSTANT_COLOR0_NV:
+      case GL_CONSTANT_COLOR1_NV:
+	return 4;
+
+      /* GL_ARB_vertex_blend */
+      /* case GL_MODELVIEW0_ARB: */ /* alias */
+      /* case GL_MODELVIEW1_ARB: */ /* alias */
+      case GL_MODELVIEW2_ARB:
+      case GL_MODELVIEW3_ARB:
+      case GL_MODELVIEW4_ARB:
+      case GL_MODELVIEW5_ARB:
+      case GL_MODELVIEW6_ARB:
+      case GL_MODELVIEW7_ARB:
+      case GL_MODELVIEW8_ARB:
+      case GL_MODELVIEW9_ARB:
+      case GL_MODELVIEW10_ARB:
+      case GL_MODELVIEW11_ARB:
+      case GL_MODELVIEW12_ARB:
+      case GL_MODELVIEW13_ARB:
+      case GL_MODELVIEW14_ARB:
+      case GL_MODELVIEW15_ARB:
+      case GL_MODELVIEW16_ARB:
+      case GL_MODELVIEW17_ARB:
+      case GL_MODELVIEW18_ARB:
+      case GL_MODELVIEW19_ARB:
+      case GL_MODELVIEW20_ARB:
+      case GL_MODELVIEW21_ARB:
+      case GL_MODELVIEW22_ARB:
+      case GL_MODELVIEW23_ARB:
+      case GL_MODELVIEW24_ARB:
+      case GL_MODELVIEW25_ARB:
+      case GL_MODELVIEW26_ARB:
+      case GL_MODELVIEW27_ARB:
+      case GL_MODELVIEW28_ARB:
+      case GL_MODELVIEW29_ARB:
+      case GL_MODELVIEW30_ARB:
+      case GL_MODELVIEW31_ARB:
+
+      /* GL_EXT_vertex_weighting */
+      /* case GL_MODELVIEW0_MATRIX_EXT: */ /* alias */
+      case GL_MODELVIEW1_MATRIX_EXT:
+	return 32;
+
+      /* GL_ARB_texture_comrpession / GL 1.3 */
+      case GL_COMPRESSED_TEXTURE_FORMATS: {
+	  GLint temp;
+	  
+	  glGetIntegerv( GL_NUM_COMPRESSED_TEXTURE_FORMATS, & temp );
+	  return temp;
+      }
+
       default:
 	return -1;
     }
@@ -885,7 +1129,15 @@ GLint __glGetTexLevelParameterfv_size(GLenum pname)
       case GL_TEXTURE_ALPHA_SIZE:
       case GL_TEXTURE_LUMINANCE_SIZE:
       case GL_TEXTURE_INTENSITY_SIZE:
+
+      /* GL_ARB_texture_compression / GL 1.3 */
+      case GL_TEXTURE_COMPRESSED_IMAGE_SIZE:
+      case GL_TEXTURE_COMPRESSED:
+
+      /* GL_ARB_depth_texture / GL 1.4 */
+      case GL_TEXTURE_DEPTH_SIZE:
 	return 1;
+
       default:
 	return -1;
     }

hw/xfree86/dixmods/glxmodule.c

@@ -776,7 +776,6 @@ static const char *glcoreSymbols[] = {
     "__glXFogfvReqSize",
     "__glXFogivReqSize",
     "__glXForceCurrent",
-    "__glXFormatGLModes",
     "__glXFree",
     "__glXFreeBuffers",
     "__glXFreeContext",

hw/xfree86/dri/dri.c

@@ -113,11 +113,14 @@ Bool
 DRIScreenInit(ScreenPtr pScreen, DRIInfoPtr pDRIInfo, int *pDRMFD)
 {
     DRIScreenPrivPtr    pDRIPriv;
-    drmContextPtr       reserved;
+    drm_context_t *       reserved;
     int                 reserved_count;
     int                 i, fd, drmWasAvailable;
     Bool                xineramaInCore = FALSE;
     int                 err = 0;
+    char                *openbusid;
+    drmVersionPtr       drmlibv;
+    int                 drmlibmajor, drmlibminor, drmdimajor, drmdiminor;
 
     if (DRIGeneration != serverGeneration) {
 	if ((DRIScreenPrivIndex = AllocateScreenPrivateIndex()) < 0)
@@ -148,8 +151,31 @@ DRIScreenInit(ScreenPtr pScreen, DRIInfoPtr pDRIInfo, int *pDRMFD)
 
     drmWasAvailable = drmAvailable();
 
+    /* Check the DRM lib version.
+     * drmGetLibVersion was not supported in version 1.0, so check for
+     * symbol first to avoid possible crash or hang.
+     */
+    drmlibmajor = 1;
+    drmlibminor = 0;
+    if (xf86LoaderCheckSymbol("drmGetLibVersion")) {
+	drmlibv = drmGetLibVersion(-1);
+	if (drmlibv != NULL) {
+	    drmlibmajor = drmlibv->version_major;
+	    drmlibminor = drmlibv->version_minor;
+	    drmFreeVersion(drmlibv);
+	}
+    }
+
+    /* Check if the libdrm can handle falling back to loading based on name
+     * if a busid string is passed.
+     */
+    if (drmlibmajor == 1 && drmlibminor >= 2)
+	openbusid = pDRIInfo->busIdString;
+    else
+	openbusid = NULL;
+
     /* Note that drmOpen will try to load the kernel module, if needed. */
-    fd = drmOpen(pDRIInfo->drmDriverName, NULL );
+    fd = drmOpen(pDRIInfo->drmDriverName, openbusid);
     if (fd < 0) {
         /* failed to open DRM */
         pScreen->devPrivates[DRIScreenPrivIndex].ptr = NULL;
@@ -184,7 +210,40 @@ DRIScreenInit(ScreenPtr pScreen, DRIInfoPtr pDRIInfo, int *pDRMFD)
     pDRIPriv->grabbedDRILock = FALSE;
     pDRIPriv->drmSIGIOHandlerInstalled = FALSE;
 
-    if ((err = drmSetBusid(pDRIPriv->drmFD, pDRIPriv->pDriverInfo->busIdString)) < 0) {
+    if (drmlibmajor == 1 && drmlibminor >= 2) {
+	drmSetVersion sv;
+
+	/* Get the interface version, asking for 1.1. */
+	sv.drm_di_major = 1;
+	sv.drm_di_minor = 1;
+	sv.drm_dd_major = -1;
+	err = drmSetInterfaceVersion(pDRIPriv->drmFD, &sv);
+	if (err == 0) {
+	    drmdimajor = sv.drm_di_major;
+	    drmdiminor = sv.drm_di_minor;
+	} else {
+	    /* failure, so set it to 1.0.0. */
+	    drmdimajor = 1;
+	    drmdiminor = 0;
+	}
+    }
+    else {
+	/* We can't check the DI DRM interface version, so set it to 1.0.0. */
+	drmdimajor = 1;
+	drmdiminor = 0;
+    }
+    DRIDrvMsg(pScreen->myNum, X_INFO,
+              "[drm] DRM interface version %d.%d\n", drmdimajor, drmdiminor);
+
+    /* If the interface minor number is 1.1, then we've opened a DRM device
+     * that already had the busid set through drmOpen.
+     */
+    if (drmdimajor == 1 && drmdiminor >= 1)
+	err = 0;
+    else
+	err = drmSetBusid(pDRIPriv->drmFD, pDRIPriv->pDriverInfo->busIdString);
+
+    if (err < 0) {
 	pDRIPriv->directRenderingSupport = FALSE;
 	pScreen->devPrivates[DRIScreenPrivIndex].ptr = NULL;
 	drmClose(pDRIPriv->drmFD);
@@ -235,7 +294,7 @@ DRIScreenInit(ScreenPtr pScreen, DRIInfoPtr pDRIInfo, int *pDRMFD)
 	      pDRIPriv->hSAREA, pDRIPriv->pSAREA);
 
     if (drmAddMap( pDRIPriv->drmFD,
-		   (drmHandle)pDRIPriv->pDriverInfo->frameBufferPhysicalAddress,
+		   (drm_handle_t)pDRIPriv->pDriverInfo->frameBufferPhysicalAddress,
 		   pDRIPriv->pDriverInfo->frameBufferSize,
 		   DRM_FRAME_BUFFER,
 		   0,
@@ -424,7 +483,7 @@ DRICloseScreen(ScreenPtr pScreen)
 {
     DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
     DRIInfoPtr       pDRIInfo;
-    drmContextPtr    reserved;
+    drm_context_t *    reserved;
     int              reserved_count;
 
     if (pDRIPriv && pDRIPriv->directRenderingSupport) {
@@ -575,7 +634,7 @@ DRIQueryDirectRenderingCapable(ScreenPtr pScreen, Bool* isCapable)
 }
 
 Bool
-DRIOpenConnection(ScreenPtr pScreen, drmHandlePtr hSAREA, char **busIdString)
+DRIOpenConnection(ScreenPtr pScreen, drm_handle_t * hSAREA, char **busIdString)
 {
     DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
 
@@ -586,7 +645,7 @@ DRIOpenConnection(ScreenPtr pScreen, drmHandlePtr hSAREA, char **busIdString)
 }
 
 Bool
-DRIAuthConnection(ScreenPtr pScreen, drmMagic magic)
+DRIAuthConnection(ScreenPtr pScreen, drm_magic_t magic)
 {
     DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
 
@@ -620,18 +679,18 @@ DRIGetClientDriverName(ScreenPtr pScreen,
 /* DRICreateContextPriv and DRICreateContextPrivFromHandle are helper
    functions that layer on drmCreateContext and drmAddContextTag.
 
-   DRICreateContextPriv always creates a kernel drmContext and then calls
+   DRICreateContextPriv always creates a kernel drm_context_t and then calls
    DRICreateContextPrivFromHandle to create a DRIContextPriv structure for
-   DRI tracking.  For the SIGIO handler, the drmContext is associated with
+   DRI tracking.  For the SIGIO handler, the drm_context_t is associated with
    DRIContextPrivPtr.  Any special flags are stored in the DRIContextPriv
    area and are passed to the kernel (if necessary).
 
    DRICreateContextPriv returns a pointer to newly allocated
-   DRIContextPriv, and returns the kernel drmContext in pHWContext. */
+   DRIContextPriv, and returns the kernel drm_context_t in pHWContext. */
 
 DRIContextPrivPtr
 DRICreateContextPriv(ScreenPtr pScreen,
-		     drmContextPtr pHWContext,
+		     drm_context_t * pHWContext,
 		     DRIContextFlags flags)
 {
     DRIScreenPrivPtr  pDRIPriv = DRI_SCREEN_PRIV(pScreen);
@@ -645,7 +704,7 @@ DRICreateContextPriv(ScreenPtr pScreen,
 
 DRIContextPrivPtr
 DRICreateContextPrivFromHandle(ScreenPtr pScreen,
-			       drmContext hHWContext,
+			       drm_context_t hHWContext,
 			       DRIContextFlags flags)
 {
     DRIScreenPrivPtr  pDRIPriv = DRI_SCREEN_PRIV(pScreen);
@@ -721,7 +780,7 @@ DRICreateDummyContext(ScreenPtr pScreen, Bool needCtxPriv)
 {
     DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
     __GLXscreenInfo *pGLXScreen = &__glXActiveScreens[pScreen->myNum];
-    __GLXvisualConfig *pGLXVis = pGLXScreen->pGlxVisual;
+    __GLcontextModes *modes = pGLXScreen->modes;
     void **pVisualConfigPriv = pGLXScreen->pVisualPriv;
     DRIContextPrivPtr pDRIContextPriv;
     void *contextStore;
@@ -734,7 +793,7 @@ DRICreateDummyContext(ScreenPtr pScreen, Bool needCtxPriv)
     for (visNum = 0;
 	 visNum < pScreen->numVisuals;
 	 visNum++, visual++) {
-	if (pGLXVis->vid == visual->vid)
+	if (modes->visualID == visual->vid)
 	    break;
     }
     if (visNum == pScreen->numVisuals) return FALSE;
@@ -781,15 +840,14 @@ DRIDestroyDummyContext(ScreenPtr pScreen, Bool hasCtxPriv)
 
 Bool
 DRICreateContext(ScreenPtr pScreen, VisualPtr visual,
-                 XID context, drmContextPtr pHWContext)
+                 XID context, drm_context_t * pHWContext)
 {
     DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
     __GLXscreenInfo *pGLXScreen = &__glXActiveScreens[pScreen->myNum];
-    __GLXvisualConfig *pGLXVis = pGLXScreen->pGlxVisual;
+    __GLcontextModes *modes = pGLXScreen->modes;
     void **pVisualConfigPriv = pGLXScreen->pVisualPriv;
     DRIContextPrivPtr pDRIContextPriv;
     void *contextStore;
-    int visNum;
 
     if (pDRIPriv->createDummyCtx && !pDRIPriv->dummyCtxPriv) {
         if (!DRICreateDummyContext(pScreen, pDRIPriv->createDummyCtxPriv)) {
@@ -800,12 +858,13 @@ DRICreateContext(ScreenPtr pScreen, VisualPtr visual,
     }
 
     /* Find the GLX visual associated with the one requested */
-    for (visNum = 0;
+    for (modes = pGLXScreen->modes; modes != NULL; modes = modes->next) {
-	 visNum < pGLXScreen->numVisuals;
+	if (modes->visualID == visual->vid)
-	 visNum++, pGLXVis++, pVisualConfigPriv++)
-	if (pGLXVis->vid == visual->vid)
 	    break;
-    if (visNum == pGLXScreen->numVisuals) {
+	pVisualConfigPriv++;
+    }
+
+    if (modes == NULL) {
 	/* No matching GLX visual found */
 	return FALSE;
     }
@@ -928,7 +987,7 @@ DRITransitionTo2d(ScreenPtr pScreen)
 
 Bool
 DRICreateDrawable(ScreenPtr pScreen, Drawable id,
-                  DrawablePtr pDrawable, drmDrawablePtr hHWDrawable)
+                  DrawablePtr pDrawable, drm_drawable_t * hHWDrawable)
 {
     DRIScreenPrivPtr	pDRIPriv = DRI_SCREEN_PRIV(pScreen);
     DRIDrawablePrivPtr	pDRIDrawablePriv;
@@ -945,7 +1004,7 @@ DRICreateDrawable(ScreenPtr pScreen, Drawable id,
 		return FALSE;
 	    }
 
-	    /* Only create a drmDrawable once */
+	    /* Only create a drm_drawable_t once */
 	    if (drmCreateDrawable(pDRIPriv->drmFD, hHWDrawable)) {
 		xfree(pDRIDrawablePriv);
 		return FALSE;
@@ -1065,11 +1124,11 @@ DRIGetDrawableInfo(ScreenPtr pScreen,
                    int* W,
                    int* H,
                    int* numClipRects,
-                   XF86DRIClipRectPtr* pClipRects,
+                   drm_clip_rect_t ** pClipRects,
                    int* backX,
                    int* backY,
                    int* numBackClipRects,
-                   XF86DRIClipRectPtr* pBackClipRects)
+                   drm_clip_rect_t ** pBackClipRects)
 {
     DRIScreenPrivPtr    pDRIPriv = DRI_SCREEN_PRIV(pScreen);
     DRIDrawablePrivPtr	pDRIDrawablePriv, pOldDrawPriv;
@@ -1165,7 +1224,7 @@ DRIGetDrawableInfo(ScreenPtr pScreen,
 	    *W = (int)(pWin->drawable.width);
 	    *H = (int)(pWin->drawable.height);
 	    *numClipRects = REGION_NUM_RECTS(&pWin->clipList);
-	    *pClipRects = (XF86DRIClipRectPtr)REGION_RECTS(&pWin->clipList);
+	    *pClipRects = (drm_clip_rect_t *)REGION_RECTS(&pWin->clipList);
 
 	    if (!*numClipRects && pDRIPriv->fullscreen) {
 				/* use fake full-screen clip rect */
@@ -1191,8 +1250,8 @@ DRIGetDrawableInfo(ScreenPtr pScreen,
 
 	       if (x0 < 0) x0 = 0;
 	       if (y0 < 0) y0 = 0;
-	       if (x1 > pScreen->width-1) x1 = pScreen->width-1;
+	       if (x1 > pScreen->width) x1 = pScreen->width;
-	       if (y1 > pScreen->height-1) y1 = pScreen->height-1;
+	       if (y1 > pScreen->height) y1 = pScreen->height;
 
 	       pDRIPriv->private_buffer_rect.x1 = x0;
 	       pDRIPriv->private_buffer_rect.y1 = y0;
@@ -1222,7 +1281,7 @@ DRIGetDrawableInfo(ScreenPtr pScreen,
 
 Bool
 DRIGetDeviceInfo(ScreenPtr pScreen,
-                 drmHandlePtr hFrameBuffer,
+                 drm_handle_t * hFrameBuffer,
                  int* fbOrigin,
                  int* fbSize,
                  int* fbStride,
@@ -1870,7 +1929,7 @@ DRIGetSAREAPrivate(ScreenPtr pScreen)
     return (void *)(((char*)pDRIPriv->pSAREA)+sizeof(XF86DRISAREARec));
 }
 
-drmContext
+drm_context_t
 DRIGetContext(ScreenPtr pScreen)
 {
     DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
@@ -1967,7 +2026,7 @@ DRIOpenFullScreen(ScreenPtr pScreen, DrawablePtr pDrawable)
     DRIScreenPrivPtr   pDRIPriv    = DRI_SCREEN_PRIV(pScreen);
     ScrnInfoPtr        pScrn       = xf86Screens[pScreen->myNum];
     WindowPtr	       pWin        = (WindowPtr)pDrawable;
-    XF86DRIClipRectPtr pClipRects  = (void *)REGION_RECTS(&pWin->clipList);
+    drm_clip_rect_t * pClipRects  = (void *)REGION_RECTS(&pWin->clipList);
 
     _DRIAdjustFrame(pScrn, pDRIPriv, pScrn->frameX0, pScrn->frameY0);
 
@@ -2115,3 +2174,21 @@ DRIMoveBuffersHelper(
    } else *xdir = 1;
 
 }
+
+char *
+DRICreatePCIBusID(pciVideoPtr PciInfo)
+{
+    char *busID;
+    int domain;
+    PCITAG tag;
+
+    busID = xalloc(20);
+    if (busID == NULL)
+	return NULL;
+
+    tag = pciTag(PciInfo->bus, PciInfo->device, PciInfo->func);
+    domain = xf86GetPciDomain(tag);
+    snprintf(busID, 20, "pci:%04x:%02x:%02x.%d", domain, PciInfo->bus,
+	PciInfo->device, PciInfo->func);
+    return busID;
+}

hw/xfree86/dri/dri.h

@@ -105,11 +105,11 @@ typedef struct {
      */
     Bool	(*CreateContext)(ScreenPtr pScreen,
 				 VisualPtr visual,
-				 drmContext hHWContext,
+				 drm_context_t hHWContext,
 				 void* pVisualConfigPriv,
 				 DRIContextType context);
     void        (*DestroyContext)(ScreenPtr pScreen,
-				  drmContext hHWContext,
+				  drm_context_t hHWContext,
                                   DRIContextType context);
     void	(*SwapContext)(ScreenPtr pScreen,
 			       DRISyncType syncType,
@@ -175,10 +175,10 @@ extern Bool DRIQueryDirectRenderingCapable(ScreenPtr pScreen,
                                            Bool *isCapable);
 
 extern Bool DRIOpenConnection(ScreenPtr pScreen,
-                              drmHandlePtr hSAREA,
+                              drm_handle_t * hSAREA,
                               char **busIdString);
 
-extern Bool DRIAuthConnection(ScreenPtr pScreen, drmMagic magic);
+extern Bool DRIAuthConnection(ScreenPtr pScreen, drm_magic_t magic);
 
 extern Bool DRICloseConnection(ScreenPtr pScreen);
 
@@ -191,7 +191,7 @@ extern Bool DRIGetClientDriverName(ScreenPtr pScreen,
 extern Bool DRICreateContext(ScreenPtr pScreen,
                              VisualPtr visual,
                              XID context,
-                             drmContextPtr pHWContext);
+                             drm_context_t * pHWContext);
 
 extern Bool DRIDestroyContext(ScreenPtr pScreen, XID context);
 
@@ -200,7 +200,7 @@ extern Bool DRIContextPrivDelete(pointer pResource, XID id);
 extern Bool DRICreateDrawable(ScreenPtr pScreen,
                               Drawable id,
                               DrawablePtr pDrawable,
-                              drmDrawablePtr hHWDrawable);
+                              drm_drawable_t * hHWDrawable);
 
 extern Bool DRIDestroyDrawable(ScreenPtr pScreen, 
                                Drawable id,
@@ -218,14 +218,14 @@ extern Bool DRIGetDrawableInfo(ScreenPtr pScreen,
                                int* W,
                                int* H,
                                int* numClipRects,
-                               XF86DRIClipRectPtr* pClipRects,
+                               drm_clip_rect_t ** pClipRects,
                                int* backX,
                                int* backY,
                                int* numBackClipRects,
-                               XF86DRIClipRectPtr* pBackClipRects);
+                               drm_clip_rect_t ** pBackClipRects);
 
 extern Bool DRIGetDeviceInfo(ScreenPtr pScreen,
-                             drmHandlePtr hFrameBuffer,
+                             drm_handle_t * hFrameBuffer,
                              int* fbOrigin,
                              int* fbSize,
                              int* fbStride,
@@ -298,16 +298,16 @@ extern unsigned int DRIGetDrawableStamp(ScreenPtr pScreen,
                                         CARD32 drawable_index);
 
 extern DRIContextPrivPtr DRICreateContextPriv(ScreenPtr pScreen,
-                                              drmContextPtr pHWContext,
+                                              drm_context_t * pHWContext,
                                               DRIContextFlags flags);
 
 extern DRIContextPrivPtr DRICreateContextPrivFromHandle(ScreenPtr pScreen,
-                                                        drmContext hHWContext,
+                                                        drm_context_t hHWContext,
                                                         DRIContextFlags flags);
 
 extern Bool DRIDestroyContextPriv(DRIContextPrivPtr pDRIContextPriv);
 
-extern drmContext DRIGetContext(ScreenPtr pScreen);
+extern drm_context_t DRIGetContext(ScreenPtr pScreen);
 
 extern void DRIQueryVersion(int *majorVersion,
                             int *minorVersion,
@@ -325,6 +325,8 @@ extern void DRIMoveBuffersHelper(ScreenPtr pScreen,
                                  int *ydir, 
                                  RegionPtr reg);
 
+extern char *DRICreatePCIBusID(pciVideoPtr PciInfo);
+
 #define _DRI_H_
 
 #endif

hw/xfree86/dri/dristruct.h

@@ -50,7 +50,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 typedef struct _DRIDrawablePrivRec
 {
-    drmDrawable		hwDrawable;
+    drm_drawable_t		hwDrawable;
     int			drawableIndex;
     ScreenPtr		pScreen;
     int 		refCount;
@@ -58,7 +58,7 @@ typedef struct _DRIDrawablePrivRec
 
 struct _DRIContextPrivRec
 {
-    drmContext		hwContext;
+    drm_context_t		hwContext;
     ScreenPtr		pScreen;
     Bool     		valid3D;
     DRIContextFlags     flags;
@@ -78,19 +78,19 @@ typedef struct _DRIScreenPrivRec
 {
     Bool		directRenderingSupport;
     int			drmFD;	      /* File descriptor for /dev/video/?   */
-    drmHandle   	hSAREA;	      /* Handle to SAREA, for mapping       */
+    drm_handle_t   	hSAREA;	      /* Handle to SAREA, for mapping       */
     XF86DRISAREAPtr	pSAREA;	      /* Mapped pointer to SAREA            */
-    drmHandle   	hFrameBuffer; /* Handle to framebuffer, for mapping */
+    drm_handle_t   	hFrameBuffer; /* Handle to framebuffer, for mapping */
-    drmContext          myContext;    /* DDX Driver's context               */
+    drm_context_t          myContext;    /* DDX Driver's context               */
     DRIContextPrivPtr   myContextPriv;/* Pointer to server's private area   */
     DRIContextPrivPtr   lastPartial3DContext;  /* last one partially saved  */
     void**		hiddenContextStore;    /* hidden X context          */
     void**		partial3DContextStore; /* parital 3D context        */
     DRIInfoPtr		pDriverInfo;
     int                 nrWindows;
-    XF86DRIClipRectRec  private_buffer_rect; /* management of private buffers */
+    drm_clip_rect_t  private_buffer_rect; /* management of private buffers */
     DrawablePtr         fullscreen; /* pointer to fullscreen drawable */
-    XF86DRIClipRectRec  fullscreen_rect; /* fake rect for fullscreen mode */
+    drm_clip_rect_t  fullscreen_rect; /* fake rect for fullscreen mode */
     DRIWrappedFuncsRec	wrap;
     DrawablePtr		DRIDrawables[SAREA_MAX_DRAWABLES];
     DRIContextPrivPtr   dummyCtxPriv; /* Pointer to dummy context */

hw/xfree86/dri/sarea.h

@@ -1,3 +1,4 @@
+/* $XFree86: xc/programs/Xserver/GL/dri/sarea.h,v 1.11 2002/10/30 12:52:03 alanh Exp $ */
 /**
  * \file sarea.h 
  * SAREA definitions.
@@ -87,7 +88,7 @@ typedef struct _XF86DRISAREA {
     drmLock			drawable_lock;
     XF86DRISAREADrawableRec	drawableTable[SAREA_MAX_DRAWABLES];
     XF86DRISAREAFrameRec        frame;
-    drmContext			dummy_context;
+    drm_context_t			dummy_context;
 } XF86DRISAREARec, *XF86DRISAREAPtr;
 
 #endif

hw/xfree86/dri/xf86dri.c

@@ -184,7 +184,7 @@ ProcXF86DRIOpenConnection(
 )
 {
     xXF86DRIOpenConnectionReply rep;
-    drmHandle			hSAREA;
+    drm_handle_t			hSAREA;
     char*			busIdString;
 
     REQUEST(xXF86DRIOpenConnectionReq);
@@ -340,7 +340,7 @@ ProcXF86DRICreateContext(
     if (!DRICreateContext( pScreen,
 			   visual,
 			   stuff->context,
-			   (drmContextPtr)&rep.hHWContext)) {
+			   (drm_context_t *)&rep.hHWContext)) {
 	return BadValue;
     }
 
@@ -397,7 +397,7 @@ ProcXF86DRICreateDrawable(
     if (!DRICreateDrawable( screenInfo.screens[stuff->screen],
 			    (Drawable)stuff->drawable,
 			    pDrawable,
-			    (drmDrawablePtr)&rep.hHWDrawable)) {
+			    (drm_drawable_t *)&rep.hHWDrawable)) {
 	return BadValue;
     }
 
@@ -442,8 +442,8 @@ ProcXF86DRIGetDrawableInfo(
     xXF86DRIGetDrawableInfoReply	rep;
     DrawablePtr pDrawable;
     int X, Y, W, H;
-    XF86DRIClipRectPtr pClipRects;
+    drm_clip_rect_t * pClipRects;
-    XF86DRIClipRectPtr pBackClipRects;
+    drm_clip_rect_t * pBackClipRects;
     int backX, backY;
 
     REQUEST(xXF86DRIGetDrawableInfoReq);
@@ -492,10 +492,10 @@ ProcXF86DRIGetDrawableInfo(
     rep.backY = backY;
         
     if (rep.numBackClipRects) 
-       rep.length += sizeof(XF86DRIClipRectRec) * rep.numBackClipRects;    
+       rep.length += sizeof(drm_clip_rect_t) * rep.numBackClipRects;    
 
     if (rep.numClipRects) 
-       rep.length += sizeof(XF86DRIClipRectRec) * rep.numClipRects;
+       rep.length += sizeof(drm_clip_rect_t) * rep.numClipRects;
     
     rep.length = ((rep.length + 3) & ~3) >> 2;
 
@@ -503,13 +503,13 @@ ProcXF86DRIGetDrawableInfo(
 
     if (rep.numClipRects) {
 	WriteToClient(client,  
-		      sizeof(XF86DRIClipRectRec) * rep.numClipRects,
+		      sizeof(drm_clip_rect_t) * rep.numClipRects,
 		      (char *)pClipRects);
     }
 
     if (rep.numBackClipRects) {
        WriteToClient(client, 
-		     sizeof(XF86DRIClipRectRec) * rep.numBackClipRects,
+		     sizeof(drm_clip_rect_t) * rep.numBackClipRects,
 		     (char *)pBackClipRects);
     }
 
@@ -522,7 +522,7 @@ ProcXF86DRIGetDeviceInfo(
 )
 {
     xXF86DRIGetDeviceInfoReply	rep;
-    drmHandle hFrameBuffer;
+    drm_handle_t hFrameBuffer;
     void *pDevPrivate;
 
     REQUEST(xXF86DRIGetDeviceInfoReq);

hw/xfree86/os-support/xf86_libc.h

@@ -45,6 +45,7 @@
 #define XF86_LIBC_H 1
 
 #include "Xfuncs.h"
+#include <stddef.h>
 
 /*
  * The first set of definitions are required both for modules and