glx: indent -br -i3 -npcs --no-tabs packrender.h

1 files changed, 121 insertions, 121 deletions

diff --git a/src/glx/x11/packrender.h b/src/glx/x11/packrender.h
index 82f82515a6..6db6ea721f 100644
--- a/src/glx/x11/packrender.h
+++ b/src/glx/x11/packrender.h
@@ -49,23 +49,23 @@
 #define __GLX_PAD(a) (((a)+3) & ~3)
 
 /*
- ** Network size parameters
- */
+** Network size parameters
+*/
 #define sz_double 8
 
 /* Setup for all commands */
-#define __GLX_DECLARE_VARIABLES() \
-    __GLXcontext *gc;		  \
-    GLubyte *pc, *pixelHeaderPC;  \
-    GLuint compsize, cmdlen
-
-#define __GLX_LOAD_VARIABLES()	   \
-    gc = __glXGetCurrentContext(); \
-    pc = gc->pc;                   \
-    /* Muffle compilers */		    \
-    cmdlen = 0;         (void)cmdlen;	    \
-    compsize = 0;       (void)compsize;	    \
-    pixelHeaderPC = 0;  (void)pixelHeaderPC
+#define __GLX_DECLARE_VARIABLES()               \
+   __GLXcontext *gc;                            \
+   GLubyte *pc, *pixelHeaderPC;                 \
+   GLuint compsize, cmdlen
+
+#define __GLX_LOAD_VARIABLES()     \
+   gc = __glXGetCurrentContext();  \
+   pc = gc->pc;                    \
+   /* Muffle compilers */                  \
+   cmdlen = 0;         (void)cmdlen;          \
+   compsize = 0;       (void)compsize;        \
+   pixelHeaderPC = 0;  (void)pixelHeaderPC
 
 /*
 ** Variable sized command support macro.  This macro is used by calls
@@ -74,53 +74,53 @@
 ** If the buffer can't hold the command then it is flushed so that
 ** the command will fit in the next buffer.
 */
-#define __GLX_BEGIN_VARIABLE(opcode,size)	\
-    if (pc + (size) > gc->bufEnd) {		\
-	pc = __glXFlushRenderBuffer(gc, pc);	\
-    }						\
-    __GLX_PUT_SHORT(0,size);			\
-    __GLX_PUT_SHORT(2,opcode)
-
-#define __GLX_BEGIN_VARIABLE_LARGE(opcode,size)	\
-    pc = __glXFlushRenderBuffer(gc, pc);	\
-    __GLX_PUT_LONG(0,size);			\
-    __GLX_PUT_LONG(4,opcode)
-
-#define __GLX_BEGIN_VARIABLE_WITH_PIXEL(opcode,size) \
-    if (pc + (size) > gc->bufEnd) {		     \
-	pc = __glXFlushRenderBuffer(gc, pc);	     \
-    }						     \
-    __GLX_PUT_SHORT(0,size);			     \
-    __GLX_PUT_SHORT(2,opcode);			     \
-    pc += __GLX_RENDER_HDR_SIZE;		     \
-    pixelHeaderPC = pc;				     \
-    pc += __GLX_PIXEL_HDR_SIZE
-
-#define __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(opcode,size) \
-    pc = __glXFlushRenderBuffer(gc, pc);		   \
-    __GLX_PUT_LONG(0,size);				   \
-    __GLX_PUT_LONG(4,opcode);				   \
-    pc += __GLX_RENDER_LARGE_HDR_SIZE;			   \
-    pixelHeaderPC = pc;					   \
-    pc += __GLX_PIXEL_HDR_SIZE
-
-#define __GLX_BEGIN_VARIABLE_WITH_PIXEL_3D(opcode,size) \
-    if (pc + (size) > gc->bufEnd) {		        \
-	pc = __glXFlushRenderBuffer(gc, pc); 	        \
-    }						        \
-    __GLX_PUT_SHORT(0,size);			        \
-    __GLX_PUT_SHORT(2,opcode);			        \
-    pc += __GLX_RENDER_HDR_SIZE;		        \
-    pixelHeaderPC = pc;				        \
-    pc += __GLX_PIXEL_3D_HDR_SIZE
-
-#define __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL_3D(opcode,size) \
-    pc = __glXFlushRenderBuffer(gc, pc);	   	      \
-    __GLX_PUT_LONG(0,size);				      \
-    __GLX_PUT_LONG(4,opcode);				      \
-    pc += __GLX_RENDER_LARGE_HDR_SIZE;			      \
-    pixelHeaderPC = pc;					      \
-    pc += __GLX_PIXEL_3D_HDR_SIZE
+#define __GLX_BEGIN_VARIABLE(opcode,size)       \
+   if (pc + (size) > gc->bufEnd) {              \
+      pc = __glXFlushRenderBuffer(gc, pc);      \
+   }                                            \
+   __GLX_PUT_SHORT(0,size);                     \
+   __GLX_PUT_SHORT(2,opcode)
+
+#define __GLX_BEGIN_VARIABLE_LARGE(opcode,size) \
+   pc = __glXFlushRenderBuffer(gc, pc);         \
+   __GLX_PUT_LONG(0,size);                      \
+   __GLX_PUT_LONG(4,opcode)
+
+#define __GLX_BEGIN_VARIABLE_WITH_PIXEL(opcode,size)  \
+   if (pc + (size) > gc->bufEnd) {                    \
+      pc = __glXFlushRenderBuffer(gc, pc);            \
+   }                                                  \
+   __GLX_PUT_SHORT(0,size);                           \
+   __GLX_PUT_SHORT(2,opcode);                         \
+   pc += __GLX_RENDER_HDR_SIZE;                       \
+   pixelHeaderPC = pc;                                \
+   pc += __GLX_PIXEL_HDR_SIZE
+
+#define __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(opcode,size)  \
+   pc = __glXFlushRenderBuffer(gc, pc);                     \
+   __GLX_PUT_LONG(0,size);                                  \
+   __GLX_PUT_LONG(4,opcode);                                \
+   pc += __GLX_RENDER_LARGE_HDR_SIZE;                       \
+   pixelHeaderPC = pc;                                      \
+   pc += __GLX_PIXEL_HDR_SIZE
+
+#define __GLX_BEGIN_VARIABLE_WITH_PIXEL_3D(opcode,size)  \
+   if (pc + (size) > gc->bufEnd) {                       \
+      pc = __glXFlushRenderBuffer(gc, pc);               \
+   }                                                     \
+   __GLX_PUT_SHORT(0,size);                              \
+   __GLX_PUT_SHORT(2,opcode);                            \
+   pc += __GLX_RENDER_HDR_SIZE;                          \
+   pixelHeaderPC = pc;                                   \
+   pc += __GLX_PIXEL_3D_HDR_SIZE
+
+#define __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL_3D(opcode,size)  \
+   pc = __glXFlushRenderBuffer(gc, pc);                        \
+   __GLX_PUT_LONG(0,size);                                     \
+   __GLX_PUT_LONG(4,opcode);                                   \
+   pc += __GLX_RENDER_LARGE_HDR_SIZE;                          \
+   pixelHeaderPC = pc;                                         \
+   pc += __GLX_PIXEL_3D_HDR_SIZE
 
 /*
 ** Fixed size command support macro.  This macro is used by calls that
@@ -130,8 +130,8 @@
 ** before doing the storage work.
 */
 #define __GLX_BEGIN(opcode,size) \
-    __GLX_PUT_SHORT(0,size);     \
-    __GLX_PUT_SHORT(2,opcode)
+   __GLX_PUT_SHORT(0,size);      \
+   __GLX_PUT_SHORT(2,opcode)
 
 /*
 ** Finish a rendering command by advancing the pc.  If the pc is now past
@@ -141,52 +141,52 @@
 ** rendering buffer is flushed out into the X protocol stream (which may
 ** or may not do I/O).
 */
-#define __GLX_END(size)			       \
-    pc += size;				       \
-    if (pc > gc->limit) {		       \
-	(void) __glXFlushRenderBuffer(gc, pc); \
-    } else {				       \
-	gc->pc = pc;			       \
-    }
+#define __GLX_END(size)           \
+   pc += size;                       \
+   if (pc > gc->limit) {                  \
+      (void) __glXFlushRenderBuffer(gc, pc);    \
+   } else {                                     \
+      gc->pc = pc;                              \
+   }
 
 /* Array copy macros */
-#define __GLX_MEM_COPY(dest,src,bytes) \
-    if (src && dest) \
-    	memcpy(dest, src, bytes)
+#define __GLX_MEM_COPY(dest,src,bytes)          \
+   if (src && dest)                             \
+      memcpy(dest, src, bytes)
 
 /* Single item copy macros */
-#define __GLX_PUT_CHAR(offset,a) \
-    *((INT8 *) (pc + offset)) = a
+#define __GLX_PUT_CHAR(offset,a)                \
+   *((INT8 *) (pc + offset)) = a
 
 #ifndef _CRAY
-#define __GLX_PUT_SHORT(offset,a) \
-    *((INT16 *) (pc + offset)) = a
+#define __GLX_PUT_SHORT(offset,a)               \
+   *((INT16 *) (pc + offset)) = a
 
-#define __GLX_PUT_LONG(offset,a) \
-    *((INT32 *) (pc + offset)) = a
+#define __GLX_PUT_LONG(offset,a)                \
+   *((INT32 *) (pc + offset)) = a
 
-#define __GLX_PUT_FLOAT(offset,a) \
-    *((FLOAT32 *) (pc + offset)) = a
+#define __GLX_PUT_FLOAT(offset,a)               \
+   *((FLOAT32 *) (pc + offset)) = a
 
 #else
-#define __GLX_PUT_SHORT(offset,a) \
- { GLubyte *cp = (pc+offset); \
-   int shift = (64-16) - ((int)(cp) >> (64-6)); \
-   *(int *)cp = (*(int *)cp & ~(0xffff << shift)) | ((a & 0xffff) << shift); }
+#define __GLX_PUT_SHORT(offset,a)               \
+   { GLubyte *cp = (pc+offset);                 \
+      int shift = (64-16) - ((int)(cp) >> (64-6));                      \
+      *(int *)cp = (*(int *)cp & ~(0xffff << shift)) | ((a & 0xffff) << shift); }
 
-#define __GLX_PUT_LONG(offset,a) \
- { GLubyte *cp = (pc+offset); \
-   int shift = (64-32) - ((int)(cp) >> (64-6)); \
-   *(int *)cp = (*(int *)cp & ~(0xffffffff << shift)) | ((a & 0xffffffff) << shift); }
+#define __GLX_PUT_LONG(offset,a)                \
+   { GLubyte *cp = (pc+offset);                 \
+      int shift = (64-32) - ((int)(cp) >> (64-6));                      \
+      *(int *)cp = (*(int *)cp & ~(0xffffffff << shift)) | ((a & 0xffffffff) << shift); }
 
-#define __GLX_PUT_FLOAT(offset,a) \
-    gl_put_float((pc + offset),a)
+#define __GLX_PUT_FLOAT(offset,a)               \
+   gl_put_float((pc + offset),a)
 
-#define __GLX_PUT_DOUBLE(offset,a) \
-    gl_put_double(pc + offset, a)
+#define __GLX_PUT_DOUBLE(offset,a)              \
+   gl_put_double(pc + offset, a)
 
-extern void gl_put_float(/*GLubyte *, struct cray_single*/);
-extern void gl_put_double(/*GLubyte *, struct cray_double*/);
+extern void gl_put_float( /*GLubyte *, struct cray_single */ );
+extern void gl_put_double( /*GLubyte *, struct cray_double */ );
 #endif
 
 #ifndef _CRAY
@@ -196,48 +196,48 @@ extern void gl_put_double(/*GLubyte *, struct cray_double*/);
 ** This can certainly be done better for a particular machine
 ** architecture!
 */
-#define __GLX_PUT_DOUBLE(offset,a) \
-    __GLX_MEM_COPY(pc + offset, &a, 8)
+#define __GLX_PUT_DOUBLE(offset,a)              \
+   __GLX_MEM_COPY(pc + offset, &a, 8)
 #else
-#define __GLX_PUT_DOUBLE(offset,a) \
-    *((FLOAT64 *) (pc + offset)) = a
+#define __GLX_PUT_DOUBLE(offset,a)              \
+   *((FLOAT64 *) (pc + offset)) = a
 #endif
 
 #endif
 
-#define __GLX_PUT_CHAR_ARRAY(offset,a,alen) \
-    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT8)
+#define __GLX_PUT_CHAR_ARRAY(offset,a,alen)                 \
+   __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT8)
 
 #ifndef _CRAY
-#define __GLX_PUT_SHORT_ARRAY(offset,a,alen) \
-    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT16)
+#define __GLX_PUT_SHORT_ARRAY(offset,a,alen)                \
+   __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT16)
 
-#define __GLX_PUT_LONG_ARRAY(offset,a,alen) \
-    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT32)
+#define __GLX_PUT_LONG_ARRAY(offset,a,alen)                 \
+   __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT32)
 
-#define __GLX_PUT_FLOAT_ARRAY(offset,a,alen) \
-    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_FLOAT32)
+#define __GLX_PUT_FLOAT_ARRAY(offset,a,alen)                   \
+   __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_FLOAT32)
 
-#define __GLX_PUT_DOUBLE_ARRAY(offset,a,alen) \
-    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_FLOAT64)
+#define __GLX_PUT_DOUBLE_ARRAY(offset,a,alen)                  \
+   __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_FLOAT64)
 
 #else
-#define __GLX_PUT_SHORT_ARRAY(offset,a,alen) \
-    gl_put_short_array((GLubyte *)(pc + offset), a, alen * __GLX_SIZE_INT16)
+#define __GLX_PUT_SHORT_ARRAY(offset,a,alen)                            \
+   gl_put_short_array((GLubyte *)(pc + offset), a, alen * __GLX_SIZE_INT16)
 
-#define __GLX_PUT_LONG_ARRAY(offset,a,alen) \
-    gl_put_long_array((GLubyte *)(pc + offset), (long *)a, alen * __GLX_SIZE_INT32)
+#define __GLX_PUT_LONG_ARRAY(offset,a,alen)                             \
+   gl_put_long_array((GLubyte *)(pc + offset), (long *)a, alen * __GLX_SIZE_INT32)
 
-#define __GLX_PUT_FLOAT_ARRAY(offset,a,alen) \
-    gl_put_float_array((GLubyte *)(pc + offset), (float *)a, alen * __GLX_SIZE_FLOAT32)
+#define __GLX_PUT_FLOAT_ARRAY(offset,a,alen)                            \
+   gl_put_float_array((GLubyte *)(pc + offset), (float *)a, alen * __GLX_SIZE_FLOAT32)
 
-#define __GLX_PUT_DOUBLE_ARRAY(offset,a,alen) \
-    gl_put_double_array((GLubyte *)(pc + offset), (double *)a, alen * __GLX_SIZE_FLOAT64)
+#define __GLX_PUT_DOUBLE_ARRAY(offset,a,alen)                           \
+   gl_put_double_array((GLubyte *)(pc + offset), (double *)a, alen * __GLX_SIZE_FLOAT64)
 
-extern gl_put_short_array (GLubyte *, short *, int);
-extern gl_put_long_array (GLubyte *, long *, int);
-extern gl_put_float_array (GLubyte *, float *, int);
-extern gl_put_double_array (GLubyte *, double *, int);
+extern gl_put_short_array(GLubyte *, short *, int);
+extern gl_put_long_array(GLubyte *, long *, int);
+extern gl_put_float_array(GLubyte *, float *, int);
+extern gl_put_double_array(GLubyte *, double *, int);
 
 #endif /* _CRAY */