libX11 xserver fontconfig mesa pixman xkbcomp xkeyboard-config git update

23 Mar 2012

1 files changed, 293 insertions, 310 deletions

diff --git a/xorg-server/glx/indirect_util.c b/xorg-server/glx/indirect_util.c
index d00523249..a54f70aee 100644
--- a/xorg-server/glx/indirect_util.c
+++ b/xorg-server/glx/indirect_util.c
@@ -1,310 +1,293 @@
-/*

- * (C) Copyright IBM Corporation 2005

- * All Rights Reserved.

- * 

- * Permission is hereby granted, free of charge, to any person obtaining a

- * copy of this software and associated documentation files (the "Software"),

- * to deal in the Software without restriction, including without limitation

- * the rights to use, copy, modify, merge, publish, distribute, sub license,

- * and/or sell copies of the Software, and to permit persons to whom the

- * Software is furnished to do so, subject to the following conditions:

- * 

- * The above copyright notice and this permission notice (including the next

- * paragraph) shall be included in all copies or substantial portions of the

- * Software.

- * 

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL

- * IBM,

- * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

- * SOFTWARE.

- */

-

-#ifdef HAVE_DIX_CONFIG_H

-#include <dix-config.h>

-#endif

-

-#include <string.h>

-

-#include <X11/Xmd.h>

-#include <GL/gl.h>

-#include <GL/glxproto.h>

-#include <inttypes.h>

-#include "indirect_size.h"

-#include "indirect_size_get.h"

-#include "indirect_dispatch.h"

-#include "glxserver.h"

-#include "glxbyteorder.h"

-#include "singlesize.h"

-#include "glapitable.h"

-#include "glapi.h"

-#include "glthread.h"

-#include "dispatch.h"

-#include "glxext.h"

-#include "indirect_table.h"

-#include "indirect_util.h"

-

-

-#define __GLX_PAD(a) (((a)+3)&~3)

-

-extern xGLXSingleReply __glXReply;

-

-

-GLint

-__glGetBooleanv_variable_size( GLenum e )

-{

-    if ( e == GL_COMPRESSED_TEXTURE_FORMATS ) {

-	GLint temp;

-

-	CALL_GetIntegerv( GET_DISPATCH(),

-			  (GL_NUM_COMPRESSED_TEXTURE_FORMATS, & temp) );

-	return temp;

-    }

-    else {

-	return 0;

-    }

-}

-

-

-/**

- * Get a properly aligned buffer to hold reply data.

- *

- * \warning

- * This function assumes that \c local_buffer is already properly aligned.

- * It also assumes that \c alignment is a power of two.

- */

-void *

-__glXGetAnswerBuffer( __GLXclientState * cl, size_t required_size,

-    void * local_buffer, size_t local_size, unsigned alignment )

-{

-    void * buffer = local_buffer;

-    const unsigned mask = alignment - 1;

-

-    if ( local_size < required_size ) {

-        const size_t worst_case_size = required_size + alignment;

-        intptr_t  temp_buf;

-

-        if ( cl->returnBufSize < worst_case_size ) {

-	    void * temp = realloc( cl->returnBuf, worst_case_size );

-	    

-	    if ( temp == NULL ) {

-	        return NULL;

-	    }

-	    

-	    cl->returnBuf = temp;

-	    cl->returnBufSize = worst_case_size;

-	}

-	

-	temp_buf = (intptr_t) cl->returnBuf;

-	temp_buf = (temp_buf + mask) & ~mask;

-	buffer = (void *) temp_buf;

-    }

-

-    return buffer;

-}

-

-

-/**

- * Send a GLX reply to the client.

- *

- * Technically speaking, there are several different ways to encode a GLX

- * reply.  The primary difference is whether or not certain fields (e.g.,

- * retval, size, and "pad3") are set.  This function gets around that by

- * always setting all of the fields to "reasonable" values.  This does no

- * harm to clients, but it does make the server-side code much more compact.

- */

-void

-__glXSendReply( ClientPtr client, const void * data, size_t elements,

-    size_t element_size, GLboolean always_array, CARD32 retval )

-{

-    size_t reply_ints = 0;

-

-    if ( __glXErrorOccured() ) {

-        elements = 0;

-    }

-    else if ( (elements > 1) || always_array ) {

-        reply_ints = bytes_to_int32(elements * element_size);

-    }

-

-    __glXReply.length =         reply_ints;

-    __glXReply.type =           X_Reply;

-    __glXReply.sequenceNumber = client->sequence;

-    __glXReply.size =           elements;

-    __glXReply.retval =         retval;

-

-

-    /* It is faster on almost always every architecture to just copy the 8

-     * bytes, even when not necessary, than check to see of the value of

-     * elements requires it.  Copying the data when not needed will do no

-     * harm.

-     */

-

-    (void) memcpy( & __glXReply.pad3, data, 8 );

-    WriteToClient( client, sz_xGLXSingleReply, (char *) & __glXReply );

-

-    if ( reply_ints != 0 ) {

-        WriteToClient( client, reply_ints * 4, (char *) data );

-    }

-}

-

-

-/**

- * Send a GLX reply to the client.

- *

- * Technically speaking, there are several different ways to encode a GLX

- * reply.  The primary difference is whether or not certain fields (e.g.,

- * retval, size, and "pad3") are set.  This function gets around that by

- * always setting all of the fields to "reasonable" values.  This does no

- * harm to clients, but it does make the server-side code much more compact.

- *

- * \warning

- * This function assumes that values stored in \c data will be byte-swapped

- * by the caller if necessary.

- */

-void

-__glXSendReplySwap( ClientPtr client, const void * data, size_t elements,

-    size_t element_size, GLboolean always_array, CARD32 retval )

-{

-    size_t reply_ints = 0;

-

-    if ( __glXErrorOccured() ) {

-        elements = 0;

-    }

-    else if ( (elements > 1) || always_array ) {

-        reply_ints = bytes_to_int32(elements * element_size);

-    }

-

-    __glXReply.length =         bswap_32( reply_ints );

-    __glXReply.type =           X_Reply;

-    __glXReply.sequenceNumber = bswap_16( client->sequence );

-    __glXReply.size =           bswap_32( elements );

-    __glXReply.retval =         bswap_32( retval );

-

-

-    /* It is faster on almost always every architecture to just copy the 8

-     * bytes, even when not necessary, than check to see of the value of

-     * elements requires it.  Copying the data when not needed will do no

-     * harm.

-     */

-

-    (void) memcpy( & __glXReply.pad3, data, 8 );

-    WriteToClient( client, sz_xGLXSingleReply, (char *) & __glXReply );

-

-    if ( reply_ints != 0 ) {

-        WriteToClient( client, reply_ints * 4, (char *) data );

-    }

-}

-

-

-static int

-get_decode_index(const struct __glXDispatchInfo *dispatch_info,

-		 unsigned opcode)

-{

-    int remaining_bits;

-    int next_remain;

-    const int_fast16_t * const tree = dispatch_info->dispatch_tree;

-    int_fast16_t index;

-

-

-    remaining_bits = dispatch_info->bits;

-    if (opcode >= (1U << remaining_bits)) {

-	return -1;

-    }

-    

-    index = 0;

-    for (/* empty */; remaining_bits > 0; remaining_bits = next_remain) {

-	unsigned mask;

-	unsigned child_index;

-

-

-	/* Calculate the slice of bits used by this node.

-	 * 

-	 * If remaining_bits = 8 and tree[index] = 3, the mask of just the

-	 * remaining bits is 0x00ff and the mask for the remaining bits after

-	 * this node is 0x001f.  By taking 0x00ff & ~0x001f, we get 0x00e0.

-	 * This masks the 3 bits that we would want for this node.

-	 */

-

-	next_remain = remaining_bits - tree[index];

-	mask = ((1 << remaining_bits) - 1) &

-	  ~((1 << next_remain) - 1);

-

-

-	/* Using the mask, calculate the index of the opcode in the node.

-	 * With that index, fetch the index of the next node.

-	 */

-

-	child_index = (opcode & mask) >> next_remain;

-	index = tree[index + 1 + child_index];

-

-

-	/* If the next node is an empty leaf, the opcode is for a non-existant

-	 * function.  We're done.

-	 *

-	 * If the next node is a non-empty leaf, look up the function pointer

-	 * and return it.

-	 */

-

-	if (index == EMPTY_LEAF) {

-	    return -1;

-	}

-	else if (IS_LEAF_INDEX(index)) {

-	    unsigned func_index;

-

-

-	    /* The value stored in the tree for a leaf node is the base of

-	     * the function pointers for that leaf node.  The offset for the

-	     * function for a particular opcode is the remaining bits in the

-	     * opcode.

-	     */

-

-	    func_index = -index;

-	    func_index += opcode & ((1 << next_remain) - 1);

-	    return func_index;

-	}

-    }

-

-    /* We should *never* get here!!!

-     */

-    return -1;

-}

-

-

-void *

-__glXGetProtocolDecodeFunction(const struct __glXDispatchInfo *dispatch_info,

-			       int opcode, int swapped_version)

-{

-    const int func_index = get_decode_index(dispatch_info, opcode);

-

-    return (func_index < 0) 

-	? NULL 

-	: (void *) dispatch_info->dispatch_functions[func_index][swapped_version];

-}

-

-

-int

-__glXGetProtocolSizeData(const struct __glXDispatchInfo *dispatch_info,

-			 int opcode, __GLXrenderSizeData *data)

-{

-    if (dispatch_info->size_table != NULL) {

-	const int func_index = get_decode_index(dispatch_info, opcode);

-

-	if ((func_index >= 0) 

-	    && (dispatch_info->size_table[func_index][0] != 0)) {

-	    const int var_offset = 

-		dispatch_info->size_table[func_index][1];

-

-	    data->bytes = dispatch_info->size_table[func_index][0];

-	    data->varsize = (var_offset != ~0)

-		? dispatch_info->size_func_table[var_offset]

-		: NULL;

-

-	    return 0;

-	}

-    }

-

-    return -1;

-}

+/*
+ * (C) Copyright IBM Corporation 2005
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * IBM,
+ * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <string.h>
+
+#include <X11/Xmd.h>
+#include <GL/gl.h>
+#include <GL/glxproto.h>
+#include <inttypes.h>
+#include "indirect_size.h"
+#include "indirect_size_get.h"
+#include "indirect_dispatch.h"
+#include "glxserver.h"
+#include "glxbyteorder.h"
+#include "singlesize.h"
+#include "glapitable.h"
+#include "glapi.h"
+#include "glthread.h"
+#include "dispatch.h"
+#include "glxext.h"
+#include "indirect_table.h"
+#include "indirect_util.h"
+
+#define __GLX_PAD(a) (((a)+3)&~3)
+
+extern xGLXSingleReply __glXReply;
+
+GLint
+__glGetBooleanv_variable_size(GLenum e)
+{
+    if (e == GL_COMPRESSED_TEXTURE_FORMATS) {
+        GLint temp;
+
+        CALL_GetIntegerv(GET_DISPATCH(),
+                         (GL_NUM_COMPRESSED_TEXTURE_FORMATS, &temp));
+        return temp;
+    }
+    else {
+        return 0;
+    }
+}
+
+/**
+ * Get a properly aligned buffer to hold reply data.
+ *
+ * \warning
+ * This function assumes that \c local_buffer is already properly aligned.
+ * It also assumes that \c alignment is a power of two.
+ */
+void *
+__glXGetAnswerBuffer(__GLXclientState * cl, size_t required_size,
+                     void *local_buffer, size_t local_size, unsigned alignment)
+{
+    void *buffer = local_buffer;
+    const unsigned mask = alignment - 1;
+
+    if (local_size < required_size) {
+        const size_t worst_case_size = required_size + alignment;
+        intptr_t temp_buf;
+
+        if (cl->returnBufSize < worst_case_size) {
+            void *temp = realloc(cl->returnBuf, worst_case_size);
+
+            if (temp == NULL) {
+                return NULL;
+            }
+
+            cl->returnBuf = temp;
+            cl->returnBufSize = worst_case_size;
+        }
+
+        temp_buf = (intptr_t) cl->returnBuf;
+        temp_buf = (temp_buf + mask) & ~mask;
+        buffer = (void *) temp_buf;
+    }
+
+    return buffer;
+}
+
+/**
+ * Send a GLX reply to the client.
+ *
+ * Technically speaking, there are several different ways to encode a GLX
+ * reply.  The primary difference is whether or not certain fields (e.g.,
+ * retval, size, and "pad3") are set.  This function gets around that by
+ * always setting all of the fields to "reasonable" values.  This does no
+ * harm to clients, but it does make the server-side code much more compact.
+ */
+void
+__glXSendReply(ClientPtr client, const void *data, size_t elements,
+               size_t element_size, GLboolean always_array, CARD32 retval)
+{
+    size_t reply_ints = 0;
+
+    if (__glXErrorOccured()) {
+        elements = 0;
+    }
+    else if ((elements > 1) || always_array) {
+        reply_ints = bytes_to_int32(elements * element_size);
+    }
+
+    __glXReply.length = reply_ints;
+    __glXReply.type = X_Reply;
+    __glXReply.sequenceNumber = client->sequence;
+    __glXReply.size = elements;
+    __glXReply.retval = retval;
+
+    /* It is faster on almost always every architecture to just copy the 8
+     * bytes, even when not necessary, than check to see of the value of
+     * elements requires it.  Copying the data when not needed will do no
+     * harm.
+     */
+
+    (void) memcpy(&__glXReply.pad3, data, 8);
+    WriteToClient(client, sz_xGLXSingleReply, (char *) &__glXReply);
+
+    if (reply_ints != 0) {
+        WriteToClient(client, reply_ints * 4, (char *) data);
+    }
+}
+
+/**
+ * Send a GLX reply to the client.
+ *
+ * Technically speaking, there are several different ways to encode a GLX
+ * reply.  The primary difference is whether or not certain fields (e.g.,
+ * retval, size, and "pad3") are set.  This function gets around that by
+ * always setting all of the fields to "reasonable" values.  This does no
+ * harm to clients, but it does make the server-side code much more compact.
+ *
+ * \warning
+ * This function assumes that values stored in \c data will be byte-swapped
+ * by the caller if necessary.
+ */
+void
+__glXSendReplySwap(ClientPtr client, const void *data, size_t elements,
+                   size_t element_size, GLboolean always_array, CARD32 retval)
+{
+    size_t reply_ints = 0;
+
+    if (__glXErrorOccured()) {
+        elements = 0;
+    }
+    else if ((elements > 1) || always_array) {
+        reply_ints = bytes_to_int32(elements * element_size);
+    }
+
+    __glXReply.length = bswap_32(reply_ints);
+    __glXReply.type = X_Reply;
+    __glXReply.sequenceNumber = bswap_16(client->sequence);
+    __glXReply.size = bswap_32(elements);
+    __glXReply.retval = bswap_32(retval);
+
+    /* It is faster on almost always every architecture to just copy the 8
+     * bytes, even when not necessary, than check to see of the value of
+     * elements requires it.  Copying the data when not needed will do no
+     * harm.
+     */
+
+    (void) memcpy(&__glXReply.pad3, data, 8);
+    WriteToClient(client, sz_xGLXSingleReply, (char *) &__glXReply);
+
+    if (reply_ints != 0) {
+        WriteToClient(client, reply_ints * 4, (char *) data);
+    }
+}
+
+static int
+get_decode_index(const struct __glXDispatchInfo *dispatch_info, unsigned opcode)
+{
+    int remaining_bits;
+    int next_remain;
+    const int_fast16_t *const tree = dispatch_info->dispatch_tree;
+    int_fast16_t index;
+
+    remaining_bits = dispatch_info->bits;
+    if (opcode >= (1U << remaining_bits)) {
+        return -1;
+    }
+
+    index = 0;
+    for ( /* empty */ ; remaining_bits > 0; remaining_bits = next_remain) {
+        unsigned mask;
+        unsigned child_index;
+
+        /* Calculate the slice of bits used by this node.
+         * 
+         * If remaining_bits = 8 and tree[index] = 3, the mask of just the
+         * remaining bits is 0x00ff and the mask for the remaining bits after
+         * this node is 0x001f.  By taking 0x00ff & ~0x001f, we get 0x00e0.
+         * This masks the 3 bits that we would want for this node.
+         */
+
+        next_remain = remaining_bits - tree[index];
+        mask = ((1 << remaining_bits) - 1) & ~((1 << next_remain) - 1);
+
+        /* Using the mask, calculate the index of the opcode in the node.
+         * With that index, fetch the index of the next node.
+         */
+
+        child_index = (opcode & mask) >> next_remain;
+        index = tree[index + 1 + child_index];
+
+        /* If the next node is an empty leaf, the opcode is for a non-existant
+         * function.  We're done.
+         *
+         * If the next node is a non-empty leaf, look up the function pointer
+         * and return it.
+         */
+
+        if (index == EMPTY_LEAF) {
+            return -1;
+        }
+        else if (IS_LEAF_INDEX(index)) {
+            unsigned func_index;
+
+            /* The value stored in the tree for a leaf node is the base of
+             * the function pointers for that leaf node.  The offset for the
+             * function for a particular opcode is the remaining bits in the
+             * opcode.
+             */
+
+            func_index = -index;
+            func_index += opcode & ((1 << next_remain) - 1);
+            return func_index;
+        }
+    }
+
+    /* We should *never* get here!!!
+     */
+    return -1;
+}
+
+void *
+__glXGetProtocolDecodeFunction(const struct __glXDispatchInfo *dispatch_info,
+                               int opcode, int swapped_version)
+{
+    const int func_index = get_decode_index(dispatch_info, opcode);
+
+    return (func_index < 0)
+        ? NULL
+        : (void *) dispatch_info->
+        dispatch_functions[func_index][swapped_version];
+}
+
+int
+__glXGetProtocolSizeData(const struct __glXDispatchInfo *dispatch_info,
+                         int opcode, __GLXrenderSizeData * data)
+{
+    if (dispatch_info->size_table != NULL) {
+        const int func_index = get_decode_index(dispatch_info, opcode);
+
+        if ((func_index >= 0)
+            && (dispatch_info->size_table[func_index][0] != 0)) {
+            const int var_offset = dispatch_info->size_table[func_index][1];
+
+            data->bytes = dispatch_info->size_table[func_index][0];
+            data->varsize = (var_offset != ~0)
+                ? dispatch_info->size_func_table[var_offset]
+                : NULL;
+
+            return 0;
+        }
+    }
+
+    return -1;
+}