2 * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
3 * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
12 * The above copyright notice including the dates of first publication and
13 * either this permission notice or a reference to
14 * http://oss.sgi.com/projects/FreeB/
15 * shall be included in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
22 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25 * Except as contained in this notice, the name of Silicon Graphics, Inc.
26 * shall not be used in advertising or otherwise to promote the sale, use or
27 * other dealings in this Software without prior written authorization from
28 * Silicon Graphics, Inc.
31 #ifdef HAVE_DIX_CONFIG_H
32 #include <dix-config.h>
36 #include "glxserver.h"
38 #include <GL/glxtokens.h>
40 #include <pixmapstr.h>
41 #include <windowstr.h>
43 #include "indirect_dispatch.h"
44 #include "indirect_table.h"
45 #include "indirect_util.h"
47 /************************************************************************/
50 ** Byteswapping versions of GLX commands. In most cases they just swap
51 ** the incoming arguments and then call the unswapped routine. For commands
52 ** that have replies, a separate swapping routine for the reply is provided;
53 ** it is called at the end of the unswapped routine.
57 __glXDispSwap_CreateContext(__GLXclientState * cl, GLbyte * pc)
59 ClientPtr client = cl->client;
60 xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;
62 __GLX_DECLARE_SWAP_VARIABLES;
64 REQUEST_SIZE_MATCH(xGLXCreateContextReq);
66 __GLX_SWAP_SHORT(&req->length);
67 __GLX_SWAP_INT(&req->context);
68 __GLX_SWAP_INT(&req->visual);
69 __GLX_SWAP_INT(&req->screen);
70 __GLX_SWAP_INT(&req->shareList);
72 return __glXDisp_CreateContext(cl, pc);
76 __glXDispSwap_CreateNewContext(__GLXclientState * cl, GLbyte * pc)
78 ClientPtr client = cl->client;
79 xGLXCreateNewContextReq *req = (xGLXCreateNewContextReq *) pc;
81 __GLX_DECLARE_SWAP_VARIABLES;
83 REQUEST_SIZE_MATCH(xGLXCreateNewContextReq);
85 __GLX_SWAP_SHORT(&req->length);
86 __GLX_SWAP_INT(&req->context);
87 __GLX_SWAP_INT(&req->fbconfig);
88 __GLX_SWAP_INT(&req->screen);
89 __GLX_SWAP_INT(&req->renderType);
90 __GLX_SWAP_INT(&req->shareList);
92 return __glXDisp_CreateNewContext(cl, pc);
96 __glXDispSwap_CreateContextWithConfigSGIX(__GLXclientState * cl, GLbyte * pc)
98 ClientPtr client = cl->client;
99 xGLXCreateContextWithConfigSGIXReq *req =
100 (xGLXCreateContextWithConfigSGIXReq *) pc;
101 __GLX_DECLARE_SWAP_VARIABLES;
103 REQUEST_SIZE_MATCH(xGLXCreateContextWithConfigSGIXReq);
105 __GLX_SWAP_SHORT(&req->length);
106 __GLX_SWAP_INT(&req->context);
107 __GLX_SWAP_INT(&req->fbconfig);
108 __GLX_SWAP_INT(&req->screen);
109 __GLX_SWAP_INT(&req->renderType);
110 __GLX_SWAP_INT(&req->shareList);
112 return __glXDisp_CreateContextWithConfigSGIX(cl, pc);
116 __glXDispSwap_DestroyContext(__GLXclientState * cl, GLbyte * pc)
118 ClientPtr client = cl->client;
119 xGLXDestroyContextReq *req = (xGLXDestroyContextReq *) pc;
121 __GLX_DECLARE_SWAP_VARIABLES;
123 REQUEST_SIZE_MATCH(xGLXDestroyContextReq);
125 __GLX_SWAP_SHORT(&req->length);
126 __GLX_SWAP_INT(&req->context);
128 return __glXDisp_DestroyContext(cl, pc);
132 __glXDispSwap_MakeCurrent(__GLXclientState * cl, GLbyte * pc)
134 ClientPtr client = cl->client;
135 xGLXMakeCurrentReq *req = (xGLXMakeCurrentReq *) pc;
137 __GLX_DECLARE_SWAP_VARIABLES;
139 REQUEST_SIZE_MATCH(xGLXMakeCurrentReq);
141 __GLX_SWAP_SHORT(&req->length);
142 __GLX_SWAP_INT(&req->drawable);
143 __GLX_SWAP_INT(&req->context);
144 __GLX_SWAP_INT(&req->oldContextTag);
146 return __glXDisp_MakeCurrent(cl, pc);
150 __glXDispSwap_MakeContextCurrent(__GLXclientState * cl, GLbyte * pc)
152 ClientPtr client = cl->client;
153 xGLXMakeContextCurrentReq *req = (xGLXMakeContextCurrentReq *) pc;
155 __GLX_DECLARE_SWAP_VARIABLES;
157 REQUEST_SIZE_MATCH(xGLXMakeContextCurrentReq);
159 __GLX_SWAP_SHORT(&req->length);
160 __GLX_SWAP_INT(&req->drawable);
161 __GLX_SWAP_INT(&req->readdrawable);
162 __GLX_SWAP_INT(&req->context);
163 __GLX_SWAP_INT(&req->oldContextTag);
165 return __glXDisp_MakeContextCurrent(cl, pc);
169 __glXDispSwap_MakeCurrentReadSGI(__GLXclientState * cl, GLbyte * pc)
171 ClientPtr client = cl->client;
172 xGLXMakeCurrentReadSGIReq *req = (xGLXMakeCurrentReadSGIReq *) pc;
174 __GLX_DECLARE_SWAP_VARIABLES;
176 REQUEST_SIZE_MATCH(xGLXMakeCurrentReadSGIReq);
178 __GLX_SWAP_SHORT(&req->length);
179 __GLX_SWAP_INT(&req->drawable);
180 __GLX_SWAP_INT(&req->readable);
181 __GLX_SWAP_INT(&req->context);
182 __GLX_SWAP_INT(&req->oldContextTag);
184 return __glXDisp_MakeCurrentReadSGI(cl, pc);
188 __glXDispSwap_IsDirect(__GLXclientState * cl, GLbyte * pc)
190 ClientPtr client = cl->client;
191 xGLXIsDirectReq *req = (xGLXIsDirectReq *) pc;
193 __GLX_DECLARE_SWAP_VARIABLES;
195 REQUEST_SIZE_MATCH(xGLXIsDirectReq);
197 __GLX_SWAP_SHORT(&req->length);
198 __GLX_SWAP_INT(&req->context);
200 return __glXDisp_IsDirect(cl, pc);
204 __glXDispSwap_QueryVersion(__GLXclientState * cl, GLbyte * pc)
206 ClientPtr client = cl->client;
207 xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) pc;
209 __GLX_DECLARE_SWAP_VARIABLES;
211 REQUEST_SIZE_MATCH(xGLXQueryVersionReq);
213 __GLX_SWAP_SHORT(&req->length);
214 __GLX_SWAP_INT(&req->majorVersion);
215 __GLX_SWAP_INT(&req->minorVersion);
217 return __glXDisp_QueryVersion(cl, pc);
221 __glXDispSwap_WaitGL(__GLXclientState * cl, GLbyte * pc)
223 ClientPtr client = cl->client;
224 xGLXWaitGLReq *req = (xGLXWaitGLReq *) pc;
226 __GLX_DECLARE_SWAP_VARIABLES;
228 REQUEST_SIZE_MATCH(xGLXWaitGLReq);
230 __GLX_SWAP_SHORT(&req->length);
231 __GLX_SWAP_INT(&req->contextTag);
233 return __glXDisp_WaitGL(cl, pc);
237 __glXDispSwap_WaitX(__GLXclientState * cl, GLbyte * pc)
239 ClientPtr client = cl->client;
240 xGLXWaitXReq *req = (xGLXWaitXReq *) pc;
242 __GLX_DECLARE_SWAP_VARIABLES;
244 REQUEST_SIZE_MATCH(xGLXWaitXReq);
246 __GLX_SWAP_SHORT(&req->length);
247 __GLX_SWAP_INT(&req->contextTag);
249 return __glXDisp_WaitX(cl, pc);
253 __glXDispSwap_CopyContext(__GLXclientState * cl, GLbyte * pc)
255 ClientPtr client = cl->client;
256 xGLXCopyContextReq *req = (xGLXCopyContextReq *) pc;
258 __GLX_DECLARE_SWAP_VARIABLES;
260 REQUEST_SIZE_MATCH(xGLXCopyContextReq);
262 __GLX_SWAP_SHORT(&req->length);
263 __GLX_SWAP_INT(&req->source);
264 __GLX_SWAP_INT(&req->dest);
265 __GLX_SWAP_INT(&req->mask);
267 return __glXDisp_CopyContext(cl, pc);
271 __glXDispSwap_GetVisualConfigs(__GLXclientState * cl, GLbyte * pc)
273 ClientPtr client = cl->client;
274 xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;
276 __GLX_DECLARE_SWAP_VARIABLES;
278 REQUEST_SIZE_MATCH(xGLXGetVisualConfigsReq);
280 __GLX_SWAP_INT(&req->screen);
281 return __glXDisp_GetVisualConfigs(cl, pc);
285 __glXDispSwap_GetFBConfigs(__GLXclientState * cl, GLbyte * pc)
287 ClientPtr client = cl->client;
288 xGLXGetFBConfigsReq *req = (xGLXGetFBConfigsReq *) pc;
290 __GLX_DECLARE_SWAP_VARIABLES;
292 REQUEST_SIZE_MATCH(xGLXGetFBConfigsReq);
294 __GLX_SWAP_INT(&req->screen);
295 return __glXDisp_GetFBConfigs(cl, pc);
299 __glXDispSwap_GetFBConfigsSGIX(__GLXclientState * cl, GLbyte * pc)
301 ClientPtr client = cl->client;
302 xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *) pc;
304 __GLX_DECLARE_SWAP_VARIABLES;
306 REQUEST_AT_LEAST_SIZE(xGLXGetFBConfigsSGIXReq);
308 __GLX_SWAP_INT(&req->screen);
309 return __glXDisp_GetFBConfigsSGIX(cl, pc);
313 __glXDispSwap_CreateGLXPixmap(__GLXclientState * cl, GLbyte * pc)
315 ClientPtr client = cl->client;
316 xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc;
318 __GLX_DECLARE_SWAP_VARIABLES;
320 REQUEST_SIZE_MATCH(xGLXCreateGLXPixmapReq);
322 __GLX_SWAP_SHORT(&req->length);
323 __GLX_SWAP_INT(&req->screen);
324 __GLX_SWAP_INT(&req->visual);
325 __GLX_SWAP_INT(&req->pixmap);
326 __GLX_SWAP_INT(&req->glxpixmap);
328 return __glXDisp_CreateGLXPixmap(cl, pc);
332 __glXDispSwap_CreatePixmap(__GLXclientState * cl, GLbyte * pc)
334 ClientPtr client = cl->client;
335 xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
338 __GLX_DECLARE_SWAP_VARIABLES;
339 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
341 REQUEST_AT_LEAST_SIZE(xGLXCreatePixmapReq);
343 __GLX_SWAP_SHORT(&req->length);
344 __GLX_SWAP_INT(&req->screen);
345 __GLX_SWAP_INT(&req->fbconfig);
346 __GLX_SWAP_INT(&req->pixmap);
347 __GLX_SWAP_INT(&req->glxpixmap);
348 __GLX_SWAP_INT(&req->numAttribs);
350 if (req->numAttribs > (UINT32_MAX >> 3)) {
351 client->errorValue = req->numAttribs;
354 REQUEST_FIXED_SIZE(xGLXCreatePixmapReq, req->numAttribs << 3);
355 attribs = (CARD32 *) (req + 1);
356 __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs << 1);
358 return __glXDisp_CreatePixmap(cl, pc);
362 __glXDispSwap_CreateGLXPixmapWithConfigSGIX(__GLXclientState * cl, GLbyte * pc)
364 ClientPtr client = cl->client;
365 xGLXCreateGLXPixmapWithConfigSGIXReq *req =
366 (xGLXCreateGLXPixmapWithConfigSGIXReq *) pc;
367 __GLX_DECLARE_SWAP_VARIABLES;
369 REQUEST_SIZE_MATCH(xGLXCreateGLXPixmapWithConfigSGIXReq);
371 __GLX_SWAP_SHORT(&req->length);
372 __GLX_SWAP_INT(&req->screen);
373 __GLX_SWAP_INT(&req->fbconfig);
374 __GLX_SWAP_INT(&req->pixmap);
375 __GLX_SWAP_INT(&req->glxpixmap);
377 return __glXDisp_CreateGLXPixmapWithConfigSGIX(cl, pc);
381 __glXDispSwap_DestroyGLXPixmap(__GLXclientState * cl, GLbyte * pc)
383 ClientPtr client = cl->client;
384 xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;
386 __GLX_DECLARE_SWAP_VARIABLES;
388 REQUEST_SIZE_MATCH(xGLXDestroyGLXPixmapReq);
390 __GLX_SWAP_SHORT(&req->length);
391 __GLX_SWAP_INT(&req->glxpixmap);
393 return __glXDisp_DestroyGLXPixmap(cl, pc);
397 __glXDispSwap_DestroyPixmap(__GLXclientState * cl, GLbyte * pc)
399 ClientPtr client = cl->client;
400 xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;
402 __GLX_DECLARE_SWAP_VARIABLES;
404 REQUEST_AT_LEAST_SIZE(xGLXDestroyGLXPixmapReq);
406 __GLX_SWAP_SHORT(&req->length);
407 __GLX_SWAP_INT(&req->glxpixmap);
409 return __glXDisp_DestroyGLXPixmap(cl, pc);
413 __glXDispSwap_QueryContext(__GLXclientState * cl, GLbyte * pc)
415 ClientPtr client = cl->client;
416 xGLXQueryContextReq *req = (xGLXQueryContextReq *) pc;
418 __GLX_DECLARE_SWAP_VARIABLES;
420 REQUEST_SIZE_MATCH(xGLXQueryContextReq);
422 __GLX_SWAP_INT(&req->context);
424 return __glXDisp_QueryContext(cl, pc);
428 __glXDispSwap_CreatePbuffer(__GLXclientState * cl, GLbyte * pc)
430 ClientPtr client = cl->client;
431 xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *) pc;
433 __GLX_DECLARE_SWAP_VARIABLES;
434 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
437 REQUEST_AT_LEAST_SIZE(xGLXCreatePbufferReq);
439 __GLX_SWAP_INT(&req->screen);
440 __GLX_SWAP_INT(&req->fbconfig);
441 __GLX_SWAP_INT(&req->pbuffer);
442 __GLX_SWAP_INT(&req->numAttribs);
444 if (req->numAttribs > (UINT32_MAX >> 3)) {
445 client->errorValue = req->numAttribs;
448 REQUEST_FIXED_SIZE(xGLXCreatePbufferReq, req->numAttribs << 3);
449 attribs = (CARD32 *) (req + 1);
450 __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs << 1);
452 return __glXDisp_CreatePbuffer(cl, pc);
456 __glXDispSwap_CreateGLXPbufferSGIX(__GLXclientState * cl, GLbyte * pc)
458 ClientPtr client = cl->client;
459 xGLXCreateGLXPbufferSGIXReq *req = (xGLXCreateGLXPbufferSGIXReq *) pc;
461 __GLX_DECLARE_SWAP_VARIABLES;
463 REQUEST_AT_LEAST_SIZE(xGLXCreateGLXPbufferSGIXReq);
465 __GLX_SWAP_INT(&req->screen);
466 __GLX_SWAP_INT(&req->fbconfig);
467 __GLX_SWAP_INT(&req->pbuffer);
468 __GLX_SWAP_INT(&req->width);
469 __GLX_SWAP_INT(&req->height);
471 return __glXDisp_CreateGLXPbufferSGIX(cl, pc);
475 __glXDispSwap_DestroyPbuffer(__GLXclientState * cl, GLbyte * pc)
477 ClientPtr client = cl->client;
478 xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) pc;
480 __GLX_DECLARE_SWAP_VARIABLES;
482 REQUEST_SIZE_MATCH(xGLXDestroyPbufferReq);
484 __GLX_SWAP_INT(&req->pbuffer);
486 return __glXDisp_DestroyPbuffer(cl, pc);
490 __glXDispSwap_DestroyGLXPbufferSGIX(__GLXclientState * cl, GLbyte * pc)
492 ClientPtr client = cl->client;
493 xGLXDestroyGLXPbufferSGIXReq *req = (xGLXDestroyGLXPbufferSGIXReq *) pc;
495 __GLX_DECLARE_SWAP_VARIABLES;
497 REQUEST_SIZE_MATCH(xGLXDestroyGLXPbufferSGIXReq);
499 __GLX_SWAP_INT(&req->pbuffer);
501 return __glXDisp_DestroyGLXPbufferSGIX(cl, pc);
505 __glXDispSwap_ChangeDrawableAttributes(__GLXclientState * cl, GLbyte * pc)
507 ClientPtr client = cl->client;
508 xGLXChangeDrawableAttributesReq *req =
509 (xGLXChangeDrawableAttributesReq *) pc;
510 __GLX_DECLARE_SWAP_VARIABLES;
511 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
514 REQUEST_AT_LEAST_SIZE(xGLXChangeDrawableAttributesReq);
516 __GLX_SWAP_INT(&req->drawable);
517 __GLX_SWAP_INT(&req->numAttribs);
519 if (req->numAttribs > (UINT32_MAX >> 3)) {
520 client->errorValue = req->numAttribs;
523 if (((sizeof(xGLXChangeDrawableAttributesReq) +
524 (req->numAttribs << 3)) >> 2) < client->req_len)
527 attribs = (CARD32 *) (req + 1);
528 __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs << 1);
530 return __glXDisp_ChangeDrawableAttributes(cl, pc);
534 __glXDispSwap_ChangeDrawableAttributesSGIX(__GLXclientState * cl, GLbyte * pc)
536 ClientPtr client = cl->client;
537 xGLXChangeDrawableAttributesSGIXReq *req =
538 (xGLXChangeDrawableAttributesSGIXReq *) pc;
539 __GLX_DECLARE_SWAP_VARIABLES;
540 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
543 REQUEST_AT_LEAST_SIZE(xGLXChangeDrawableAttributesSGIXReq);
545 __GLX_SWAP_INT(&req->drawable);
546 __GLX_SWAP_INT(&req->numAttribs);
548 if (req->numAttribs > (UINT32_MAX >> 3)) {
549 client->errorValue = req->numAttribs;
552 REQUEST_FIXED_SIZE(xGLXChangeDrawableAttributesSGIXReq,
553 req->numAttribs << 3);
554 attribs = (CARD32 *) (req + 1);
555 __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs << 1);
557 return __glXDisp_ChangeDrawableAttributesSGIX(cl, pc);
561 __glXDispSwap_CreateWindow(__GLXclientState * cl, GLbyte * pc)
563 ClientPtr client = cl->client;
564 xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
566 __GLX_DECLARE_SWAP_VARIABLES;
567 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
570 REQUEST_AT_LEAST_SIZE(xGLXCreateWindowReq);
572 __GLX_SWAP_INT(&req->screen);
573 __GLX_SWAP_INT(&req->fbconfig);
574 __GLX_SWAP_INT(&req->window);
575 __GLX_SWAP_INT(&req->glxwindow);
576 __GLX_SWAP_INT(&req->numAttribs);
578 if (req->numAttribs > (UINT32_MAX >> 3)) {
579 client->errorValue = req->numAttribs;
582 REQUEST_FIXED_SIZE(xGLXCreateWindowReq, req->numAttribs << 3);
583 attribs = (CARD32 *) (req + 1);
584 __GLX_SWAP_INT_ARRAY(attribs, req->numAttribs << 1);
586 return __glXDisp_CreateWindow(cl, pc);
590 __glXDispSwap_DestroyWindow(__GLXclientState * cl, GLbyte * pc)
592 ClientPtr client = cl->client;
593 xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc;
595 __GLX_DECLARE_SWAP_VARIABLES;
597 REQUEST_AT_LEAST_SIZE(xGLXDestroyWindowReq);
599 __GLX_SWAP_INT(&req->glxwindow);
601 return __glXDisp_DestroyWindow(cl, pc);
605 __glXDispSwap_SwapBuffers(__GLXclientState * cl, GLbyte * pc)
607 ClientPtr client = cl->client;
608 xGLXSwapBuffersReq *req = (xGLXSwapBuffersReq *) pc;
610 __GLX_DECLARE_SWAP_VARIABLES;
612 REQUEST_SIZE_MATCH(xGLXSwapBuffersReq);
614 __GLX_SWAP_SHORT(&req->length);
615 __GLX_SWAP_INT(&req->contextTag);
616 __GLX_SWAP_INT(&req->drawable);
618 return __glXDisp_SwapBuffers(cl, pc);
622 __glXDispSwap_UseXFont(__GLXclientState * cl, GLbyte * pc)
624 ClientPtr client = cl->client;
625 xGLXUseXFontReq *req = (xGLXUseXFontReq *) pc;
627 __GLX_DECLARE_SWAP_VARIABLES;
629 REQUEST_SIZE_MATCH(xGLXUseXFontReq);
631 __GLX_SWAP_SHORT(&req->length);
632 __GLX_SWAP_INT(&req->contextTag);
633 __GLX_SWAP_INT(&req->font);
634 __GLX_SWAP_INT(&req->first);
635 __GLX_SWAP_INT(&req->count);
636 __GLX_SWAP_INT(&req->listBase);
638 return __glXDisp_UseXFont(cl, pc);
642 __glXDispSwap_QueryExtensionsString(__GLXclientState * cl, GLbyte * pc)
644 ClientPtr client = cl->client;
645 xGLXQueryExtensionsStringReq *req = (xGLXQueryExtensionsStringReq *) pc;
647 __GLX_DECLARE_SWAP_VARIABLES;
649 REQUEST_SIZE_MATCH(xGLXQueryExtensionsStringReq);
651 __GLX_SWAP_SHORT(&req->length);
652 __GLX_SWAP_INT(&req->screen);
654 return __glXDisp_QueryExtensionsString(cl, pc);
658 __glXDispSwap_QueryServerString(__GLXclientState * cl, GLbyte * pc)
660 ClientPtr client = cl->client;
661 xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *) pc;
663 __GLX_DECLARE_SWAP_VARIABLES;
665 REQUEST_SIZE_MATCH(xGLXQueryServerStringReq);
667 __GLX_SWAP_SHORT(&req->length);
668 __GLX_SWAP_INT(&req->screen);
669 __GLX_SWAP_INT(&req->name);
671 return __glXDisp_QueryServerString(cl, pc);
675 __glXDispSwap_ClientInfo(__GLXclientState * cl, GLbyte * pc)
677 ClientPtr client = cl->client;
678 xGLXClientInfoReq *req = (xGLXClientInfoReq *) pc;
680 __GLX_DECLARE_SWAP_VARIABLES;
682 REQUEST_AT_LEAST_SIZE(xGLXClientInfoReq);
684 __GLX_SWAP_SHORT(&req->length);
685 __GLX_SWAP_INT(&req->major);
686 __GLX_SWAP_INT(&req->minor);
687 __GLX_SWAP_INT(&req->numbytes);
689 return __glXDisp_ClientInfo(cl, pc);
693 __glXDispSwap_QueryContextInfoEXT(__GLXclientState * cl, GLbyte * pc)
695 ClientPtr client = cl->client;
696 xGLXQueryContextInfoEXTReq *req = (xGLXQueryContextInfoEXTReq *) pc;
698 __GLX_DECLARE_SWAP_VARIABLES;
700 REQUEST_SIZE_MATCH(xGLXQueryContextInfoEXTReq);
702 __GLX_SWAP_SHORT(&req->length);
703 __GLX_SWAP_INT(&req->context);
705 return __glXDisp_QueryContextInfoEXT(cl, pc);
709 __glXDispSwap_BindTexImageEXT(__GLXclientState * cl, GLbyte * pc)
711 ClientPtr client = cl->client;
712 xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
717 __GLX_DECLARE_SWAP_VARIABLES;
719 if ((sizeof(xGLXVendorPrivateReq) + 12) >> 2 > client->req_len)
722 pc += __GLX_VENDPRIV_HDR_SIZE;
724 drawId = ((GLXDrawable *) (pc));
725 buffer = ((int *) (pc + 4));
726 num_attribs = ((CARD32 *) (pc + 8));
728 __GLX_SWAP_SHORT(&req->length);
729 __GLX_SWAP_INT(&req->contextTag);
730 __GLX_SWAP_INT(drawId);
731 __GLX_SWAP_INT(buffer);
732 __GLX_SWAP_INT(num_attribs);
734 return __glXDisp_BindTexImageEXT(cl, (GLbyte *) pc);
738 __glXDispSwap_ReleaseTexImageEXT(__GLXclientState * cl, GLbyte * pc)
740 ClientPtr client = cl->client;
741 xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
745 __GLX_DECLARE_SWAP_VARIABLES;
747 REQUEST_FIXED_SIZE(xGLXVendorPrivateReq, 8);
749 pc += __GLX_VENDPRIV_HDR_SIZE;
751 drawId = ((GLXDrawable *) (pc));
752 buffer = ((int *) (pc + 4));
754 __GLX_SWAP_SHORT(&req->length);
755 __GLX_SWAP_INT(&req->contextTag);
756 __GLX_SWAP_INT(drawId);
757 __GLX_SWAP_INT(buffer);
759 return __glXDisp_ReleaseTexImageEXT(cl, (GLbyte *) pc);
763 __glXDispSwap_CopySubBufferMESA(__GLXclientState * cl, GLbyte * pc)
765 ClientPtr client = cl->client;
766 xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
770 __GLX_DECLARE_SWAP_VARIABLES;
772 REQUEST_FIXED_SIZE(xGLXVendorPrivateReq, 20);
777 pc += __GLX_VENDPRIV_HDR_SIZE;
779 __GLX_SWAP_SHORT(&req->length);
780 __GLX_SWAP_INT(&req->contextTag);
782 __GLX_SWAP_INT(pc + 4);
783 __GLX_SWAP_INT(pc + 8);
784 __GLX_SWAP_INT(pc + 12);
785 __GLX_SWAP_INT(pc + 16);
787 return __glXDisp_CopySubBufferMESA(cl, pc);
792 __glXDispSwap_GetDrawableAttributesSGIX(__GLXclientState * cl, GLbyte * pc)
794 ClientPtr client = cl->client;
795 xGLXVendorPrivateWithReplyReq *req = (xGLXVendorPrivateWithReplyReq *) pc;
798 __GLX_DECLARE_SWAP_VARIABLES;
800 REQUEST_SIZE_MATCH(xGLXGetDrawableAttributesSGIXReq);
802 data = (CARD32 *) (req + 1);
803 __GLX_SWAP_SHORT(&req->length);
804 __GLX_SWAP_INT(&req->contextTag);
805 __GLX_SWAP_INT(data);
807 return __glXDisp_GetDrawableAttributesSGIX(cl, pc);
811 __glXDispSwap_GetDrawableAttributes(__GLXclientState * cl, GLbyte * pc)
813 ClientPtr client = cl->client;
814 xGLXGetDrawableAttributesReq *req = (xGLXGetDrawableAttributesReq *) pc;
816 __GLX_DECLARE_SWAP_VARIABLES;
818 REQUEST_AT_LEAST_SIZE(xGLXGetDrawableAttributesReq);
820 __GLX_SWAP_SHORT(&req->length);
821 __GLX_SWAP_INT(&req->drawable);
823 return __glXDisp_GetDrawableAttributes(cl, pc);
826 /************************************************************************/
833 __glXSwapMakeCurrentReply(ClientPtr client, xGLXMakeCurrentReply * reply)
835 __GLX_DECLARE_SWAP_VARIABLES;
836 __GLX_SWAP_SHORT(&reply->sequenceNumber);
837 __GLX_SWAP_INT(&reply->length);
838 __GLX_SWAP_INT(&reply->contextTag);
839 WriteToClient(client, sz_xGLXMakeCurrentReply, reply);
843 __glXSwapIsDirectReply(ClientPtr client, xGLXIsDirectReply * reply)
845 __GLX_DECLARE_SWAP_VARIABLES;
846 __GLX_SWAP_SHORT(&reply->sequenceNumber);
847 __GLX_SWAP_INT(&reply->length);
848 WriteToClient(client, sz_xGLXIsDirectReply, reply);
852 __glXSwapQueryVersionReply(ClientPtr client, xGLXQueryVersionReply * reply)
854 __GLX_DECLARE_SWAP_VARIABLES;
855 __GLX_SWAP_SHORT(&reply->sequenceNumber);
856 __GLX_SWAP_INT(&reply->length);
857 __GLX_SWAP_INT(&reply->majorVersion);
858 __GLX_SWAP_INT(&reply->minorVersion);
859 WriteToClient(client, sz_xGLXQueryVersionReply, reply);
863 glxSwapQueryExtensionsStringReply(ClientPtr client,
864 xGLXQueryExtensionsStringReply * reply,
867 int length = reply->length;
869 __GLX_DECLARE_SWAP_VARIABLES;
870 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
871 __GLX_SWAP_SHORT(&reply->sequenceNumber);
872 __GLX_SWAP_INT(&reply->length);
873 __GLX_SWAP_INT(&reply->n);
874 WriteToClient(client, sz_xGLXQueryExtensionsStringReply, reply);
875 __GLX_SWAP_INT_ARRAY((int *) buf, length);
876 WriteToClient(client, length << 2, buf);
880 glxSwapQueryServerStringReply(ClientPtr client,
881 xGLXQueryServerStringReply * reply, char *buf)
883 int length = reply->length;
885 __GLX_DECLARE_SWAP_VARIABLES;
886 __GLX_SWAP_SHORT(&reply->sequenceNumber);
887 __GLX_SWAP_INT(&reply->length);
888 __GLX_SWAP_INT(&reply->n);
889 WriteToClient(client, sz_xGLXQueryServerStringReply, reply);
890 /** no swap is needed for an array of chars **/
891 /* __GLX_SWAP_INT_ARRAY((int *)buf, length); */
892 WriteToClient(client, length << 2, buf);
896 __glXSwapQueryContextInfoEXTReply(ClientPtr client,
897 xGLXQueryContextInfoEXTReply * reply,
900 int length = reply->length;
902 __GLX_DECLARE_SWAP_VARIABLES;
903 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
904 __GLX_SWAP_SHORT(&reply->sequenceNumber);
905 __GLX_SWAP_INT(&reply->length);
906 __GLX_SWAP_INT(&reply->n);
907 WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, reply);
908 __GLX_SWAP_INT_ARRAY((int *) buf, length);
909 WriteToClient(client, length << 2, buf);
913 __glXSwapGetDrawableAttributesReply(ClientPtr client,
914 xGLXGetDrawableAttributesReply * reply,
917 int length = reply->length;
919 __GLX_DECLARE_SWAP_VARIABLES;
920 __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
921 __GLX_SWAP_SHORT(&reply->sequenceNumber);
922 __GLX_SWAP_INT(&reply->length);
923 __GLX_SWAP_INT(&reply->numAttribs);
924 WriteToClient(client, sz_xGLXGetDrawableAttributesReply, reply);
925 __GLX_SWAP_INT_ARRAY((int *) buf, length);
926 WriteToClient(client, length << 2, buf);
929 /************************************************************************/
932 ** Render and Renderlarge are not in the GLX API. They are used by the GLX
933 ** client library to send batches of GL rendering commands.
937 __glXDispSwap_Render(__GLXclientState * cl, GLbyte * pc)
939 return __glXDisp_Render(cl, pc);
943 ** Execute a large rendering request (one that spans multiple X requests).
946 __glXDispSwap_RenderLarge(__GLXclientState * cl, GLbyte * pc)
948 return __glXDisp_RenderLarge(cl, pc);
951 /************************************************************************/
954 ** No support is provided for the vendor-private requests other than
955 ** allocating these entry points in the dispatch table.
959 __glXDispSwap_VendorPrivate(__GLXclientState * cl, GLbyte * pc)
961 xGLXVendorPrivateReq *req;
963 __GLXdispatchVendorPrivProcPtr proc;
965 __GLX_DECLARE_SWAP_VARIABLES;
967 req = (xGLXVendorPrivateReq *) pc;
968 __GLX_SWAP_SHORT(&req->length);
969 __GLX_SWAP_INT(&req->vendorCode);
971 vendorcode = req->vendorCode;
973 proc = (__GLXdispatchVendorPrivProcPtr)
974 __glXGetProtocolDecodeFunction(&VendorPriv_dispatch_info,
977 (*proc) (cl, (GLbyte *) req);
981 cl->client->errorValue = req->vendorCode;
982 return __glXError(GLXUnsupportedPrivateRequest);
986 __glXDispSwap_VendorPrivateWithReply(__GLXclientState * cl, GLbyte * pc)
988 xGLXVendorPrivateWithReplyReq *req;
990 __GLXdispatchVendorPrivProcPtr proc;
992 __GLX_DECLARE_SWAP_VARIABLES;
994 req = (xGLXVendorPrivateWithReplyReq *) pc;
995 __GLX_SWAP_SHORT(&req->length);
996 __GLX_SWAP_INT(&req->vendorCode);
998 vendorcode = req->vendorCode;
1000 proc = (__GLXdispatchVendorPrivProcPtr)
1001 __glXGetProtocolDecodeFunction(&VendorPriv_dispatch_info,
1004 return (*proc) (cl, (GLbyte *) req);
1007 cl->client->errorValue = req->vendorCode;
1008 return __glXError(GLXUnsupportedPrivateRequest);