Introduce a consistent coding style

This is strictly the application of the script 'x-indent-all.sh'
from util/modular. Compared to the patch that Daniel posted in
January, I've added a few indent flags:

	-bap
	-psl
	-T PrivatePtr
	-T pmWait
	-T _XFUNCPROTOBEGIN
	-T _XFUNCPROTOEND
	-T _X_EXPORT

The typedefs were needed to make the output of sdksyms.sh match the
previous output, otherwise, the code is formatted badly enough that
sdksyms.sh generates incorrect output.

The generated code was compared with the previous version and found to
be essentially identical -- "assert" line numbers and BUILD_TIME were
the only differences found.

The comparison was done with this script:

dir1=$1
dir2=$2

for dir in $dir1 $dir2; do
	(cd $dir && find . -name '*.o' | while read file; do
		dir=`dirname $file`
		base=`basename $file .o`
		dump=$dir/$base.dump
		objdump -d $file > $dump
	done)
done

find $dir1 -name '*.dump' | while read dump; do
	otherdump=`echo $dump | sed "s;$dir1;$dir2;"`
	diff -u $dump $otherdump
done

Signed-off-by: Keith Packard <keithp@keithp.com>
Acked-by: Daniel Stone <daniel@fooishbar.org>
Acked-by: Alan Coopersmith <alan.coopersmith@oracle.com>

1 files changed, 206 insertions, 193 deletions

diff --git a/glx/single2.c b/glx/single2.c
index 9f8254b01..42cccc148 100644
--- a/glx/single2.c
+++ b/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);
 }