libX11 xserver fontconfig mesa pixman xkbcomp xkeyboard-config git update

23 Mar 2012

1 files changed, 133 insertions, 116 deletions

diff --git a/xorg-server/glx/render2.c b/xorg-server/glx/render2.c
index eb7c30ba0..8cf74a691 100644
--- a/xorg-server/glx/render2.c
+++ b/xorg-server/glx/render2.c
@@ -41,138 +41,152 @@
 #include "glthread.h"
 #include "dispatch.h"
 
-
-void __glXDisp_Map1f(GLbyte *pc)
+void
+__glXDisp_Map1f(GLbyte * pc)
 {
     GLint order, k;
     GLfloat u1, u2, *points;
     GLenum target;
 
-    target = *(GLenum *)(pc + 0);
-    order = *(GLint *)(pc + 12);
-    u1 = *(GLfloat *)(pc + 4);
-    u2 = *(GLfloat *)(pc + 8);
-    points = (GLfloat *)(pc + 16);
+    target = *(GLenum *) (pc + 0);
+    order = *(GLint *) (pc + 12);
+    u1 = *(GLfloat *) (pc + 4);
+    u2 = *(GLfloat *) (pc + 8);
+    points = (GLfloat *) (pc + 16);
     k = __glMap1f_size(target);
 
-    CALL_Map1f( GET_DISPATCH(), (target, u1, u2, k, order, points) );
+    CALL_Map1f(GET_DISPATCH(), (target, u1, u2, k, order, points));
 }
 
-void __glXDisp_Map2f(GLbyte *pc)
+void
+__glXDisp_Map2f(GLbyte * pc)
 {
     GLint uorder, vorder, ustride, vstride, k;
     GLfloat u1, u2, v1, v2, *points;
     GLenum target;
 
-    target = *(GLenum *)(pc + 0);
-    uorder = *(GLint *)(pc + 12);
-    vorder = *(GLint *)(pc + 24);
-    u1 = *(GLfloat *)(pc + 4);
-    u2 = *(GLfloat *)(pc + 8);
-    v1 = *(GLfloat *)(pc + 16);
-    v2 = *(GLfloat *)(pc + 20);
-    points = (GLfloat *)(pc + 28);
+    target = *(GLenum *) (pc + 0);
+    uorder = *(GLint *) (pc + 12);
+    vorder = *(GLint *) (pc + 24);
+    u1 = *(GLfloat *) (pc + 4);
+    u2 = *(GLfloat *) (pc + 8);
+    v1 = *(GLfloat *) (pc + 16);
+    v2 = *(GLfloat *) (pc + 20);
+    points = (GLfloat *) (pc + 28);
 
     k = __glMap2f_size(target);
     ustride = vorder * k;
     vstride = k;
 
-   CALL_Map2f( GET_DISPATCH(), (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points) );
+    CALL_Map2f(GET_DISPATCH(),
+               (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder,
+                points));
 }
 
-void __glXDisp_Map1d(GLbyte *pc)
+void
+__glXDisp_Map1d(GLbyte * pc)
 {
     GLint order, k;
+
 #ifdef __GLX_ALIGN64
     GLint compsize;
 #endif
     GLenum target;
     GLdouble u1, u2, *points;
 
-    target = *(GLenum*) (pc + 16);
-    order = *(GLint*) (pc + 20);
+    target = *(GLenum *) (pc + 16);
+    order = *(GLint *) (pc + 20);
     k = __glMap1d_size(target);
 
 #ifdef __GLX_ALIGN64
     if (order < 0 || k < 0) {
-	compsize = 0;
-    } else {
-	compsize = order * k;
+        compsize = 0;
+    }
+    else {
+        compsize = order * k;
     }
 #endif
 
-    __GLX_GET_DOUBLE(u1,pc);
-    __GLX_GET_DOUBLE(u2,pc+8);
+    __GLX_GET_DOUBLE(u1, pc);
+    __GLX_GET_DOUBLE(u2, pc + 8);
     pc += 24;
 
 #ifdef __GLX_ALIGN64
-    if (((unsigned long)pc) & 7) {
-	/*
-	** Copy the doubles up 4 bytes, trashing the command but aligning
-	** the data in the process
-	*/
-	__GLX_MEM_COPY(pc-4, pc, compsize*8);
-	points = (GLdouble*) (pc - 4);
-    } else {
-	points = (GLdouble*) pc;
+    if (((unsigned long) pc) & 7) {
+        /*
+         ** Copy the doubles up 4 bytes, trashing the command but aligning
+         ** the data in the process
+         */
+        __GLX_MEM_COPY(pc - 4, pc, compsize * 8);
+        points = (GLdouble *) (pc - 4);
+    }
+    else {
+        points = (GLdouble *) pc;
     }
 #else
-    points = (GLdouble*) pc;
+    points = (GLdouble *) pc;
 #endif
-    CALL_Map1d( GET_DISPATCH(), (target, u1, u2, k, order, points) );
+    CALL_Map1d(GET_DISPATCH(), (target, u1, u2, k, order, points));
 }
 
-void __glXDisp_Map2d(GLbyte *pc)
+void
+__glXDisp_Map2d(GLbyte * pc)
 {
     GLdouble u1, u2, v1, v2, *points;
     GLint uorder, vorder, ustride, vstride, k;
+
 #ifdef __GLX_ALIGN64
     GLint compsize;
 #endif
     GLenum target;
 
-    target = *(GLenum *)(pc + 32);
-    uorder = *(GLint *)(pc + 36);
-    vorder = *(GLint *)(pc + 40);
+    target = *(GLenum *) (pc + 32);
+    uorder = *(GLint *) (pc + 36);
+    vorder = *(GLint *) (pc + 40);
     k = __glMap2d_size(target);
 
 #ifdef __GLX_ALIGN64
     if (vorder < 0 || uorder < 0 || k < 0) {
-	compsize = 0;
-    } else {
-	compsize = uorder * vorder * k;
+        compsize = 0;
+    }
+    else {
+        compsize = uorder * vorder * k;
     }
 #endif
 
-    __GLX_GET_DOUBLE(u1,pc);
-    __GLX_GET_DOUBLE(u2,pc+8);
-    __GLX_GET_DOUBLE(v1,pc+16);
-    __GLX_GET_DOUBLE(v2,pc+24);
+    __GLX_GET_DOUBLE(u1, pc);
+    __GLX_GET_DOUBLE(u2, pc + 8);
+    __GLX_GET_DOUBLE(v1, pc + 16);
+    __GLX_GET_DOUBLE(v2, pc + 24);
     pc += 44;
 
     ustride = vorder * k;
     vstride = k;
 
 #ifdef __GLX_ALIGN64
-    if (((unsigned long)pc) & 7) {
-	/*
-	** Copy the doubles up 4 bytes, trashing the command but aligning
-	** the data in the process
-	*/
-	__GLX_MEM_COPY(pc-4, pc, compsize*8);
-	points = (GLdouble*) (pc - 4);
-    } else {
-	points = (GLdouble*) pc;
+    if (((unsigned long) pc) & 7) {
+        /*
+         ** Copy the doubles up 4 bytes, trashing the command but aligning
+         ** the data in the process
+         */
+        __GLX_MEM_COPY(pc - 4, pc, compsize * 8);
+        points = (GLdouble *) (pc - 4);
+    }
+    else {
+        points = (GLdouble *) pc;
     }
 #else
-    points = (GLdouble*) pc;
+    points = (GLdouble *) pc;
 #endif
-    CALL_Map2d( GET_DISPATCH(), (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points) );
+    CALL_Map2d(GET_DISPATCH(),
+               (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder,
+                points));
 }
 
-void __glXDisp_DrawArrays(GLbyte *pc)
+void
+__glXDisp_DrawArrays(GLbyte * pc)
 {
-    __GLXdispatchDrawArraysHeader *hdr = (__GLXdispatchDrawArraysHeader *)pc;
+    __GLXdispatchDrawArraysHeader *hdr = (__GLXdispatchDrawArraysHeader *) pc;
     __GLXdispatchDrawArraysComponentHeader *compHeader;
     GLint numVertexes = hdr->numVertexes;
     GLint numComponents = hdr->numComponents;
@@ -181,73 +195,76 @@ void __glXDisp_DrawArrays(GLbyte *pc)
     int i;
 
     pc += sizeof(__GLXdispatchDrawArraysHeader);
-    compHeader = (__GLXdispatchDrawArraysComponentHeader *)pc;
+    compHeader = (__GLXdispatchDrawArraysComponentHeader *) pc;
 
     /* compute stride (same for all component arrays) */
     for (i = 0; i < numComponents; i++) {
-	GLenum datatype = compHeader[i].datatype;
-	GLint numVals = compHeader[i].numVals;
+        GLenum datatype = compHeader[i].datatype;
+        GLint numVals = compHeader[i].numVals;
 
-	stride += __GLX_PAD(numVals * __glXTypeSize(datatype));
+        stride += __GLX_PAD(numVals * __glXTypeSize(datatype));
     }
 
     pc += numComponents * sizeof(__GLXdispatchDrawArraysComponentHeader);
 
     /* set up component arrays */
     for (i = 0; i < numComponents; i++) {
-	GLenum datatype = compHeader[i].datatype;
-	GLint numVals = compHeader[i].numVals;
-	GLenum component = compHeader[i].component;
-
-	switch (component) {
-	  case GL_VERTEX_ARRAY:
-	    CALL_EnableClientState( GET_DISPATCH(), (GL_VERTEX_ARRAY) );
-	    CALL_VertexPointer( GET_DISPATCH(), (numVals, datatype, stride, pc) );
-	    break;
-	  case GL_NORMAL_ARRAY:
-	    CALL_EnableClientState( GET_DISPATCH(), (GL_NORMAL_ARRAY) );
-	    CALL_NormalPointer( GET_DISPATCH(), (datatype, stride, pc) );
-	    break;
-	  case GL_COLOR_ARRAY:
-	    CALL_EnableClientState( GET_DISPATCH(), (GL_COLOR_ARRAY) );
-	    CALL_ColorPointer( GET_DISPATCH(), (numVals, datatype, stride, pc) );
-	    break;
-	  case GL_INDEX_ARRAY:
-	    CALL_EnableClientState( GET_DISPATCH(), (GL_INDEX_ARRAY) );
-	    CALL_IndexPointer( GET_DISPATCH(), (datatype, stride, pc) );
-	    break;
-	  case GL_TEXTURE_COORD_ARRAY:
-	    CALL_EnableClientState( GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY) );
-	    CALL_TexCoordPointer( GET_DISPATCH(), (numVals, datatype, stride, pc) );
-	    break;
-	  case GL_EDGE_FLAG_ARRAY:
-	    CALL_EnableClientState( GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY) );
-	    CALL_EdgeFlagPointer( GET_DISPATCH(), (stride, (const GLboolean *)pc) );
-	    break;
-	  case GL_SECONDARY_COLOR_ARRAY:
-	    CALL_EnableClientState( GET_DISPATCH(), (GL_SECONDARY_COLOR_ARRAY) );
-	    CALL_SecondaryColorPointerEXT( GET_DISPATCH(), (numVals, datatype, stride, pc) );
-	    break;
-	  case GL_FOG_COORD_ARRAY:
-	    CALL_EnableClientState( GET_DISPATCH(), (GL_FOG_COORD_ARRAY) );
-	    CALL_FogCoordPointerEXT( GET_DISPATCH(), (datatype, stride, pc) );
-	    break;
-	  default:
-	    break;
-	}
-
-	pc += __GLX_PAD(numVals * __glXTypeSize(datatype));
+        GLenum datatype = compHeader[i].datatype;
+        GLint numVals = compHeader[i].numVals;
+        GLenum component = compHeader[i].component;
+
+        switch (component) {
+        case GL_VERTEX_ARRAY:
+            CALL_EnableClientState(GET_DISPATCH(), (GL_VERTEX_ARRAY));
+            CALL_VertexPointer(GET_DISPATCH(), (numVals, datatype, stride, pc));
+            break;
+        case GL_NORMAL_ARRAY:
+            CALL_EnableClientState(GET_DISPATCH(), (GL_NORMAL_ARRAY));
+            CALL_NormalPointer(GET_DISPATCH(), (datatype, stride, pc));
+            break;
+        case GL_COLOR_ARRAY:
+            CALL_EnableClientState(GET_DISPATCH(), (GL_COLOR_ARRAY));
+            CALL_ColorPointer(GET_DISPATCH(), (numVals, datatype, stride, pc));
+            break;
+        case GL_INDEX_ARRAY:
+            CALL_EnableClientState(GET_DISPATCH(), (GL_INDEX_ARRAY));
+            CALL_IndexPointer(GET_DISPATCH(), (datatype, stride, pc));
+            break;
+        case GL_TEXTURE_COORD_ARRAY:
+            CALL_EnableClientState(GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY));
+            CALL_TexCoordPointer(GET_DISPATCH(),
+                                 (numVals, datatype, stride, pc));
+            break;
+        case GL_EDGE_FLAG_ARRAY:
+            CALL_EnableClientState(GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY));
+            CALL_EdgeFlagPointer(GET_DISPATCH(),
+                                 (stride, (const GLboolean *) pc));
+            break;
+        case GL_SECONDARY_COLOR_ARRAY:
+            CALL_EnableClientState(GET_DISPATCH(), (GL_SECONDARY_COLOR_ARRAY));
+            CALL_SecondaryColorPointerEXT(GET_DISPATCH(),
+                                          (numVals, datatype, stride, pc));
+            break;
+        case GL_FOG_COORD_ARRAY:
+            CALL_EnableClientState(GET_DISPATCH(), (GL_FOG_COORD_ARRAY));
+            CALL_FogCoordPointerEXT(GET_DISPATCH(), (datatype, stride, pc));
+            break;
+        default:
+            break;
+        }
+
+        pc += __GLX_PAD(numVals * __glXTypeSize(datatype));
     }
 
-    CALL_DrawArrays( GET_DISPATCH(), (primType, 0, numVertexes) );
+    CALL_DrawArrays(GET_DISPATCH(), (primType, 0, numVertexes));
 
     /* turn off anything we might have turned on */
-    CALL_DisableClientState( GET_DISPATCH(), (GL_VERTEX_ARRAY) );
-    CALL_DisableClientState( GET_DISPATCH(), (GL_NORMAL_ARRAY) );
-    CALL_DisableClientState( GET_DISPATCH(), (GL_COLOR_ARRAY) );
-    CALL_DisableClientState( GET_DISPATCH(), (GL_INDEX_ARRAY) );
-    CALL_DisableClientState( GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY) );
-    CALL_DisableClientState( GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY) );
-    CALL_DisableClientState( GET_DISPATCH(), (GL_SECONDARY_COLOR_ARRAY) );
-    CALL_DisableClientState( GET_DISPATCH(), (GL_FOG_COORD_ARRAY) );
+    CALL_DisableClientState(GET_DISPATCH(), (GL_VERTEX_ARRAY));
+    CALL_DisableClientState(GET_DISPATCH(), (GL_NORMAL_ARRAY));
+    CALL_DisableClientState(GET_DISPATCH(), (GL_COLOR_ARRAY));
+    CALL_DisableClientState(GET_DISPATCH(), (GL_INDEX_ARRAY));
+    CALL_DisableClientState(GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY));
+    CALL_DisableClientState(GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY));
+    CALL_DisableClientState(GET_DISPATCH(), (GL_SECONDARY_COLOR_ARRAY));
+    CALL_DisableClientState(GET_DISPATCH(), (GL_FOG_COORD_ARRAY));
 }