Checked in the following released items:

xkeyboard-config-1.4.tar.gz
ttf-bitstream-vera-1.10.tar.gz
font-alias-1.0.1.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sony-misc-1.0.0.tar.gz
font-schumacher-misc-1.0.0.tar.gz
font-mutt-misc-1.0.0.tar.gz
font-misc-misc-1.0.0.tar.gz
font-misc-meltho-1.0.0.tar.gz
font-micro-misc-1.0.0.tar.gz
font-jis-misc-1.0.0.tar.gz
font-isas-misc-1.0.0.tar.gz
font-dec-misc-1.0.0.tar.gz
font-daewoo-misc-1.0.0.tar.gz
font-cursor-misc-1.0.0.tar.gz
font-arabic-misc-1.0.0.tar.gz
font-winitzki-cyrillic-1.0.0.tar.gz
font-misc-cyrillic-1.0.0.tar.gz
font-cronyx-cyrillic-1.0.0.tar.gz
font-screen-cyrillic-1.0.1.tar.gz
font-xfree86-type1-1.0.1.tar.gz
font-adobe-utopia-type1-1.0.1.tar.gz
font-ibm-type1-1.0.0.tar.gz
font-bitstream-type1-1.0.0.tar.gz
font-bitstream-speedo-1.0.0.tar.gz
font-bh-ttf-1.0.0.tar.gz
font-bh-type1-1.0.0.tar.gz
font-bitstream-100dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-100dpi-1.0.0.tar.gz
font-bh-100dpi-1.0.0.tar.gz
font-adobe-utopia-100dpi-1.0.1.tar.gz
font-adobe-100dpi-1.0.0.tar.gz
font-util-1.0.1.tar.gz
font-bitstream-75dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-75dpi-1.0.0.tar.gz
font-adobe-utopia-75dpi-1.0.1.tar.gz
font-bh-75dpi-1.0.0.tar.gz
bdftopcf-1.0.1.tar.gz
font-adobe-75dpi-1.0.0.tar.gz
mkfontscale-1.0.6.tar.gz
openssl-0.9.8k.tar.gz
bigreqsproto-1.0.2.tar.gz
xtrans-1.2.2.tar.gz
resourceproto-1.0.2.tar.gz
inputproto-1.4.4.tar.gz
compositeproto-0.4.tar.gz
damageproto-1.1.0.tar.gz
zlib-1.2.3.tar.gz
xkbcomp-1.0.5.tar.gz
freetype-2.3.9.tar.gz
pthreads-w32-2-8-0-release.tar.gz
pixman-0.12.0.tar.gz
kbproto-1.0.3.tar.gz
evieext-1.0.2.tar.gz
fixesproto-4.0.tar.gz
recordproto-1.13.2.tar.gz
randrproto-1.2.2.tar.gz
scrnsaverproto-1.1.0.tar.gz
renderproto-0.9.3.tar.gz
xcmiscproto-1.1.2.tar.gz
fontsproto-2.0.2.tar.gz
xextproto-7.0.3.tar.gz
xproto-7.0.14.tar.gz
libXdmcp-1.0.2.tar.gz
libxkbfile-1.0.5.tar.gz
libfontenc-1.0.4.tar.gz
libXfont-1.3.4.tar.gz
libX11-1.1.5.tar.gz
libXau-1.0.4.tar.gz
libxcb-1.1.tar.gz
xorg-server-1.5.3.tar.gz

1 files changed, 310 insertions, 0 deletions

diff --git a/xorg-server/glx/indirect_util.c b/xorg-server/glx/indirect_util.c
new file mode 100644
index 000000000..58c194c99
--- /dev/null
+++ b/xorg-server/glx/indirect_util.c
@@ -0,0 +1,310 @@
+/*
+ * (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 = xrealloc( 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 = ((elements * element_size) + 3) >> 2;
+    }
+
+    __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 = ((elements * element_size) + 3) >> 2;
+    }
+
+    __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;
+}