libX11 xserver fontconfig mesa pixman xkbcomp xkeyboard-config git update

23 Mar 2012

1 files changed, 206 insertions, 193 deletions

diff --git a/xorg-server/glx/single2.c b/xorg-server/glx/single2.c
index 9f8254b01..42cccc148 100644
--- a/xorg-server/glx/single2.c
+++ b/xorg-server/glx/single2.c
@@ -46,7 +46,8 @@
 #include "glthread.h"
 #include "dispatch.h"
 
-int __glXDisp_FeedbackBuffer(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_FeedbackBuffer(__GLXclientState * cl, GLbyte * pc)
 {
     GLsizei size;
     GLenum type;
@@ -55,28 +56,29 @@ int __glXDisp_FeedbackBuffer(__GLXclientState *cl, GLbyte *pc)
 
     cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
     if (!cx) {
-	return error;
+        return error;
     }
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    size = *(GLsizei *)(pc+0);
-    type = *(GLenum *)(pc+4);
+    size = *(GLsizei *) (pc + 0);
+    type = *(GLenum *) (pc + 4);
     if (cx->feedbackBufSize < size) {
-	cx->feedbackBuf = (GLfloat *) realloc(cx->feedbackBuf,
-						   (size_t)size 
-						   * __GLX_SIZE_FLOAT32);
-	if (!cx->feedbackBuf) {
-	    cl->client->errorValue = size;
-	    return BadAlloc;
-	}
-	cx->feedbackBufSize = size;
+        cx->feedbackBuf = (GLfloat *) realloc(cx->feedbackBuf,
+                                              (size_t) size
+                                              * __GLX_SIZE_FLOAT32);
+        if (!cx->feedbackBuf) {
+            cl->client->errorValue = size;
+            return BadAlloc;
+        }
+        cx->feedbackBufSize = size;
     }
-    CALL_FeedbackBuffer( GET_DISPATCH(), (size, type, cx->feedbackBuf) );
+    CALL_FeedbackBuffer(GET_DISPATCH(), (size, type, cx->feedbackBuf));
     cx->hasUnflushedCommands = GL_TRUE;
     return Success;
 }
 
-int __glXDisp_SelectBuffer(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_SelectBuffer(__GLXclientState * cl, GLbyte * pc)
 {
     __GLXcontext *cx;
     GLsizei size;
@@ -84,110 +86,112 @@ int __glXDisp_SelectBuffer(__GLXclientState *cl, GLbyte *pc)
 
     cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
     if (!cx) {
-	return error;
+        return error;
     }
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    size = *(GLsizei *)(pc+0);
+    size = *(GLsizei *) (pc + 0);
     if (cx->selectBufSize < size) {
-	cx->selectBuf = (GLuint *) realloc(cx->selectBuf,
-						(size_t) size 
-						* __GLX_SIZE_CARD32);
-	if (!cx->selectBuf) {
-	    cl->client->errorValue = size;
-	    return BadAlloc;
-	}
-	cx->selectBufSize = size;
+        cx->selectBuf = (GLuint *) realloc(cx->selectBuf,
+                                           (size_t) size * __GLX_SIZE_CARD32);
+        if (!cx->selectBuf) {
+            cl->client->errorValue = size;
+            return BadAlloc;
+        }
+        cx->selectBufSize = size;
     }
-    CALL_SelectBuffer( GET_DISPATCH(), (size, cx->selectBuf) );
+    CALL_SelectBuffer(GET_DISPATCH(), (size, cx->selectBuf));
     cx->hasUnflushedCommands = GL_TRUE;
     return Success;
 }
 
-int __glXDisp_RenderMode(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_RenderMode(__GLXclientState * cl, GLbyte * pc)
 {
     ClientPtr client;
     xGLXRenderModeReply reply;
     __GLXcontext *cx;
-    GLint nitems=0, retBytes=0, retval, newModeCheck;
+    GLint nitems = 0, retBytes = 0, retval, newModeCheck;
     GLubyte *retBuffer = NULL;
     GLenum newMode;
     int error;
 
     cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
     if (!cx) {
-	return error;
+        return error;
     }
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    newMode = *(GLenum*) pc;
-    retval = CALL_RenderMode( GET_DISPATCH(), (newMode) );
+    newMode = *(GLenum *) pc;
+    retval = CALL_RenderMode(GET_DISPATCH(), (newMode));
 
     /* Check that render mode worked */
-    CALL_GetIntegerv( GET_DISPATCH(), (GL_RENDER_MODE, &newModeCheck) );
+    CALL_GetIntegerv(GET_DISPATCH(), (GL_RENDER_MODE, &newModeCheck));
     if (newModeCheck != newMode) {
-	/* Render mode change failed.  Bail */
-	newMode = newModeCheck;
-	goto noChangeAllowed;
+        /* Render mode change failed.  Bail */
+        newMode = newModeCheck;
+        goto noChangeAllowed;
     }
 
     /*
-    ** Render mode might have still failed if we get here.  But in this
-    ** case we can't really tell, nor does it matter.  If it did fail, it
-    ** will return 0, and thus we won't send any data across the wire.
-    */
+     ** Render mode might have still failed if we get here.  But in this
+     ** case we can't really tell, nor does it matter.  If it did fail, it
+     ** will return 0, and thus we won't send any data across the wire.
+     */
 
     switch (cx->renderMode) {
-      case GL_RENDER:
-	cx->renderMode = newMode;
-	break;
-      case GL_FEEDBACK:
-	if (retval < 0) {
-	    /* Overflow happened. Copy the entire buffer */
-	    nitems = cx->feedbackBufSize;
-	} else {
-	    nitems = retval;
-	}
-	retBytes = nitems * __GLX_SIZE_FLOAT32;
-	retBuffer = (GLubyte*) cx->feedbackBuf;
-	cx->renderMode = newMode;
-	break;
-      case GL_SELECT:
-	if (retval < 0) {
-	    /* Overflow happened.  Copy the entire buffer */
-	    nitems = cx->selectBufSize;
-	} else {
-	    GLuint *bp = cx->selectBuf;
-	    GLint i;
-
-	    /*
-	    ** Figure out how many bytes of data need to be sent.  Parse
-	    ** the selection buffer to determine this fact as the
-	    ** return value is the number of hits, not the number of
-	    ** items in the buffer.
-	    */
-	    nitems = 0;
-	    i = retval;
-	    while (--i >= 0) {
-		GLuint n;
-
-		/* Parse select data for this hit */
-		n = *bp;
-		bp += 3 + n;
-	    }
-	    nitems = bp - cx->selectBuf;
-	}
-	retBytes = nitems * __GLX_SIZE_CARD32;
-	retBuffer = (GLubyte*) cx->selectBuf;
-	cx->renderMode = newMode;
-	break;
+    case GL_RENDER:
+        cx->renderMode = newMode;
+        break;
+    case GL_FEEDBACK:
+        if (retval < 0) {
+            /* Overflow happened. Copy the entire buffer */
+            nitems = cx->feedbackBufSize;
+        }
+        else {
+            nitems = retval;
+        }
+        retBytes = nitems * __GLX_SIZE_FLOAT32;
+        retBuffer = (GLubyte *) cx->feedbackBuf;
+        cx->renderMode = newMode;
+        break;
+    case GL_SELECT:
+        if (retval < 0) {
+            /* Overflow happened.  Copy the entire buffer */
+            nitems = cx->selectBufSize;
+        }
+        else {
+            GLuint *bp = cx->selectBuf;
+            GLint i;
+
+            /*
+             ** Figure out how many bytes of data need to be sent.  Parse
+             ** the selection buffer to determine this fact as the
+             ** return value is the number of hits, not the number of
+             ** items in the buffer.
+             */
+            nitems = 0;
+            i = retval;
+            while (--i >= 0) {
+                GLuint n;
+
+                /* Parse select data for this hit */
+                n = *bp;
+                bp += 3 + n;
+            }
+            nitems = bp - cx->selectBuf;
+        }
+        retBytes = nitems * __GLX_SIZE_CARD32;
+        retBuffer = (GLubyte *) cx->selectBuf;
+        cx->renderMode = newMode;
+        break;
     }
 
     /*
-    ** First reply is the number of elements returned in the feedback or
-    ** selection array, as per the API for glRenderMode itself.
-    */
-  noChangeAllowed:;
+     ** First reply is the number of elements returned in the feedback or
+     ** selection array, as per the API for glRenderMode itself.
+     */
+ noChangeAllowed:;
     client = cl->client;
     reply.length = nitems;
     reply.type = X_Reply;
@@ -195,29 +199,31 @@ int __glXDisp_RenderMode(__GLXclientState *cl, GLbyte *pc)
     reply.retval = retval;
     reply.size = nitems;
     reply.newMode = newMode;
-    WriteToClient(client, sz_xGLXRenderModeReply, (char *)&reply);
+    WriteToClient(client, sz_xGLXRenderModeReply, (char *) &reply);
     if (retBytes) {
-	WriteToClient(client, retBytes, (char *)retBuffer);
+        WriteToClient(client, retBytes, (char *) retBuffer);
     }
     return Success;
 }
 
-int __glXDisp_Flush(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_Flush(__GLXclientState * cl, GLbyte * pc)
 {
-	__GLXcontext *cx;
-	int error;
+    __GLXcontext *cx;
+    int error;
 
-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
-	if (!cx) {
-		return error;
-	}
+    cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
+    if (!cx) {
+        return error;
+    }
 
-	CALL_Flush( GET_DISPATCH(), () );
-	cx->hasUnflushedCommands = GL_FALSE;
-	return Success;
+    CALL_Flush(GET_DISPATCH(), ());
+    cx->hasUnflushedCommands = GL_FALSE;
+    return Success;
 }
 
-int __glXDisp_Finish(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_Finish(__GLXclientState * cl, GLbyte * pc)
 {
     __GLXcontext *cx;
     ClientPtr client;
@@ -225,11 +231,11 @@ int __glXDisp_Finish(__GLXclientState *cl, GLbyte *pc)
 
     cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
     if (!cx) {
-	return error;
+        return error;
     }
 
     /* Do a local glFinish */
-    CALL_Finish( GET_DISPATCH(), () );
+    CALL_Finish(GET_DISPATCH(), ());
     cx->hasUnflushedCommands = GL_FALSE;
 
     /* Send empty reply packet to indicate finish is finished */
@@ -241,75 +247,83 @@ int __glXDisp_Finish(__GLXclientState *cl, GLbyte *pc)
 
 #define SEPARATOR " "
 
-char *__glXcombine_strings(const char *cext_string, const char *sext_string)
+char *
+__glXcombine_strings(const char *cext_string, const char *sext_string)
 {
-   size_t clen, slen;
-   char *combo_string, *token, *s1;
-   const char *s2, *end;
-
-   /* safeguard to prevent potentially fatal errors in the string functions */
-   if (!cext_string)
-      cext_string = "";
-   if (!sext_string)
-      sext_string = "";
-
-   /*
-   ** String can't be longer than min(cstring, sstring)
-   ** pull tokens out of shortest string
-   ** include space in combo_string for final separator and null terminator
-   */
-   clen = strlen(cext_string);
-   slen = strlen(sext_string);
-   if (clen > slen) {
-	combo_string = (char *) malloc(slen + 2);
-	s1 = (char *) malloc(slen + 2);
-	if (s1) strcpy(s1, sext_string);
-	s2 = cext_string;
-   } else {
-	combo_string = (char *) malloc(clen + 2);
-	s1 = (char *) malloc(clen + 2);
-	if (s1) strcpy(s1, cext_string);
-	s2 = sext_string;
-   }
-   if (!combo_string || !s1) {
-	free(combo_string);
-	free(s1);
-	return NULL;
-   }
-   combo_string[0] = '\0';
-
-   /* Get first extension token */
-   token = strtok( s1, SEPARATOR);
-   while ( token != NULL ) {
-
-	/*
-	** if token in second string then save it
-	** beware of extension names which are prefixes of other extension names
-	*/
-	const char *p = s2;
-	end = p + strlen(p);
-	while (p < end) {
-	    size_t n = strcspn(p, SEPARATOR);
-	    if ((strlen(token) == n) && (strncmp(token, p, n) == 0)) {
-		combo_string = strcat(combo_string, token);
-		combo_string = strcat(combo_string, SEPARATOR);
-	    }
-	    p += (n + 1);
-	}
-
-	/* Get next extension token */
-	token = strtok( NULL, SEPARATOR);
-   }
-   free(s1);
-   return combo_string;
+    size_t clen, slen;
+    char *combo_string, *token, *s1;
+    const char *s2, *end;
+
+    /* safeguard to prevent potentially fatal errors in the string functions */
+    if (!cext_string)
+        cext_string = "";
+    if (!sext_string)
+        sext_string = "";
+
+    /*
+     ** String can't be longer than min(cstring, sstring)
+     ** pull tokens out of shortest string
+     ** include space in combo_string for final separator and null terminator
+     */
+    clen = strlen(cext_string);
+    slen = strlen(sext_string);
+    if (clen > slen) {
+        combo_string = (char *) malloc(slen + 2);
+        s1 = (char *) malloc(slen + 2);
+        if (s1)
+            strcpy(s1, sext_string);
+        s2 = cext_string;
+    }
+    else {
+        combo_string = (char *) malloc(clen + 2);
+        s1 = (char *) malloc(clen + 2);
+        if (s1)
+            strcpy(s1, cext_string);
+        s2 = sext_string;
+    }
+    if (!combo_string || !s1) {
+        free(combo_string);
+        free(s1);
+        return NULL;
+    }
+    combo_string[0] = '\0';
+
+    /* Get first extension token */
+    token = strtok(s1, SEPARATOR);
+    while (token != NULL) {
+
+        /*
+         ** if token in second string then save it
+         ** beware of extension names which are prefixes of other extension names
+         */
+        const char *p = s2;
+
+        end = p + strlen(p);
+        while (p < end) {
+            size_t n = strcspn(p, SEPARATOR);
+
+            if ((strlen(token) == n) && (strncmp(token, p, n) == 0)) {
+                combo_string = strcat(combo_string, token);
+                combo_string = strcat(combo_string, SEPARATOR);
+            }
+            p += (n + 1);
+        }
+
+        /* Get next extension token */
+        token = strtok(NULL, SEPARATOR);
+    }
+    free(s1);
+    return combo_string;
 }
 
-int DoGetString(__GLXclientState *cl, GLbyte *pc, GLboolean need_swap)
+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;
@@ -318,67 +332,66 @@ int DoGetString(__GLXclientState *cl, GLbyte *pc, GLboolean need_swap)
     /* 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);
+    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;
+        return error;
     }
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    name = *(GLenum *)(pc + 0);
-    string = (const char *) CALL_GetString( GET_DISPATCH(), (name) );
+    name = *(GLenum *) (pc + 0);
+    string = (const char *) CALL_GetString(GET_DISPATCH(), (name));
     client = cl->client;
 
     if (string == NULL)
-      string = "";
+        string = "";
 
     /*
-    ** 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.
-    */
+     ** 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);
-	free(buf1);
-	string = buf;
+        buf1 = __glXcombine_strings(string, cl->GLClientextensions);
+        buf = __glXcombine_strings(buf1, cx->pGlxScreen->GLextensions);
+        free(buf1);
+        string = buf;
     }
-    else if ( name == GL_VERSION ) {
-	if ( atof( string ) > atof( GLServerVersion ) ) {
-	    if ( asprintf( &buf, "%s (%s)", GLServerVersion, string ) == -1) {
-		string = GLServerVersion;
-	    }
-	    else {
-		string = buf;
-	    }
-	}
+    else if (name == GL_VERSION) {
+        if (atof(string) > atof(GLServerVersion)) {
+            if (asprintf(&buf, "%s (%s)", GLServerVersion, string) == -1) {
+                string = GLServerVersion;
+            }
+            else {
+                string = buf;
+            }
+        }
     }
     if (string) {
-	length = strlen((const char *) string) + 1;
+        length = strlen((const char *) string) + 1;
     }
 
     __GLX_BEGIN_REPLY(length);
     __GLX_PUT_SIZE(length);
 
-    if ( need_swap ) {
-	__GLX_SWAP_REPLY_SIZE();
-	__GLX_SWAP_REPLY_HEADER();
+    if (need_swap) {
+        __GLX_SWAP_REPLY_SIZE();
+        __GLX_SWAP_REPLY_HEADER();
     }
 
     __GLX_SEND_HEADER();
-    WriteToClient(client, length, (char *) string); 
+    WriteToClient(client, length, (char *) string);
     free(buf);
 
     return Success;
 }
 
-int __glXDisp_GetString(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetString(__GLXclientState * cl, GLbyte * pc)
 {
     return DoGetString(cl, pc, GL_FALSE);
 }