[deb_xorg-server.git] / hw / dmx / glxProxy / glxvendor.c

/* DO NOT EDIT - THIS FILE IS AUTOMATICALLY GENERATED */
/*
 * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
 * Copyright (C) 1991-2000 Silicon Graphics, Inc. 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, sublicense,
 * 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 including the dates of first publication and
 * either this permission notice or a reference to
 * http://oss.sgi.com/projects/FreeB/
 * 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 NONINFRINGEMENT. IN NO EVENT SHALL
 * SILICON GRAPHICS, INC. 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.
 *
 * Except as contained in this notice, the name of Silicon Graphics, Inc.
 * shall not be used in advertising or otherwise to promote the sale, use or
 * other dealings in this Software without prior written authorization from
 * Silicon Graphics, Inc.
 */

#ifdef HAVE_DMX_CONFIG_H
#include <dmx-config.h>
#endif

#include "dmx.h"
#include "dmxwindow.h"
#include "dmxpixmap.h"
#include "dmxfont.h"

#include "glxserver.h"
#include "glxext.h"
#include "g_disptab.h"
/* #include "g_disptab_EXT.h" */
#include "unpack.h"
#include "glxutil.h"

#include "GL/glxproto.h"

#ifdef PANORAMIX
#include "panoramiXsrv.h"
#endif

/*
 * GetReqVendorPrivate - this is the equivalent of GetReq macro
 *    from Xlibint.h but it does not set the reqType field (the opcode).
 *    this is because the GL single opcodes has different naming convension
 *    the other X opcodes (ie. X_GLsop_GetFloatv).
 */
#if (defined(__STDC__) && !defined(UNIXCPP)) || defined(ANSICPP)
#define GetReqVendorPrivate(name, req) \
        WORD64ALIGN\
	if ((dpy->bufptr + SIZEOF(x##name##Req)) > dpy->bufmax)\
		_XFlush(dpy);\
	req = (x##name##Req *)(dpy->last_req = dpy->bufptr);\
	req->length = (SIZEOF(x##name##Req))>>2;\
	dpy->bufptr += SIZEOF(x##name##Req);\
	dpy->request++

#else                           /* non-ANSI C uses empty comment instead of "##" for token concatenation */
#define GetReqVendorPrivate(name, req) \
        WORD64ALIGN\
	if ((dpy->bufptr + SIZEOF(x/**/name/**/Req)) > dpy->bufmax)\
		_XFlush(dpy);\
	req = (x/**/name/**/Req *)(dpy->last_req = dpy->bufptr);\
	req->length = (SIZEOF(x/**/name/**/Req))>>2;\
	dpy->bufptr += SIZEOF(x/**/name/**/Req);\
	dpy->request++
#endif

extern Display *GetBackEndDisplay(__GLXclientState * cl, int s);
extern int GetCurrentBackEndTag(__GLXclientState * cl, GLXContextTag tag,
                                int s);

static int swap_vec_element_size = 0;

static void
SendSwappedReply(ClientPtr client,
                 xGLXVendorPrivReply * reply, char *buf, int buf_size)
{
    __GLX_DECLARE_SWAP_VARIABLES;
    __GLX_SWAP_SHORT(&reply->sequenceNumber);
    __GLX_SWAP_INT(&reply->length);
    __GLX_SWAP_INT(&reply->retval);
    __GLX_SWAP_INT(&reply->size);

    if ((buf_size == 0) && (swap_vec_element_size > 0)) {
        /*
         * the reply has single component - need to swap pad3
         */
        if (swap_vec_element_size == 2) {
            __GLX_SWAP_SHORT(&reply->pad3);
        }
        else if (swap_vec_element_size == 4) {
            __GLX_SWAP_INT(&reply->pad3);
            __GLX_SWAP_INT(&reply->pad4);
        }
        else if (swap_vec_element_size == 8) {
            __GLX_SWAP_DOUBLE(&reply->pad3);
        }
    }
    else if ((buf_size > 0) && (swap_vec_element_size > 0)) {
        /*
         * the reply has vector of elements which needs to be swapped
         */
        int vsize = buf_size / swap_vec_element_size;
        char *p = buf;
        int i;

        for (i = 0; i < vsize; i++) {
            if (swap_vec_element_size == 2) {
                __GLX_SWAP_SHORT(p);
            }
            else if (swap_vec_element_size == 4) {
                __GLX_SWAP_INT(p);
            }
            else if (swap_vec_element_size == 8) {
                __GLX_SWAP_DOUBLE(p);
            }

            p += swap_vec_element_size;
        }

        __GLX_SWAP_INT(&reply->pad3);
        __GLX_SWAP_INT(&reply->pad4);
        __GLX_SWAP_INT(&reply->pad5);
        __GLX_SWAP_INT(&reply->pad6);

    }

    WriteToClient(client, sizeof(xGLXVendorPrivReply), reply);
    if (buf_size > 0)
        WriteToClient(client, buf_size, buf);

}

int
__glXVForwardSingleReq(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
    xGLXVendorPrivateReq *be_req;
    __GLXcontext *glxc;
    int from_screen = 0;
    int to_screen = 0;
    int buf_size;
    int s;

    glxc = __glXLookupContextByTag(cl, req->contextTag);
    if (!glxc) {
        return 0;
    }
    from_screen = to_screen = glxc->pScreen->myNum;

#ifdef PANORAMIX
    if (!noPanoramiXExtension) {
        from_screen = 0;
        to_screen = screenInfo.numScreens - 1;
    }
#endif

    pc += sz_xGLXVendorPrivateReq;
    buf_size = (req->length << 2) - sz_xGLXVendorPrivateReq;

    /*
     * just forward the request to back-end server(s)
     */
    for (s = from_screen; s <= to_screen; s++) {
        DMXScreenInfo *dmxScreen = &dmxScreens[s];
        Display *dpy = GetBackEndDisplay(cl, s);

        LockDisplay(dpy);
        GetReqVendorPrivate(GLXVendorPrivate, be_req);
        be_req->reqType = dmxScreen->glxMajorOpcode;
        be_req->glxCode = req->glxCode;
        be_req->length = req->length;
        be_req->vendorCode = req->vendorCode;
        be_req->contextTag = GetCurrentBackEndTag(cl, req->contextTag, s);
        if (buf_size > 0)
            _XSend(dpy, (const char *) pc, buf_size);
        UnlockDisplay(dpy);
        SyncHandle();
    }

    return Success;
}

int
__glXVForwardPipe0WithReply(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
    xGLXVendorPrivateReq *be_req;
    xGLXVendorPrivReply reply;
    xGLXVendorPrivReply be_reply;
    __GLXcontext *glxc;
    int buf_size;
    char *be_buf = NULL;
    int be_buf_size;
    DMXScreenInfo *dmxScreen;
    Display *dpy;

    glxc = __glXLookupContextByTag(cl, req->contextTag);
    if (!glxc) {
        return __glXBadContext;
    }

    pc += sz_xGLXVendorPrivateReq;
    buf_size = (req->length << 2) - sz_xGLXVendorPrivateReq;

    dmxScreen = &dmxScreens[glxc->pScreen->myNum];
    dpy = GetBackEndDisplay(cl, glxc->pScreen->myNum);

    /* 
     * send the request to the first back-end server
     */
    LockDisplay(dpy);
    GetReqVendorPrivate(GLXVendorPrivate, be_req);
    be_req->reqType = dmxScreen->glxMajorOpcode;
    be_req->glxCode = req->glxCode;
    be_req->length = req->length;
    be_req->vendorCode = req->vendorCode;
    be_req->contextTag =
        GetCurrentBackEndTag(cl, req->contextTag, glxc->pScreen->myNum);
    if (buf_size > 0)
        _XSend(dpy, (const char *) pc, buf_size);

    /*
     * get the reply from the back-end server
     */
    _XReply(dpy, (xReply *) &be_reply, 0, False);
    be_buf_size = be_reply.length << 2;
    if (be_buf_size > 0) {
        be_buf = (char *) malloc(be_buf_size);
        if (be_buf) {
            _XRead(dpy, be_buf, be_buf_size);
        }
        else {
            /* Throw data on the floor */
            _XEatDataWords(dpy, be_reply.length);
            return BadAlloc;
        }
    }

    UnlockDisplay(dpy);
    SyncHandle();

    /*
     * send the reply to the client
     */
    memcpy(&reply, &be_reply, sz_xGLXVendorPrivReply);
    reply.type = X_Reply;
    reply.sequenceNumber = client->sequence;

    if (client->swapped) {
        SendSwappedReply(client, &reply, be_buf, be_buf_size);
    }
    else {
        WriteToClient(client, sizeof(xGLXVendorPrivReply), &reply);
        if (be_buf_size > 0)
            WriteToClient(client, be_buf_size, be_buf);
    }

    if (be_buf_size > 0)
        free(be_buf);

    return Success;
}

int
__glXVForwardAllWithReply(__GLXclientState * cl, GLbyte * pc)
{
    ClientPtr client = cl->client;
    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
    xGLXVendorPrivateReq *be_req;
    xGLXVendorPrivReply reply;
    xGLXVendorPrivReply be_reply;
    __GLXcontext *glxc;
    int buf_size;
    char *be_buf = NULL;
    int be_buf_size = 0;
    int from_screen = 0;
    int to_screen = 0;
    int s;

    DMXScreenInfo *dmxScreen;
    Display *dpy;

    glxc = __glXLookupContextByTag(cl, req->contextTag);
    if (!glxc) {
        return 0;
    }
    from_screen = to_screen = glxc->pScreen->myNum;

#ifdef PANORAMIX
    if (!noPanoramiXExtension) {
        from_screen = 0;
        to_screen = screenInfo.numScreens - 1;
    }
#endif

    pc += sz_xGLXVendorPrivateReq;
    buf_size = (req->length << 2) - sz_xGLXVendorPrivateReq;

    /* 
     * send the request to the first back-end server(s)
     */
    for (s = to_screen; s >= from_screen; s--) {
        dmxScreen = &dmxScreens[s];
        dpy = GetBackEndDisplay(cl, s);

        LockDisplay(dpy);
        GetReqVendorPrivate(GLXVendorPrivate, be_req);
        be_req->reqType = dmxScreen->glxMajorOpcode;
        be_req->glxCode = req->glxCode;
        be_req->length = req->length;
        be_req->vendorCode = req->vendorCode;
        be_req->contextTag = GetCurrentBackEndTag(cl, req->contextTag, s);
        if (buf_size > 0)
            _XSend(dpy, (const char *) pc, buf_size);

        /*
         * get the reply from the back-end server
         */
        _XReply(dpy, (xReply *) &be_reply, 0, False);
        if (s == from_screen) {
            /* Save data from last reply to send on to client */
            be_buf_size = be_reply.length << 2;
            if (be_buf_size > 0) {
                be_buf = malloc(be_buf_size);
                if (be_buf) {
                    _XRead(dpy, be_buf, be_buf_size);
                }
                else {
                    /* Throw data on the floor */
                    _XEatDataWords(dpy, be_reply.length);
                    return BadAlloc;
                }
            }
        }
        else {
            /* Just discard data from all replies before the last one */
            if (be_reply.length > 0)
                _XEatDataWords(dpy, be_reply.length);
        }

        UnlockDisplay(dpy);
        SyncHandle();
    }

    /*
     * send the reply to the client
     */
    memcpy(&reply, &be_reply, sz_xGLXVendorPrivReply);
    reply.type = X_Reply;
    reply.sequenceNumber = client->sequence;

    if (client->swapped) {
        SendSwappedReply(client, &reply, be_buf, be_buf_size);
    }
    else {
        WriteToClient(client, sizeof(xGLXVendorPrivReply), &reply);
        if (be_buf_size > 0)
            WriteToClient(client, be_buf_size, be_buf);
    }

    if (be_buf_size > 0)
        free(be_buf);

    return Success;
}

int
__glXVForwardSingleReqSwap(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;

    __GLX_DECLARE_SWAP_VARIABLES;

    __GLX_SWAP_SHORT(&req->length);
    __GLX_SWAP_INT(&req->vendorCode);
    __GLX_SWAP_INT(&req->contextTag);

    swap_vec_element_size = 0;

    return (__glXVForwardSingleReq(cl, pc));
}

int
__glXVForwardPipe0WithReplySwap(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;

    __GLX_DECLARE_SWAP_VARIABLES;
    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

    __GLX_SWAP_SHORT(&req->length);
    __GLX_SWAP_INT(&req->vendorCode);
    __GLX_SWAP_INT(&req->contextTag);

    swap_vec_element_size = 0;

    /*
     * swap extra data in request - assuming all data
     * (if available) are arrays of 4 bytes components !
     */
    if (req->length > sz_xGLXVendorPrivateReq / 4) {
        int *data = (int *) (req + 1);
        int count = req->length - sz_xGLXVendorPrivateReq / 4;

        __GLX_SWAP_INT_ARRAY(data, count);
    }

    return (__glXVForwardPipe0WithReply(cl, pc));
}

int
__glXVForwardPipe0WithReplySwapsv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;

    __GLX_DECLARE_SWAP_VARIABLES;
    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

    __GLX_SWAP_SHORT(&req->length);
    __GLX_SWAP_INT(&req->vendorCode);
    __GLX_SWAP_INT(&req->contextTag);

    swap_vec_element_size = 2;

    /*
     * swap extra data in request - assuming all data
     * (if available) are arrays of 4 bytes components !
     */
    if (req->length > sz_xGLXVendorPrivateReq / 4) {
        int *data = (int *) (req + 1);
        int count = req->length - sz_xGLXVendorPrivateReq / 4;

        __GLX_SWAP_INT_ARRAY(data, count);
    }

    return (__glXVForwardPipe0WithReply(cl, pc));
}

int
__glXVForwardPipe0WithReplySwapiv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;

    __GLX_DECLARE_SWAP_VARIABLES;
    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

    __GLX_SWAP_SHORT(&req->length);
    __GLX_SWAP_INT(&req->vendorCode);
    __GLX_SWAP_INT(&req->contextTag);

    swap_vec_element_size = 4;

    /*
     * swap extra data in request - assuming all data
     * (if available) are arrays of 4 bytes components !
     */
    if (req->length > sz_xGLXVendorPrivateReq / 4) {
        int *data = (int *) (req + 1);
        int count = req->length - sz_xGLXVendorPrivateReq / 4;

        __GLX_SWAP_INT_ARRAY(data, count);
    }

    return (__glXVForwardPipe0WithReply(cl, pc));
}

int
__glXVForwardPipe0WithReplySwapdv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;

    __GLX_DECLARE_SWAP_VARIABLES;
    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

    __GLX_SWAP_SHORT(&req->length);
    __GLX_SWAP_INT(&req->vendorCode);
    __GLX_SWAP_INT(&req->contextTag);

    swap_vec_element_size = 8;

    /*
     * swap extra data in request - assuming all data
     * (if available) are arrays of 4 bytes components !
     */
    if (req->length > sz_xGLXVendorPrivateReq / 4) {
        int *data = (int *) (req + 1);
        int count = req->length - sz_xGLXVendorPrivateReq / 4;

        __GLX_SWAP_INT_ARRAY(data, count);
    }

    return (__glXVForwardPipe0WithReply(cl, pc));
}

int
__glXVForwardAllWithReplySwap(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;

    __GLX_DECLARE_SWAP_VARIABLES;
    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

    __GLX_SWAP_SHORT(&req->length);
    __GLX_SWAP_INT(&req->vendorCode);
    __GLX_SWAP_INT(&req->contextTag);

    swap_vec_element_size = 0;

    /*
     * swap extra data in request - assuming all data
     * (if available) are arrays of 4 bytes components !
     */
    if (req->length > sz_xGLXVendorPrivateReq / 4) {
        int *data = (int *) (req + 1);
        int count = req->length - sz_xGLXVendorPrivateReq / 4;

        __GLX_SWAP_INT_ARRAY(data, count);
    }

    return (__glXVForwardAllWithReply(cl, pc));
}

int
__glXVForwardAllWithReplySwapsv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;

    __GLX_DECLARE_SWAP_VARIABLES;
    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

    __GLX_SWAP_SHORT(&req->length);
    __GLX_SWAP_INT(&req->vendorCode);
    __GLX_SWAP_INT(&req->contextTag);

    swap_vec_element_size = 2;

    /*
     * swap extra data in request - assuming all data
     * (if available) are arrays of 4 bytes components !
     */
    if (req->length > sz_xGLXVendorPrivateReq / 4) {
        int *data = (int *) (req + 1);
        int count = req->length - sz_xGLXVendorPrivateReq / 4;

        __GLX_SWAP_INT_ARRAY(data, count);
    }

    return (__glXVForwardAllWithReply(cl, pc));
}

int
__glXVForwardAllWithReplySwapiv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;

    __GLX_DECLARE_SWAP_VARIABLES;
    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

    __GLX_SWAP_SHORT(&req->length);
    __GLX_SWAP_INT(&req->vendorCode);
    __GLX_SWAP_INT(&req->contextTag);

    swap_vec_element_size = 4;

    /*
     * swap extra data in request - assuming all data
     * (if available) are arrays of 4 bytes components !
     */
    if (req->length > sz_xGLXVendorPrivateReq / 4) {
        int *data = (int *) (req + 1);
        int count = req->length - sz_xGLXVendorPrivateReq / 4;

        __GLX_SWAP_INT_ARRAY(data, count);
    }

    return (__glXVForwardAllWithReply(cl, pc));
}

int
__glXVForwardAllWithReplySwapdv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;

    __GLX_DECLARE_SWAP_VARIABLES;
    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;

    __GLX_SWAP_SHORT(&req->length);
    __GLX_SWAP_INT(&req->vendorCode);
    __GLX_SWAP_INT(&req->contextTag);

    swap_vec_element_size = 8;

    /*
     * swap extra data in request - assuming all data
     * (if available) are arrays of 4 bytes components !
     */
    if (req->length > sz_xGLXVendorPrivateReq / 4) {
        int *data = (int *) (req + 1);
        int count = req->length - sz_xGLXVendorPrivateReq / 4;

        __GLX_SWAP_INT_ARRAY(data, count);
    }

    return (__glXVForwardAllWithReply(cl, pc));
}
Commit	Line	Data
a09e091a JB	1	/* DO NOT EDIT - THIS FILE IS AUTOMATICALLY GENERATED */
	2	/*
	3	* SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
	4	* Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
	5	*
	6	* Permission is hereby granted, free of charge, to any person obtaining a
	7	* copy of this software and associated documentation files (the "Software"),
	8	* to deal in the Software without restriction, including without limitation
	9	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	10	* and/or sell copies of the Software, and to permit persons to whom the
	11	* Software is furnished to do so, subject to the following conditions:
	12	*
	13	* The above copyright notice including the dates of first publication and
	14	* either this permission notice or a reference to
	15	* http://oss.sgi.com/projects/FreeB/
	16	* shall be included in all copies or substantial portions of the Software.
	17	*
	18	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	19	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	20	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	21	* SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
	22	* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
	23	* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	24	* SOFTWARE.
	25	*
	26	* Except as contained in this notice, the name of Silicon Graphics, Inc.
	27	* shall not be used in advertising or otherwise to promote the sale, use or
	28	* other dealings in this Software without prior written authorization from
	29	* Silicon Graphics, Inc.
	30	*/
	31
	32	#ifdef HAVE_DMX_CONFIG_H
	33	#include <dmx-config.h>
	34	#endif
	35
	36	#include "dmx.h"
	37	#include "dmxwindow.h"
	38	#include "dmxpixmap.h"
	39	#include "dmxfont.h"
	40
	41	#include "glxserver.h"
	42	#include "glxext.h"
	43	#include "g_disptab.h"
	44	/* #include "g_disptab_EXT.h" */
	45	#include "unpack.h"
	46	#include "glxutil.h"
	47
	48	#include "GL/glxproto.h"
	49
	50	#ifdef PANORAMIX
	51	#include "panoramiXsrv.h"
	52	#endif
	53
	54	/*
	55	* GetReqVendorPrivate - this is the equivalent of GetReq macro
	56	* from Xlibint.h but it does not set the reqType field (the opcode).
	57	* this is because the GL single opcodes has different naming convension
	58	* the other X opcodes (ie. X_GLsop_GetFloatv).
	59	*/
	60	#if (defined(__STDC__) && !defined(UNIXCPP)) \|\| defined(ANSICPP)
	61	#define GetReqVendorPrivate(name, req) \
	62	WORD64ALIGN\
	63	if ((dpy->bufptr + SIZEOF(x##name##Req)) > dpy->bufmax)\
	64	_XFlush(dpy);\
65	req = (x##name##Req *)(dpy->last_req = dpy->bufptr);\
66	req->length = (SIZEOF(x##name##Req))>>2;\
67	dpy->bufptr += SIZEOF(x##name##Req);\
68	dpy->request++
69
70	#else /* non-ANSI C uses empty comment instead of "##" for token concatenation */
71	#define GetReqVendorPrivate(name, req) \
72	WORD64ALIGN\
73	if ((dpy->bufptr + SIZEOF(x//name//Req)) > dpy->bufmax)\
74	_XFlush(dpy);\
75	req = (x//name//Req *)(dpy->last_req = dpy->bufptr);\
76	req->length = (SIZEOF(x//name//Req))>>2;\
77	dpy->bufptr += SIZEOF(x//name//Req);\
78	dpy->request++
79	#endif
80
81	extern Display GetBackEndDisplay(__GLXclientState cl, int s);
82	extern int GetCurrentBackEndTag(__GLXclientState * cl, GLXContextTag tag,
83	int s);
84
85	static int swap_vec_element_size = 0;
86
87	static void
88	SendSwappedReply(ClientPtr client,
89	xGLXVendorPrivReply * reply, char *buf, int buf_size)
90	{
91	__GLX_DECLARE_SWAP_VARIABLES;
92	__GLX_SWAP_SHORT(&reply->sequenceNumber);
93	__GLX_SWAP_INT(&reply->length);
94	__GLX_SWAP_INT(&reply->retval);
95	__GLX_SWAP_INT(&reply->size);
96
97	if ((buf_size == 0) && (swap_vec_element_size > 0)) {
98	/*
99	* the reply has single component - need to swap pad3
100	*/
101	if (swap_vec_element_size == 2) {
102	__GLX_SWAP_SHORT(&reply->pad3);
103	}
104	else if (swap_vec_element_size == 4) {
105	__GLX_SWAP_INT(&reply->pad3);
106	__GLX_SWAP_INT(&reply->pad4);
107	}
108	else if (swap_vec_element_size == 8) {
109	__GLX_SWAP_DOUBLE(&reply->pad3);
110	}
111	}
112	else if ((buf_size > 0) && (swap_vec_element_size > 0)) {
113	/*
114	* the reply has vector of elements which needs to be swapped
115	*/
116	int vsize = buf_size / swap_vec_element_size;
117	char *p = buf;
118	int i;
119
120	for (i = 0; i < vsize; i++) {
121	if (swap_vec_element_size == 2) {
122	__GLX_SWAP_SHORT(p);
123	}
124	else if (swap_vec_element_size == 4) {
125	__GLX_SWAP_INT(p);
126	}
127	else if (swap_vec_element_size == 8) {
128	__GLX_SWAP_DOUBLE(p);
129	}
130
131	p += swap_vec_element_size;
132	}
133
134	__GLX_SWAP_INT(&reply->pad3);
135	__GLX_SWAP_INT(&reply->pad4);
136	__GLX_SWAP_INT(&reply->pad5);
137	__GLX_SWAP_INT(&reply->pad6);
138
139	}
140
141	WriteToClient(client, sizeof(xGLXVendorPrivReply), reply);
142	if (buf_size > 0)
143	WriteToClient(client, buf_size, buf);
144
145	}
146
147	int
148	__glXVForwardSingleReq(__GLXclientState * cl, GLbyte * pc)
149	{
150	xGLXVendorPrivateReq req = (xGLXVendorPrivateReq ) pc;
151	xGLXVendorPrivateReq *be_req;
152	__GLXcontext *glxc;
153	int from_screen = 0;
154	int to_screen = 0;
155	int buf_size;
156	int s;
157
158	glxc = __glXLookupContextByTag(cl, req->contextTag);
159	if (!glxc) {
160	return 0;
161	}
162	from_screen = to_screen = glxc->pScreen->myNum;
163
164	#ifdef PANORAMIX
165	if (!noPanoramiXExtension) {
166	from_screen = 0;
167	to_screen = screenInfo.numScreens - 1;
168	}
169	#endif
170
171	pc += sz_xGLXVendorPrivateReq;
172	buf_size = (req->length << 2) - sz_xGLXVendorPrivateReq;
173
174	/*
175	* just forward the request to back-end server(s)
176	*/
177	for (s = from_screen; s <= to_screen; s++) {
178	DMXScreenInfo *dmxScreen = &dmxScreens[s];
179	Display *dpy = GetBackEndDisplay(cl, s);
180
181	LockDisplay(dpy);
182	GetReqVendorPrivate(GLXVendorPrivate, be_req);
183	be_req->reqType = dmxScreen->glxMajorOpcode;
184	be_req->glxCode = req->glxCode;
185	be_req->length = req->length;
186	be_req->vendorCode = req->vendorCode;
187	be_req->contextTag = GetCurrentBackEndTag(cl, req->contextTag, s);
188	if (buf_size > 0)
189	_XSend(dpy, (const char *) pc, buf_size);
190	UnlockDisplay(dpy);
191	SyncHandle();
192	}
193
194	return Success;
195	}
196
197	int
198	__glXVForwardPipe0WithReply(__GLXclientState * cl, GLbyte * pc)
199	{
200	ClientPtr client = cl->client;
201	xGLXVendorPrivateReq req = (xGLXVendorPrivateReq ) pc;
202	xGLXVendorPrivateReq *be_req;
203	xGLXVendorPrivReply reply;
204	xGLXVendorPrivReply be_reply;
205	__GLXcontext *glxc;
206	int buf_size;
207	char *be_buf = NULL;
208	int be_buf_size;
209	DMXScreenInfo *dmxScreen;
210	Display *dpy;
211
212	glxc = __glXLookupContextByTag(cl, req->contextTag);
213	if (!glxc) {
214	return __glXBadContext;
215	}
216
217	pc += sz_xGLXVendorPrivateReq;
218	buf_size = (req->length << 2) - sz_xGLXVendorPrivateReq;
219
220	dmxScreen = &dmxScreens[glxc->pScreen->myNum];
221	dpy = GetBackEndDisplay(cl, glxc->pScreen->myNum);
222
223	/*
224	* send the request to the first back-end server
225	*/
226	LockDisplay(dpy);
227	GetReqVendorPrivate(GLXVendorPrivate, be_req);
228	be_req->reqType = dmxScreen->glxMajorOpcode;
229	be_req->glxCode = req->glxCode;
230	be_req->length = req->length;
231	be_req->vendorCode = req->vendorCode;
232	be_req->contextTag =
233	GetCurrentBackEndTag(cl, req->contextTag, glxc->pScreen->myNum);
234	if (buf_size > 0)
235	_XSend(dpy, (const char *) pc, buf_size);
236
237	/*
238	* get the reply from the back-end server
239	*/
240	_XReply(dpy, (xReply *) &be_reply, 0, False);
241	be_buf_size = be_reply.length << 2;
242	if (be_buf_size > 0) {
243	be_buf = (char *) malloc(be_buf_size);
244	if (be_buf) {
245	_XRead(dpy, be_buf, be_buf_size);
246	}
247	else {
248	/* Throw data on the floor */
249	_XEatDataWords(dpy, be_reply.length);
250	return BadAlloc;
251	}
252	}
253
254	UnlockDisplay(dpy);
255	SyncHandle();
256
257	/*
258	* send the reply to the client
259	*/
260	memcpy(&reply, &be_reply, sz_xGLXVendorPrivReply);
261	reply.type = X_Reply;
262	reply.sequenceNumber = client->sequence;
263
264	if (client->swapped) {
265	SendSwappedReply(client, &reply, be_buf, be_buf_size);
266	}
267	else {
268	WriteToClient(client, sizeof(xGLXVendorPrivReply), &reply);
269	if (be_buf_size > 0)
270	WriteToClient(client, be_buf_size, be_buf);
271	}
272
273	if (be_buf_size > 0)
274	free(be_buf);
275
276	return Success;
277	}
278
279	int
280	__glXVForwardAllWithReply(__GLXclientState * cl, GLbyte * pc)
281	{
282	ClientPtr client = cl->client;
283	xGLXVendorPrivateReq req = (xGLXVendorPrivateReq ) pc;
284	xGLXVendorPrivateReq *be_req;
285	xGLXVendorPrivReply reply;
286	xGLXVendorPrivReply be_reply;
287	__GLXcontext *glxc;
288	int buf_size;
289	char *be_buf = NULL;
290	int be_buf_size = 0;
291	int from_screen = 0;
292	int to_screen = 0;
293	int s;
294
295	DMXScreenInfo *dmxScreen;
296	Display *dpy;
297
298	glxc = __glXLookupContextByTag(cl, req->contextTag);
299	if (!glxc) {
300	return 0;
301	}
302	from_screen = to_screen = glxc->pScreen->myNum;
303
304	#ifdef PANORAMIX
305	if (!noPanoramiXExtension) {
306	from_screen = 0;
307	to_screen = screenInfo.numScreens - 1;
308	}
309	#endif
310
311	pc += sz_xGLXVendorPrivateReq;
312	buf_size = (req->length << 2) - sz_xGLXVendorPrivateReq;
313
314	/*
315	* send the request to the first back-end server(s)
316	*/
317	for (s = to_screen; s >= from_screen; s--) {
318	dmxScreen = &dmxScreens[s];
319	dpy = GetBackEndDisplay(cl, s);
320
321	LockDisplay(dpy);
322	GetReqVendorPrivate(GLXVendorPrivate, be_req);
323	be_req->reqType = dmxScreen->glxMajorOpcode;
324	be_req->glxCode = req->glxCode;
325	be_req->length = req->length;
326	be_req->vendorCode = req->vendorCode;
327	be_req->contextTag = GetCurrentBackEndTag(cl, req->contextTag, s);
328	if (buf_size > 0)
329	_XSend(dpy, (const char *) pc, buf_size);
330
331	/*
332	* get the reply from the back-end server
333	*/
334	_XReply(dpy, (xReply *) &be_reply, 0, False);
335	if (s == from_screen) {
336	/* Save data from last reply to send on to client */
337	be_buf_size = be_reply.length << 2;
338	if (be_buf_size > 0) {
339	be_buf = malloc(be_buf_size);
340	if (be_buf) {
341	_XRead(dpy, be_buf, be_buf_size);
342	}
343	else {
344	/* Throw data on the floor */
345	_XEatDataWords(dpy, be_reply.length);
346	return BadAlloc;
347	}
348	}
349	}
350	else {
351	/* Just discard data from all replies before the last one */
352	if (be_reply.length > 0)
353	_XEatDataWords(dpy, be_reply.length);
354	}
355
356	UnlockDisplay(dpy);
357	SyncHandle();
358	}
359
360	/*
361	* send the reply to the client
362	*/
363	memcpy(&reply, &be_reply, sz_xGLXVendorPrivReply);
364	reply.type = X_Reply;
365	reply.sequenceNumber = client->sequence;
366
367	if (client->swapped) {
368	SendSwappedReply(client, &reply, be_buf, be_buf_size);
369	}
370	else {
371	WriteToClient(client, sizeof(xGLXVendorPrivReply), &reply);
372	if (be_buf_size > 0)
373	WriteToClient(client, be_buf_size, be_buf);
374	}
375
376	if (be_buf_size > 0)
377	free(be_buf);
378
379	return Success;
380	}
381
382	int
383	__glXVForwardSingleReqSwap(__GLXclientState * cl, GLbyte * pc)
384	{
385	xGLXVendorPrivateReq req = (xGLXVendorPrivateReq ) pc;
386
387	__GLX_DECLARE_SWAP_VARIABLES;
388
389	__GLX_SWAP_SHORT(&req->length);
390	__GLX_SWAP_INT(&req->vendorCode);
391	__GLX_SWAP_INT(&req->contextTag);
392
393	swap_vec_element_size = 0;
394
395	return (__glXVForwardSingleReq(cl, pc));
396	}
397
398	int
399	__glXVForwardPipe0WithReplySwap(__GLXclientState * cl, GLbyte * pc)
400	{
401	xGLXVendorPrivateReq req = (xGLXVendorPrivateReq ) pc;
402
403	__GLX_DECLARE_SWAP_VARIABLES;
404	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
405
406	__GLX_SWAP_SHORT(&req->length);
407	__GLX_SWAP_INT(&req->vendorCode);
408	__GLX_SWAP_INT(&req->contextTag);
409
410	swap_vec_element_size = 0;
411
412	/*
413	* swap extra data in request - assuming all data
414	* (if available) are arrays of 4 bytes components !
415	*/
416	if (req->length > sz_xGLXVendorPrivateReq / 4) {
417	int data = (int ) (req + 1);
418	int count = req->length - sz_xGLXVendorPrivateReq / 4;
419
420	__GLX_SWAP_INT_ARRAY(data, count);
421	}
422
423	return (__glXVForwardPipe0WithReply(cl, pc));
424	}
425
426	int
427	__glXVForwardPipe0WithReplySwapsv(__GLXclientState * cl, GLbyte * pc)
428	{
429	xGLXVendorPrivateReq req = (xGLXVendorPrivateReq ) pc;
430
431	__GLX_DECLARE_SWAP_VARIABLES;
432	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
433
434	__GLX_SWAP_SHORT(&req->length);
435	__GLX_SWAP_INT(&req->vendorCode);
436	__GLX_SWAP_INT(&req->contextTag);
437
438	swap_vec_element_size = 2;
439
440	/*
441	* swap extra data in request - assuming all data
442	* (if available) are arrays of 4 bytes components !
443	*/
444	if (req->length > sz_xGLXVendorPrivateReq / 4) {
445	int data = (int ) (req + 1);
446	int count = req->length - sz_xGLXVendorPrivateReq / 4;
447
448	__GLX_SWAP_INT_ARRAY(data, count);
449	}
450
451	return (__glXVForwardPipe0WithReply(cl, pc));
452	}
453
454	int
455	__glXVForwardPipe0WithReplySwapiv(__GLXclientState * cl, GLbyte * pc)
456	{
457	xGLXVendorPrivateReq req = (xGLXVendorPrivateReq ) pc;
458
459	__GLX_DECLARE_SWAP_VARIABLES;
460	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
461
462	__GLX_SWAP_SHORT(&req->length);
463	__GLX_SWAP_INT(&req->vendorCode);
464	__GLX_SWAP_INT(&req->contextTag);
465
466	swap_vec_element_size = 4;
467
468	/*
469	* swap extra data in request - assuming all data
470	* (if available) are arrays of 4 bytes components !
471	*/
472	if (req->length > sz_xGLXVendorPrivateReq / 4) {
473	int data = (int ) (req + 1);
474	int count = req->length - sz_xGLXVendorPrivateReq / 4;
475
476	__GLX_SWAP_INT_ARRAY(data, count);
477	}
478
479	return (__glXVForwardPipe0WithReply(cl, pc));
480	}
481
482	int
483	__glXVForwardPipe0WithReplySwapdv(__GLXclientState * cl, GLbyte * pc)
484	{
485	xGLXVendorPrivateReq req = (xGLXVendorPrivateReq ) pc;
486
487	__GLX_DECLARE_SWAP_VARIABLES;
488	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
489
490	__GLX_SWAP_SHORT(&req->length);
491	__GLX_SWAP_INT(&req->vendorCode);
492	__GLX_SWAP_INT(&req->contextTag);
493
494	swap_vec_element_size = 8;
495
496	/*
497	* swap extra data in request - assuming all data
498	* (if available) are arrays of 4 bytes components !
499	*/
500	if (req->length > sz_xGLXVendorPrivateReq / 4) {
501	int data = (int ) (req + 1);
502	int count = req->length - sz_xGLXVendorPrivateReq / 4;
503
504	__GLX_SWAP_INT_ARRAY(data, count);
505	}
506
507	return (__glXVForwardPipe0WithReply(cl, pc));
508	}
509
510	int
511	__glXVForwardAllWithReplySwap(__GLXclientState * cl, GLbyte * pc)
512	{
513	xGLXVendorPrivateReq req = (xGLXVendorPrivateReq ) pc;
514
515	__GLX_DECLARE_SWAP_VARIABLES;
516	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
517
518	__GLX_SWAP_SHORT(&req->length);
519	__GLX_SWAP_INT(&req->vendorCode);
520	__GLX_SWAP_INT(&req->contextTag);
521
522	swap_vec_element_size = 0;
523
524	/*
525	* swap extra data in request - assuming all data
526	* (if available) are arrays of 4 bytes components !
527	*/
528	if (req->length > sz_xGLXVendorPrivateReq / 4) {
529	int data = (int ) (req + 1);
530	int count = req->length - sz_xGLXVendorPrivateReq / 4;
531
532	__GLX_SWAP_INT_ARRAY(data, count);
533	}
534
535	return (__glXVForwardAllWithReply(cl, pc));
536	}
537
538	int
539	__glXVForwardAllWithReplySwapsv(__GLXclientState * cl, GLbyte * pc)
540	{
541	xGLXVendorPrivateReq req = (xGLXVendorPrivateReq ) pc;
542
543	__GLX_DECLARE_SWAP_VARIABLES;
544	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
545
546	__GLX_SWAP_SHORT(&req->length);
547	__GLX_SWAP_INT(&req->vendorCode);
548	__GLX_SWAP_INT(&req->contextTag);
549
550	swap_vec_element_size = 2;
551
552	/*
553	* swap extra data in request - assuming all data
554	* (if available) are arrays of 4 bytes components !
555	*/
556	if (req->length > sz_xGLXVendorPrivateReq / 4) {
557	int data = (int ) (req + 1);
558	int count = req->length - sz_xGLXVendorPrivateReq / 4;
559
560	__GLX_SWAP_INT_ARRAY(data, count);
561	}
562
563	return (__glXVForwardAllWithReply(cl, pc));
564	}
565
566	int
567	__glXVForwardAllWithReplySwapiv(__GLXclientState * cl, GLbyte * pc)
568	{
569	xGLXVendorPrivateReq req = (xGLXVendorPrivateReq ) pc;
570
571	__GLX_DECLARE_SWAP_VARIABLES;
572	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
573
574	__GLX_SWAP_SHORT(&req->length);
575	__GLX_SWAP_INT(&req->vendorCode);
576	__GLX_SWAP_INT(&req->contextTag);
577
578	swap_vec_element_size = 4;
579
580	/*
581	* swap extra data in request - assuming all data
582	* (if available) are arrays of 4 bytes components !
583	*/
584	if (req->length > sz_xGLXVendorPrivateReq / 4) {
585	int data = (int ) (req + 1);
586	int count = req->length - sz_xGLXVendorPrivateReq / 4;
587
588	__GLX_SWAP_INT_ARRAY(data, count);
589	}
590
591	return (__glXVForwardAllWithReply(cl, pc));
592	}
593
594	int
595	__glXVForwardAllWithReplySwapdv(__GLXclientState * cl, GLbyte * pc)
596	{
597	xGLXVendorPrivateReq req = (xGLXVendorPrivateReq ) pc;
598
599	__GLX_DECLARE_SWAP_VARIABLES;
600	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
601
602	__GLX_SWAP_SHORT(&req->length);
603	__GLX_SWAP_INT(&req->vendorCode);
604	__GLX_SWAP_INT(&req->contextTag);
605
606	swap_vec_element_size = 8;
607
608	/*
609	* swap extra data in request - assuming all data
610	* (if available) are arrays of 4 bytes components !
611	*/
612	if (req->length > sz_xGLXVendorPrivateReq / 4) {
613	int data = (int ) (req + 1);
614	int count = req->length - sz_xGLXVendorPrivateReq / 4;
615
616	__GLX_SWAP_INT_ARRAY(data, count);
617	}
618
619	return (__glXVForwardAllWithReply(cl, pc));
620	}