← Back to branch summary

~ubuntu-branches/ubuntu/edgy/xorg-server/edgy-updates

« back to all changes in this revision

Viewing changes to GL/glx/g_singleswap.c

  • Committer: Bazaar Package Importer
  • Author(s): Rodrigo Parra Novo
  • Date: 2006-07-25 20:06:28 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20060725200628-gjmmd9gxfxdc4ejs
Tags: 1:1.1.1-0ubuntu1
* New Upstream version
* Changed Build-Depends from mesa-swrast-source to mesa-swx11-source,
  following Debian package nomenclature
* Re-did 12_security_policy_in_etc.diff for 1.1.1
* Dropped 15_security_allocate_local.diff (applied upstream)
* Dropped 16_SECURITY_setuid.diff (applied upstream)
* Dropped 000_ubuntu_fix_read_kernel_mapping.patch (applied upstream)
* Dropped 002_ubuntu_fix_for_certain_intel_chipsets.patch (applied upstream)
* Updated versioned Build-Depends on mesa-swx11-source to version
  6.5.0.cvs.20060725-0ubuntu1
* Added arrayobj.c, arrayobj.h, bitset.h & rbadaptors.h to
  GL/symlink-mesa.sh (linked from mesa-swx11-source)
* Added arrayobj.c to default build target on GL/mesa/main

Show diffs side-by-side

added added

removed removed

Lines of Context:
GL/glx/g_singleswap.c
1
 
/* $XFree86: xc/programs/Xserver/GL/glx/g_singleswap.c,v 1.4tsi Exp $ */
2
 
/*
3
 
** License Applicability. Except to the extent portions of this file are
4
 
** made subject to an alternative license as permitted in the SGI Free
5
 
** Software License B, Version 1.1 (the "License"), the contents of this
6
 
** file are subject only to the provisions of the License. You may not use
7
 
** this file except in compliance with the License. You may obtain a copy
8
 
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
9
 
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
10
 
** 
11
 
** http://oss.sgi.com/projects/FreeB
12
 
** 
13
 
** Note that, as provided in the License, the Software is distributed on an
14
 
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
15
 
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
16
 
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
17
 
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
18
 
** 
19
 
** Original Code. The Original Code is: OpenGL Sample Implementation,
20
 
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
21
 
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
22
 
** Copyright in any portions created by third parties is as indicated
23
 
** elsewhere herein. All Rights Reserved.
24
 
** 
25
 
** Additional Notice Provisions: This software was created using the
26
 
** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
27
 
** not been independently verified as being compliant with the OpenGL(R)
28
 
** version 1.2.1 Specification.
29
 
*/
30
 
 
31
 
#define NEED_REPLIES
32
 
#ifdef HAVE_DIX_CONFIG_H
33
 
#include <dix-config.h>
34
 
#endif
35
 
 
36
 
#include "glxserver.h"
37
 
#include "glxext.h"
38
 
#include "g_disptab.h"
39
 
#include "g_disptab_EXT.h"
40
 
#include "unpack.h"
41
 
#include "impsize.h"
42
 
#include "singlesize.h"
43
 
 
44
 
int __glXDispSwap_NewList(__GLXclientState *cl, GLbyte *pc)
45
 
{
46
 
        __GLXcontext *cx;
47
 
        int error;
48
 
        __GLX_DECLARE_SWAP_VARIABLES;
49
 
 
50
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
51
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
52
 
        if (!cx) {
53
 
                return error;
54
 
        }
55
 
        pc += __GLX_SINGLE_HDR_SIZE;
56
 
        __GLX_SWAP_INT(pc + 0);
57
 
        __GLX_SWAP_INT(pc + 4);
58
 
 
59
 
        glNewList( 
60
 
                *(GLuint   *)(pc + 0),
61
 
                *(GLenum   *)(pc + 4)
62
 
        );
63
 
        __GLX_NOTE_UNFLUSHED_CMDS(cx);
64
 
        return Success;
65
 
}
66
 
 
67
 
int __glXDispSwap_EndList(__GLXclientState *cl, GLbyte *pc)
68
 
{
69
 
        __GLXcontext *cx;
70
 
        int error;
71
 
        __GLX_DECLARE_SWAP_VARIABLES;
72
 
 
73
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
74
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
75
 
        if (!cx) {
76
 
                return error;
77
 
        }
78
 
 
79
 
        glEndList( 
80
 
        );
81
 
        return Success;
82
 
}
83
 
 
84
 
int __glXDispSwap_DeleteLists(__GLXclientState *cl, GLbyte *pc)
85
 
{
86
 
        __GLXcontext *cx;
87
 
        int error;
88
 
        __GLX_DECLARE_SWAP_VARIABLES;
89
 
 
90
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
91
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
92
 
        if (!cx) {
93
 
                return error;
94
 
        }
95
 
        pc += __GLX_SINGLE_HDR_SIZE;
96
 
        __GLX_SWAP_INT(pc + 0);
97
 
        __GLX_SWAP_INT(pc + 4);
98
 
 
99
 
        glDeleteLists( 
100
 
                *(GLuint   *)(pc + 0),
101
 
                *(GLsizei  *)(pc + 4)
102
 
        );
103
 
        __GLX_NOTE_UNFLUSHED_CMDS(cx);
104
 
        return Success;
105
 
}
106
 
 
107
 
int __glXDispSwap_GenLists(__GLXclientState *cl, GLbyte *pc)
108
 
{
109
 
        GLuint retval;
110
 
        __GLXcontext *cx;
111
 
        ClientPtr client = cl->client;
112
 
        int error;
113
 
        __GLX_DECLARE_SWAP_VARIABLES;
114
 
 
115
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
116
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
117
 
        if (!cx) {
118
 
                return error;
119
 
        }
120
 
        pc += __GLX_SINGLE_HDR_SIZE;
121
 
        __GLX_SWAP_INT(pc + 0);
122
 
 
123
 
        retval =
124
 
        glGenLists( 
125
 
                *(GLsizei  *)(pc + 0)
126
 
        );
127
 
        __GLX_PUT_RETVAL(retval);
128
 
        __GLX_SWAP_REPLY_RETVAL();
129
 
        __GLX_BEGIN_REPLY(0);
130
 
        __GLX_SWAP_REPLY_HEADER();
131
 
        __GLX_SEND_HEADER();
132
 
        return Success;
133
 
}
134
 
 
135
 
int __glXDispSwap_PixelStoref(__GLXclientState *cl, GLbyte *pc)
136
 
{
137
 
        __GLXcontext *cx;
138
 
        int error;
139
 
        __GLX_DECLARE_SWAP_VARIABLES;
140
 
 
141
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
142
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
143
 
        if (!cx) {
144
 
                return error;
145
 
        }
146
 
        pc += __GLX_SINGLE_HDR_SIZE;
147
 
        __GLX_SWAP_INT(pc + 0);
148
 
        __GLX_SWAP_FLOAT(pc + 4);
149
 
 
150
 
        glPixelStoref( 
151
 
                *(GLenum   *)(pc + 0),
152
 
                *(GLfloat  *)(pc + 4)
153
 
        );
154
 
        __GLX_NOTE_UNFLUSHED_CMDS(cx);
155
 
        return Success;
156
 
}
157
 
 
158
 
int __glXDispSwap_PixelStorei(__GLXclientState *cl, GLbyte *pc)
159
 
{
160
 
        __GLXcontext *cx;
161
 
        int error;
162
 
        __GLX_DECLARE_SWAP_VARIABLES;
163
 
 
164
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
165
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
166
 
        if (!cx) {
167
 
                return error;
168
 
        }
169
 
        pc += __GLX_SINGLE_HDR_SIZE;
170
 
        __GLX_SWAP_INT(pc + 0);
171
 
        __GLX_SWAP_INT(pc + 4);
172
 
 
173
 
        glPixelStorei( 
174
 
                *(GLenum   *)(pc + 0),
175
 
                *(GLint    *)(pc + 4)
176
 
        );
177
 
        __GLX_NOTE_UNFLUSHED_CMDS(cx);
178
 
        return Success;
179
 
}
180
 
 
181
 
int __glXDispSwap_GetBooleanv(__GLXclientState *cl, GLbyte *pc)
182
 
{
183
 
        GLenum pname;
184
 
        GLint compsize;
185
 
        __GLXcontext *cx;
186
 
        ClientPtr client = cl->client;
187
 
        int error;
188
 
        GLboolean answerBuffer[200];
189
 
        char *answer;
190
 
        __GLX_DECLARE_SWAP_VARIABLES;
191
 
 
192
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
193
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
194
 
        if (!cx) {
195
 
                return error;
196
 
        }
197
 
        pc += __GLX_SINGLE_HDR_SIZE;
198
 
        __GLX_SWAP_INT(pc + 0);
199
 
        pname = *(GLenum *)(pc + 0);
200
 
        compsize = __glGetBooleanv_size(pname);
201
 
        if (compsize < 0) compsize = 0;
202
 
 
203
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
204
 
        __glXClearErrorOccured();
205
 
        glGetBooleanv( 
206
 
                *(GLenum   *)(pc + 0),
207
 
                (GLboolean *) answer
208
 
        );
209
 
        if (__glXErrorOccured()) {
210
 
            __GLX_BEGIN_REPLY(0);
211
 
            __GLX_SWAP_REPLY_HEADER();
212
 
            __GLX_PUT_SIZE(0);
213
 
            __GLX_SEND_HEADER();
214
 
        } else if (compsize == 1) {
215
 
            __GLX_BEGIN_REPLY(0);
216
 
            __GLX_SWAP_REPLY_HEADER();
217
 
            __GLX_PUT_SIZE(1);
218
 
            __GLX_SWAP_REPLY_SIZE();
219
 
            __GLX_PUT_BYTE();
220
 
            __GLX_SEND_HEADER();
221
 
        } else {
222
 
            __GLX_BEGIN_REPLY(compsize);
223
 
            __GLX_SWAP_REPLY_HEADER();
224
 
            __GLX_PUT_SIZE(compsize);
225
 
            __GLX_SWAP_REPLY_SIZE();
226
 
            __GLX_SEND_HEADER();
227
 
            __GLX_SEND_BYTE_ARRAY(compsize);
228
 
        }
229
 
        return Success;
230
 
}
231
 
 
232
 
int __glXDispSwap_GetDoublev(__GLXclientState *cl, GLbyte *pc)
233
 
{
234
 
        GLenum pname;
235
 
        GLint compsize;
236
 
        __GLXcontext *cx;
237
 
        ClientPtr client = cl->client;
238
 
        int error;
239
 
        GLdouble answerBuffer[200];
240
 
        char *answer;
241
 
        __GLX_DECLARE_SWAP_VARIABLES;
242
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
243
 
 
244
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
245
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
246
 
        if (!cx) {
247
 
                return error;
248
 
        }
249
 
        pc += __GLX_SINGLE_HDR_SIZE;
250
 
        __GLX_SWAP_INT(pc + 0);
251
 
        pname = *(GLenum *)(pc + 0);
252
 
        compsize = __glGetDoublev_size(pname);
253
 
        if (compsize < 0) compsize = 0;
254
 
 
255
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*8,8);
256
 
        __glXClearErrorOccured();
257
 
        glGetDoublev( 
258
 
                *(GLenum   *)(pc + 0),
259
 
                (GLdouble *) answer
260
 
        );
261
 
        __GLX_SWAP_DOUBLE_ARRAY(answer, compsize);
262
 
        if (__glXErrorOccured()) {
263
 
            __GLX_BEGIN_REPLY(0);
264
 
            __GLX_SWAP_REPLY_HEADER();
265
 
            __GLX_PUT_SIZE(0);
266
 
            __GLX_SEND_HEADER();
267
 
        } else if (compsize == 1) {
268
 
            __GLX_BEGIN_REPLY(0);
269
 
            __GLX_SWAP_REPLY_HEADER();
270
 
            __GLX_PUT_SIZE(1);
271
 
            __GLX_SWAP_REPLY_SIZE();
272
 
            __GLX_PUT_DOUBLE();
273
 
            __GLX_SEND_HEADER();
274
 
        } else {
275
 
            __GLX_BEGIN_REPLY(compsize*8);
276
 
            __GLX_SWAP_REPLY_HEADER();
277
 
            __GLX_PUT_SIZE(compsize);
278
 
            __GLX_SWAP_REPLY_SIZE();
279
 
            __GLX_SEND_HEADER();
280
 
            __GLX_SEND_DOUBLE_ARRAY(compsize);
281
 
        }
282
 
        return Success;
283
 
}
284
 
 
285
 
int __glXDispSwap_GetError(__GLXclientState *cl, GLbyte *pc)
286
 
{
287
 
        GLenum retval;
288
 
        __GLXcontext *cx;
289
 
        ClientPtr client = cl->client;
290
 
        int error;
291
 
        __GLX_DECLARE_SWAP_VARIABLES;
292
 
 
293
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
294
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
295
 
        if (!cx) {
296
 
                return error;
297
 
        }
298
 
 
299
 
        retval =
300
 
        glGetError( 
301
 
        );
302
 
        __GLX_PUT_RETVAL(retval);
303
 
        __GLX_SWAP_REPLY_RETVAL();
304
 
        __GLX_BEGIN_REPLY(0);
305
 
        __GLX_SWAP_REPLY_HEADER();
306
 
        __GLX_SEND_HEADER();
307
 
        return Success;
308
 
}
309
 
 
310
 
int __glXDispSwap_GetFloatv(__GLXclientState *cl, GLbyte *pc)
311
 
{
312
 
        GLenum pname;
313
 
        GLint compsize;
314
 
        __GLXcontext *cx;
315
 
        ClientPtr client = cl->client;
316
 
        int error;
317
 
        GLfloat answerBuffer[200];
318
 
        char *answer;
319
 
        __GLX_DECLARE_SWAP_VARIABLES;
320
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
321
 
 
322
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
323
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
324
 
        if (!cx) {
325
 
                return error;
326
 
        }
327
 
        pc += __GLX_SINGLE_HDR_SIZE;
328
 
        __GLX_SWAP_INT(pc + 0);
329
 
        pname = *(GLenum *)(pc + 0);
330
 
        compsize = __glGetFloatv_size(pname);
331
 
        if (compsize < 0) compsize = 0;
332
 
 
333
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
334
 
        __glXClearErrorOccured();
335
 
        glGetFloatv( 
336
 
                *(GLenum   *)(pc + 0),
337
 
                (GLfloat  *) answer
338
 
        );
339
 
        __GLX_SWAP_FLOAT_ARRAY(answer, compsize);
340
 
        if (__glXErrorOccured()) {
341
 
            __GLX_BEGIN_REPLY(0);
342
 
            __GLX_SWAP_REPLY_HEADER();
343
 
            __GLX_PUT_SIZE(0);
344
 
            __GLX_SEND_HEADER();
345
 
        } else if (compsize == 1) {
346
 
            __GLX_BEGIN_REPLY(0);
347
 
            __GLX_SWAP_REPLY_HEADER();
348
 
            __GLX_PUT_SIZE(1);
349
 
            __GLX_SWAP_REPLY_SIZE();
350
 
            __GLX_PUT_FLOAT();
351
 
            __GLX_SEND_HEADER();
352
 
        } else {
353
 
            __GLX_BEGIN_REPLY(compsize*4);
354
 
            __GLX_SWAP_REPLY_HEADER();
355
 
            __GLX_PUT_SIZE(compsize);
356
 
            __GLX_SWAP_REPLY_SIZE();
357
 
            __GLX_SEND_HEADER();
358
 
            __GLX_SEND_FLOAT_ARRAY(compsize);
359
 
        }
360
 
        return Success;
361
 
}
362
 
 
363
 
int __glXDispSwap_GetIntegerv(__GLXclientState *cl, GLbyte *pc)
364
 
{
365
 
        GLenum pname;
366
 
        GLint compsize;
367
 
        __GLXcontext *cx;
368
 
        ClientPtr client = cl->client;
369
 
        int error;
370
 
        GLint answerBuffer[200];
371
 
        char *answer;
372
 
        __GLX_DECLARE_SWAP_VARIABLES;
373
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
374
 
 
375
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
376
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
377
 
        if (!cx) {
378
 
                return error;
379
 
        }
380
 
        pc += __GLX_SINGLE_HDR_SIZE;
381
 
        __GLX_SWAP_INT(pc + 0);
382
 
        pname = *(GLenum *)(pc + 0);
383
 
        compsize = __glGetIntegerv_size(pname);
384
 
        if (compsize < 0) compsize = 0;
385
 
 
386
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
387
 
        __glXClearErrorOccured();
388
 
        glGetIntegerv( 
389
 
                *(GLenum   *)(pc + 0),
390
 
                (GLint    *) answer
391
 
        );
392
 
        __GLX_SWAP_INT_ARRAY(answer, compsize);
393
 
        if (__glXErrorOccured()) {
394
 
            __GLX_BEGIN_REPLY(0);
395
 
            __GLX_SWAP_REPLY_HEADER();
396
 
            __GLX_PUT_SIZE(0);
397
 
            __GLX_SEND_HEADER();
398
 
        } else if (compsize == 1) {
399
 
            __GLX_BEGIN_REPLY(0);
400
 
            __GLX_SWAP_REPLY_HEADER();
401
 
            __GLX_PUT_SIZE(1);
402
 
            __GLX_SWAP_REPLY_SIZE();
403
 
            __GLX_PUT_INT();
404
 
            __GLX_SEND_HEADER();
405
 
        } else {
406
 
            __GLX_BEGIN_REPLY(compsize*4);
407
 
            __GLX_SWAP_REPLY_HEADER();
408
 
            __GLX_PUT_SIZE(compsize);
409
 
            __GLX_SWAP_REPLY_SIZE();
410
 
            __GLX_SEND_HEADER();
411
 
            __GLX_SEND_INT_ARRAY(compsize);
412
 
        }
413
 
        return Success;
414
 
}
415
 
 
416
 
int __glXDispSwap_GetLightfv(__GLXclientState *cl, GLbyte *pc)
417
 
{
418
 
        GLenum pname;
419
 
        GLint compsize;
420
 
        __GLXcontext *cx;
421
 
        ClientPtr client = cl->client;
422
 
        int error;
423
 
        GLfloat answerBuffer[200];
424
 
        char *answer;
425
 
        __GLX_DECLARE_SWAP_VARIABLES;
426
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
427
 
 
428
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
429
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
430
 
        if (!cx) {
431
 
                return error;
432
 
        }
433
 
        pc += __GLX_SINGLE_HDR_SIZE;
434
 
        __GLX_SWAP_INT(pc + 4);
435
 
        pname = *(GLenum *)(pc + 4);
436
 
        compsize = __glGetLightfv_size(pname);
437
 
        if (compsize < 0) compsize = 0;
438
 
        __GLX_SWAP_INT(pc + 0);
439
 
 
440
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
441
 
        __glXClearErrorOccured();
442
 
        glGetLightfv( 
443
 
                *(GLenum   *)(pc + 0),
444
 
                *(GLenum   *)(pc + 4),
445
 
                (GLfloat  *) answer
446
 
        );
447
 
        __GLX_SWAP_FLOAT_ARRAY(answer, compsize);
448
 
        if (__glXErrorOccured()) {
449
 
            __GLX_BEGIN_REPLY(0);
450
 
            __GLX_SWAP_REPLY_HEADER();
451
 
            __GLX_PUT_SIZE(0);
452
 
            __GLX_SEND_HEADER();
453
 
        } else if (compsize == 1) {
454
 
            __GLX_BEGIN_REPLY(0);
455
 
            __GLX_SWAP_REPLY_HEADER();
456
 
            __GLX_PUT_SIZE(1);
457
 
            __GLX_SWAP_REPLY_SIZE();
458
 
            __GLX_PUT_FLOAT();
459
 
            __GLX_SEND_HEADER();
460
 
        } else {
461
 
            __GLX_BEGIN_REPLY(compsize*4);
462
 
            __GLX_SWAP_REPLY_HEADER();
463
 
            __GLX_PUT_SIZE(compsize);
464
 
            __GLX_SWAP_REPLY_SIZE();
465
 
            __GLX_SEND_HEADER();
466
 
            __GLX_SEND_FLOAT_ARRAY(compsize);
467
 
        }
468
 
        return Success;
469
 
}
470
 
 
471
 
int __glXDispSwap_GetLightiv(__GLXclientState *cl, GLbyte *pc)
472
 
{
473
 
        GLenum pname;
474
 
        GLint compsize;
475
 
        __GLXcontext *cx;
476
 
        ClientPtr client = cl->client;
477
 
        int error;
478
 
        GLint answerBuffer[200];
479
 
        char *answer;
480
 
        __GLX_DECLARE_SWAP_VARIABLES;
481
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
482
 
 
483
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
484
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
485
 
        if (!cx) {
486
 
                return error;
487
 
        }
488
 
        pc += __GLX_SINGLE_HDR_SIZE;
489
 
        __GLX_SWAP_INT(pc + 4);
490
 
        pname = *(GLenum *)(pc + 4);
491
 
        compsize = __glGetLightiv_size(pname);
492
 
        if (compsize < 0) compsize = 0;
493
 
        __GLX_SWAP_INT(pc + 0);
494
 
 
495
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
496
 
        __glXClearErrorOccured();
497
 
        glGetLightiv( 
498
 
                *(GLenum   *)(pc + 0),
499
 
                *(GLenum   *)(pc + 4),
500
 
                (GLint    *) answer
501
 
        );
502
 
        __GLX_SWAP_INT_ARRAY(answer, compsize);
503
 
        if (__glXErrorOccured()) {
504
 
            __GLX_BEGIN_REPLY(0);
505
 
            __GLX_SWAP_REPLY_HEADER();
506
 
            __GLX_PUT_SIZE(0);
507
 
            __GLX_SEND_HEADER();
508
 
        } else if (compsize == 1) {
509
 
            __GLX_BEGIN_REPLY(0);
510
 
            __GLX_SWAP_REPLY_HEADER();
511
 
            __GLX_PUT_SIZE(1);
512
 
            __GLX_SWAP_REPLY_SIZE();
513
 
            __GLX_PUT_INT();
514
 
            __GLX_SEND_HEADER();
515
 
        } else {
516
 
            __GLX_BEGIN_REPLY(compsize*4);
517
 
            __GLX_SWAP_REPLY_HEADER();
518
 
            __GLX_PUT_SIZE(compsize);
519
 
            __GLX_SWAP_REPLY_SIZE();
520
 
            __GLX_SEND_HEADER();
521
 
            __GLX_SEND_INT_ARRAY(compsize);
522
 
        }
523
 
        return Success;
524
 
}
525
 
 
526
 
int __glXDispSwap_GetMapdv(__GLXclientState *cl, GLbyte *pc)
527
 
{
528
 
        GLenum target;
529
 
        GLenum query;
530
 
        GLint compsize;
531
 
        __GLXcontext *cx;
532
 
        ClientPtr client = cl->client;
533
 
        int error;
534
 
        GLdouble answerBuffer[200];
535
 
        char *answer;
536
 
        __GLX_DECLARE_SWAP_VARIABLES;
537
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
538
 
 
539
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
540
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
541
 
        if (!cx) {
542
 
                return error;
543
 
        }
544
 
        pc += __GLX_SINGLE_HDR_SIZE;
545
 
        __GLX_SWAP_INT(pc + 0);
546
 
        __GLX_SWAP_INT(pc + 4);
547
 
        target = *(GLenum *)(pc + 0);
548
 
        query = *(GLenum *)(pc + 4);
549
 
        compsize = __glGetMapdv_size(target,query);
550
 
        if (compsize < 0) compsize = 0;
551
 
 
552
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*8,8);
553
 
        __glXClearErrorOccured();
554
 
        glGetMapdv( 
555
 
                *(GLenum   *)(pc + 0),
556
 
                *(GLenum   *)(pc + 4),
557
 
                (GLdouble *) answer
558
 
        );
559
 
        __GLX_SWAP_DOUBLE_ARRAY(answer, compsize);
560
 
        if (__glXErrorOccured()) {
561
 
            __GLX_BEGIN_REPLY(0);
562
 
            __GLX_SWAP_REPLY_HEADER();
563
 
            __GLX_PUT_SIZE(0);
564
 
            __GLX_SEND_HEADER();
565
 
        } else if (compsize == 1) {
566
 
            __GLX_BEGIN_REPLY(0);
567
 
            __GLX_SWAP_REPLY_HEADER();
568
 
            __GLX_PUT_SIZE(1);
569
 
            __GLX_SWAP_REPLY_SIZE();
570
 
            __GLX_PUT_DOUBLE();
571
 
            __GLX_SEND_HEADER();
572
 
        } else {
573
 
            __GLX_BEGIN_REPLY(compsize*8);
574
 
            __GLX_SWAP_REPLY_HEADER();
575
 
            __GLX_PUT_SIZE(compsize);
576
 
            __GLX_SWAP_REPLY_SIZE();
577
 
            __GLX_SEND_HEADER();
578
 
            __GLX_SEND_DOUBLE_ARRAY(compsize);
579
 
        }
580
 
        return Success;
581
 
}
582
 
 
583
 
int __glXDispSwap_GetMapfv(__GLXclientState *cl, GLbyte *pc)
584
 
{
585
 
        GLenum target;
586
 
        GLenum query;
587
 
        GLint compsize;
588
 
        __GLXcontext *cx;
589
 
        ClientPtr client = cl->client;
590
 
        int error;
591
 
        GLfloat answerBuffer[200];
592
 
        char *answer;
593
 
        __GLX_DECLARE_SWAP_VARIABLES;
594
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
595
 
 
596
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
597
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
598
 
        if (!cx) {
599
 
                return error;
600
 
        }
601
 
        pc += __GLX_SINGLE_HDR_SIZE;
602
 
        __GLX_SWAP_INT(pc + 0);
603
 
        __GLX_SWAP_INT(pc + 4);
604
 
        target = *(GLenum *)(pc + 0);
605
 
        query = *(GLenum *)(pc + 4);
606
 
        compsize = __glGetMapfv_size(target,query);
607
 
        if (compsize < 0) compsize = 0;
608
 
 
609
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
610
 
        __glXClearErrorOccured();
611
 
        glGetMapfv( 
612
 
                *(GLenum   *)(pc + 0),
613
 
                *(GLenum   *)(pc + 4),
614
 
                (GLfloat  *) answer
615
 
        );
616
 
        __GLX_SWAP_FLOAT_ARRAY(answer, compsize);
617
 
        if (__glXErrorOccured()) {
618
 
            __GLX_BEGIN_REPLY(0);
619
 
            __GLX_SWAP_REPLY_HEADER();
620
 
            __GLX_PUT_SIZE(0);
621
 
            __GLX_SEND_HEADER();
622
 
        } else if (compsize == 1) {
623
 
            __GLX_BEGIN_REPLY(0);
624
 
            __GLX_SWAP_REPLY_HEADER();
625
 
            __GLX_PUT_SIZE(1);
626
 
            __GLX_SWAP_REPLY_SIZE();
627
 
            __GLX_PUT_FLOAT();
628
 
            __GLX_SEND_HEADER();
629
 
        } else {
630
 
            __GLX_BEGIN_REPLY(compsize*4);
631
 
            __GLX_SWAP_REPLY_HEADER();
632
 
            __GLX_PUT_SIZE(compsize);
633
 
            __GLX_SWAP_REPLY_SIZE();
634
 
            __GLX_SEND_HEADER();
635
 
            __GLX_SEND_FLOAT_ARRAY(compsize);
636
 
        }
637
 
        return Success;
638
 
}
639
 
 
640
 
int __glXDispSwap_GetMapiv(__GLXclientState *cl, GLbyte *pc)
641
 
{
642
 
        GLenum target;
643
 
        GLenum query;
644
 
        GLint compsize;
645
 
        __GLXcontext *cx;
646
 
        ClientPtr client = cl->client;
647
 
        int error;
648
 
        GLint answerBuffer[200];
649
 
        char *answer;
650
 
        __GLX_DECLARE_SWAP_VARIABLES;
651
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
652
 
 
653
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
654
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
655
 
        if (!cx) {
656
 
                return error;
657
 
        }
658
 
        pc += __GLX_SINGLE_HDR_SIZE;
659
 
        __GLX_SWAP_INT(pc + 0);
660
 
        __GLX_SWAP_INT(pc + 4);
661
 
        target = *(GLenum *)(pc + 0);
662
 
        query = *(GLenum *)(pc + 4);
663
 
        compsize = __glGetMapiv_size(target,query);
664
 
        if (compsize < 0) compsize = 0;
665
 
 
666
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
667
 
        __glXClearErrorOccured();
668
 
        glGetMapiv( 
669
 
                *(GLenum   *)(pc + 0),
670
 
                *(GLenum   *)(pc + 4),
671
 
                (GLint    *) answer
672
 
        );
673
 
        __GLX_SWAP_INT_ARRAY(answer, compsize);
674
 
        if (__glXErrorOccured()) {
675
 
            __GLX_BEGIN_REPLY(0);
676
 
            __GLX_SWAP_REPLY_HEADER();
677
 
            __GLX_PUT_SIZE(0);
678
 
            __GLX_SEND_HEADER();
679
 
        } else if (compsize == 1) {
680
 
            __GLX_BEGIN_REPLY(0);
681
 
            __GLX_SWAP_REPLY_HEADER();
682
 
            __GLX_PUT_SIZE(1);
683
 
            __GLX_SWAP_REPLY_SIZE();
684
 
            __GLX_PUT_INT();
685
 
            __GLX_SEND_HEADER();
686
 
        } else {
687
 
            __GLX_BEGIN_REPLY(compsize*4);
688
 
            __GLX_SWAP_REPLY_HEADER();
689
 
            __GLX_PUT_SIZE(compsize);
690
 
            __GLX_SWAP_REPLY_SIZE();
691
 
            __GLX_SEND_HEADER();
692
 
            __GLX_SEND_INT_ARRAY(compsize);
693
 
        }
694
 
        return Success;
695
 
}
696
 
 
697
 
int __glXDispSwap_GetMaterialfv(__GLXclientState *cl, GLbyte *pc)
698
 
{
699
 
        GLenum pname;
700
 
        GLint compsize;
701
 
        __GLXcontext *cx;
702
 
        ClientPtr client = cl->client;
703
 
        int error;
704
 
        GLfloat answerBuffer[200];
705
 
        char *answer;
706
 
        __GLX_DECLARE_SWAP_VARIABLES;
707
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
708
 
 
709
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
710
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
711
 
        if (!cx) {
712
 
                return error;
713
 
        }
714
 
        pc += __GLX_SINGLE_HDR_SIZE;
715
 
        __GLX_SWAP_INT(pc + 4);
716
 
        pname = *(GLenum *)(pc + 4);
717
 
        compsize = __glGetMaterialfv_size(pname);
718
 
        if (compsize < 0) compsize = 0;
719
 
        __GLX_SWAP_INT(pc + 0);
720
 
 
721
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
722
 
        __glXClearErrorOccured();
723
 
        glGetMaterialfv( 
724
 
                *(GLenum   *)(pc + 0),
725
 
                *(GLenum   *)(pc + 4),
726
 
                (GLfloat  *) answer
727
 
        );
728
 
        __GLX_SWAP_FLOAT_ARRAY(answer, compsize);
729
 
        if (__glXErrorOccured()) {
730
 
            __GLX_BEGIN_REPLY(0);
731
 
            __GLX_SWAP_REPLY_HEADER();
732
 
            __GLX_PUT_SIZE(0);
733
 
            __GLX_SEND_HEADER();
734
 
        } else if (compsize == 1) {
735
 
            __GLX_BEGIN_REPLY(0);
736
 
            __GLX_SWAP_REPLY_HEADER();
737
 
            __GLX_PUT_SIZE(1);
738
 
            __GLX_SWAP_REPLY_SIZE();
739
 
            __GLX_PUT_FLOAT();
740
 
            __GLX_SEND_HEADER();
741
 
        } else {
742
 
            __GLX_BEGIN_REPLY(compsize*4);
743
 
            __GLX_SWAP_REPLY_HEADER();
744
 
            __GLX_PUT_SIZE(compsize);
745
 
            __GLX_SWAP_REPLY_SIZE();
746
 
            __GLX_SEND_HEADER();
747
 
            __GLX_SEND_FLOAT_ARRAY(compsize);
748
 
        }
749
 
        return Success;
750
 
}
751
 
 
752
 
int __glXDispSwap_GetMaterialiv(__GLXclientState *cl, GLbyte *pc)
753
 
{
754
 
        GLenum pname;
755
 
        GLint compsize;
756
 
        __GLXcontext *cx;
757
 
        ClientPtr client = cl->client;
758
 
        int error;
759
 
        GLint answerBuffer[200];
760
 
        char *answer;
761
 
        __GLX_DECLARE_SWAP_VARIABLES;
762
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
763
 
 
764
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
765
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
766
 
        if (!cx) {
767
 
                return error;
768
 
        }
769
 
        pc += __GLX_SINGLE_HDR_SIZE;
770
 
        __GLX_SWAP_INT(pc + 4);
771
 
        pname = *(GLenum *)(pc + 4);
772
 
        compsize = __glGetMaterialiv_size(pname);
773
 
        if (compsize < 0) compsize = 0;
774
 
        __GLX_SWAP_INT(pc + 0);
775
 
 
776
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
777
 
        __glXClearErrorOccured();
778
 
        glGetMaterialiv( 
779
 
                *(GLenum   *)(pc + 0),
780
 
                *(GLenum   *)(pc + 4),
781
 
                (GLint    *) answer
782
 
        );
783
 
        __GLX_SWAP_INT_ARRAY(answer, compsize);
784
 
        if (__glXErrorOccured()) {
785
 
            __GLX_BEGIN_REPLY(0);
786
 
            __GLX_SWAP_REPLY_HEADER();
787
 
            __GLX_PUT_SIZE(0);
788
 
            __GLX_SEND_HEADER();
789
 
        } else if (compsize == 1) {
790
 
            __GLX_BEGIN_REPLY(0);
791
 
            __GLX_SWAP_REPLY_HEADER();
792
 
            __GLX_PUT_SIZE(1);
793
 
            __GLX_SWAP_REPLY_SIZE();
794
 
            __GLX_PUT_INT();
795
 
            __GLX_SEND_HEADER();
796
 
        } else {
797
 
            __GLX_BEGIN_REPLY(compsize*4);
798
 
            __GLX_SWAP_REPLY_HEADER();
799
 
            __GLX_PUT_SIZE(compsize);
800
 
            __GLX_SWAP_REPLY_SIZE();
801
 
            __GLX_SEND_HEADER();
802
 
            __GLX_SEND_INT_ARRAY(compsize);
803
 
        }
804
 
        return Success;
805
 
}
806
 
 
807
 
int __glXDispSwap_GetPixelMapfv(__GLXclientState *cl, GLbyte *pc)
808
 
{
809
 
        GLenum map;
810
 
        GLint compsize;
811
 
        __GLXcontext *cx;
812
 
        ClientPtr client = cl->client;
813
 
        int error;
814
 
        GLfloat answerBuffer[200];
815
 
        char *answer;
816
 
        __GLX_DECLARE_SWAP_VARIABLES;
817
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
818
 
 
819
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
820
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
821
 
        if (!cx) {
822
 
                return error;
823
 
        }
824
 
        pc += __GLX_SINGLE_HDR_SIZE;
825
 
        __GLX_SWAP_INT(pc + 0);
826
 
        map = *(GLenum *)(pc + 0);
827
 
        compsize = __glGetPixelMapfv_size(map);
828
 
        if (compsize < 0) compsize = 0;
829
 
 
830
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
831
 
        __glXClearErrorOccured();
832
 
        glGetPixelMapfv( 
833
 
                *(GLenum   *)(pc + 0),
834
 
                (GLfloat  *) answer
835
 
        );
836
 
        __GLX_SWAP_FLOAT_ARRAY(answer, compsize);
837
 
        if (__glXErrorOccured()) {
838
 
            __GLX_BEGIN_REPLY(0);
839
 
            __GLX_SWAP_REPLY_HEADER();
840
 
            __GLX_PUT_SIZE(0);
841
 
            __GLX_SEND_HEADER();
842
 
        } else if (compsize == 1) {
843
 
            __GLX_BEGIN_REPLY(0);
844
 
            __GLX_SWAP_REPLY_HEADER();
845
 
            __GLX_PUT_SIZE(1);
846
 
            __GLX_SWAP_REPLY_SIZE();
847
 
            __GLX_PUT_FLOAT();
848
 
            __GLX_SEND_HEADER();
849
 
        } else {
850
 
            __GLX_BEGIN_REPLY(compsize*4);
851
 
            __GLX_SWAP_REPLY_HEADER();
852
 
            __GLX_PUT_SIZE(compsize);
853
 
            __GLX_SWAP_REPLY_SIZE();
854
 
            __GLX_SEND_HEADER();
855
 
            __GLX_SEND_FLOAT_ARRAY(compsize);
856
 
        }
857
 
        return Success;
858
 
}
859
 
 
860
 
int __glXDispSwap_GetPixelMapuiv(__GLXclientState *cl, GLbyte *pc)
861
 
{
862
 
        GLenum map;
863
 
        GLint compsize;
864
 
        __GLXcontext *cx;
865
 
        ClientPtr client = cl->client;
866
 
        int error;
867
 
        GLuint answerBuffer[200];
868
 
        char *answer;
869
 
        __GLX_DECLARE_SWAP_VARIABLES;
870
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
871
 
 
872
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
873
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
874
 
        if (!cx) {
875
 
                return error;
876
 
        }
877
 
        pc += __GLX_SINGLE_HDR_SIZE;
878
 
        __GLX_SWAP_INT(pc + 0);
879
 
        map = *(GLenum *)(pc + 0);
880
 
        compsize = __glGetPixelMapuiv_size(map);
881
 
        if (compsize < 0) compsize = 0;
882
 
 
883
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
884
 
        __glXClearErrorOccured();
885
 
        glGetPixelMapuiv( 
886
 
                *(GLenum   *)(pc + 0),
887
 
                (GLuint   *) answer
888
 
        );
889
 
        __GLX_SWAP_INT_ARRAY(answer, compsize);
890
 
        if (__glXErrorOccured()) {
891
 
            __GLX_BEGIN_REPLY(0);
892
 
            __GLX_SWAP_REPLY_HEADER();
893
 
            __GLX_PUT_SIZE(0);
894
 
            __GLX_SEND_HEADER();
895
 
        } else if (compsize == 1) {
896
 
            __GLX_BEGIN_REPLY(0);
897
 
            __GLX_SWAP_REPLY_HEADER();
898
 
            __GLX_PUT_SIZE(1);
899
 
            __GLX_SWAP_REPLY_SIZE();
900
 
            __GLX_PUT_INT();
901
 
            __GLX_SEND_HEADER();
902
 
        } else {
903
 
            __GLX_BEGIN_REPLY(compsize*4);
904
 
            __GLX_SWAP_REPLY_HEADER();
905
 
            __GLX_PUT_SIZE(compsize);
906
 
            __GLX_SWAP_REPLY_SIZE();
907
 
            __GLX_SEND_HEADER();
908
 
            __GLX_SEND_INT_ARRAY(compsize);
909
 
        }
910
 
        return Success;
911
 
}
912
 
 
913
 
int __glXDispSwap_GetPixelMapusv(__GLXclientState *cl, GLbyte *pc)
914
 
{
915
 
        GLenum map;
916
 
        GLint compsize;
917
 
        __GLXcontext *cx;
918
 
        ClientPtr client = cl->client;
919
 
        int error;
920
 
        GLushort answerBuffer[200];
921
 
        char *answer;
922
 
        __GLX_DECLARE_SWAP_VARIABLES;
923
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
924
 
 
925
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
926
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
927
 
        if (!cx) {
928
 
                return error;
929
 
        }
930
 
        pc += __GLX_SINGLE_HDR_SIZE;
931
 
        __GLX_SWAP_INT(pc + 0);
932
 
        map = *(GLenum *)(pc + 0);
933
 
        compsize = __glGetPixelMapusv_size(map);
934
 
        if (compsize < 0) compsize = 0;
935
 
 
936
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*2,2);
937
 
        __glXClearErrorOccured();
938
 
        glGetPixelMapusv( 
939
 
                *(GLenum   *)(pc + 0),
940
 
                (GLushort *) answer
941
 
        );
942
 
        __GLX_SWAP_SHORT_ARRAY(answer, compsize);
943
 
        if (__glXErrorOccured()) {
944
 
            __GLX_BEGIN_REPLY(0);
945
 
            __GLX_SWAP_REPLY_HEADER();
946
 
            __GLX_PUT_SIZE(0);
947
 
            __GLX_SEND_HEADER();
948
 
        } else if (compsize == 1) {
949
 
            __GLX_BEGIN_REPLY(0);
950
 
            __GLX_SWAP_REPLY_HEADER();
951
 
            __GLX_PUT_SIZE(1);
952
 
            __GLX_SWAP_REPLY_SIZE();
953
 
            __GLX_PUT_SHORT();
954
 
            __GLX_SEND_HEADER();
955
 
        } else {
956
 
            __GLX_BEGIN_REPLY(compsize*2);
957
 
            __GLX_SWAP_REPLY_HEADER();
958
 
            __GLX_PUT_SIZE(compsize);
959
 
            __GLX_SWAP_REPLY_SIZE();
960
 
            __GLX_SEND_HEADER();
961
 
            __GLX_SEND_SHORT_ARRAY(compsize);
962
 
        }
963
 
        return Success;
964
 
}
965
 
 
966
 
int __glXDispSwap_GetTexEnvfv(__GLXclientState *cl, GLbyte *pc)
967
 
{
968
 
        GLenum pname;
969
 
        GLint compsize;
970
 
        __GLXcontext *cx;
971
 
        ClientPtr client = cl->client;
972
 
        int error;
973
 
        GLfloat answerBuffer[200];
974
 
        char *answer;
975
 
        __GLX_DECLARE_SWAP_VARIABLES;
976
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
977
 
 
978
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
979
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
980
 
        if (!cx) {
981
 
                return error;
982
 
        }
983
 
        pc += __GLX_SINGLE_HDR_SIZE;
984
 
        __GLX_SWAP_INT(pc + 4);
985
 
        pname = *(GLenum *)(pc + 4);
986
 
        compsize = __glGetTexEnvfv_size(pname);
987
 
        if (compsize < 0) compsize = 0;
988
 
        __GLX_SWAP_INT(pc + 0);
989
 
 
990
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
991
 
        __glXClearErrorOccured();
992
 
        glGetTexEnvfv( 
993
 
                *(GLenum   *)(pc + 0),
994
 
                *(GLenum   *)(pc + 4),
995
 
                (GLfloat  *) answer
996
 
        );
997
 
        __GLX_SWAP_FLOAT_ARRAY(answer, compsize);
998
 
        if (__glXErrorOccured()) {
999
 
            __GLX_BEGIN_REPLY(0);
1000
 
            __GLX_SWAP_REPLY_HEADER();
1001
 
            __GLX_PUT_SIZE(0);
1002
 
            __GLX_SEND_HEADER();
1003
 
        } else if (compsize == 1) {
1004
 
            __GLX_BEGIN_REPLY(0);
1005
 
            __GLX_SWAP_REPLY_HEADER();
1006
 
            __GLX_PUT_SIZE(1);
1007
 
            __GLX_SWAP_REPLY_SIZE();
1008
 
            __GLX_PUT_FLOAT();
1009
 
            __GLX_SEND_HEADER();
1010
 
        } else {
1011
 
            __GLX_BEGIN_REPLY(compsize*4);
1012
 
            __GLX_SWAP_REPLY_HEADER();
1013
 
            __GLX_PUT_SIZE(compsize);
1014
 
            __GLX_SWAP_REPLY_SIZE();
1015
 
            __GLX_SEND_HEADER();
1016
 
            __GLX_SEND_FLOAT_ARRAY(compsize);
1017
 
        }
1018
 
        return Success;
1019
 
}
1020
 
 
1021
 
int __glXDispSwap_GetTexEnviv(__GLXclientState *cl, GLbyte *pc)
1022
 
{
1023
 
        GLenum pname;
1024
 
        GLint compsize;
1025
 
        __GLXcontext *cx;
1026
 
        ClientPtr client = cl->client;
1027
 
        int error;
1028
 
        GLint answerBuffer[200];
1029
 
        char *answer;
1030
 
        __GLX_DECLARE_SWAP_VARIABLES;
1031
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1032
 
 
1033
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
1034
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
1035
 
        if (!cx) {
1036
 
                return error;
1037
 
        }
1038
 
        pc += __GLX_SINGLE_HDR_SIZE;
1039
 
        __GLX_SWAP_INT(pc + 4);
1040
 
        pname = *(GLenum *)(pc + 4);
1041
 
        compsize = __glGetTexEnviv_size(pname);
1042
 
        if (compsize < 0) compsize = 0;
1043
 
        __GLX_SWAP_INT(pc + 0);
1044
 
 
1045
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
1046
 
        __glXClearErrorOccured();
1047
 
        glGetTexEnviv( 
1048
 
                *(GLenum   *)(pc + 0),
1049
 
                *(GLenum   *)(pc + 4),
1050
 
                (GLint    *) answer
1051
 
        );
1052
 
        __GLX_SWAP_INT_ARRAY(answer, compsize);
1053
 
        if (__glXErrorOccured()) {
1054
 
            __GLX_BEGIN_REPLY(0);
1055
 
            __GLX_SWAP_REPLY_HEADER();
1056
 
            __GLX_PUT_SIZE(0);
1057
 
            __GLX_SEND_HEADER();
1058
 
        } else if (compsize == 1) {
1059
 
            __GLX_BEGIN_REPLY(0);
1060
 
            __GLX_SWAP_REPLY_HEADER();
1061
 
            __GLX_PUT_SIZE(1);
1062
 
            __GLX_SWAP_REPLY_SIZE();
1063
 
            __GLX_PUT_INT();
1064
 
            __GLX_SEND_HEADER();
1065
 
        } else {
1066
 
            __GLX_BEGIN_REPLY(compsize*4);
1067
 
            __GLX_SWAP_REPLY_HEADER();
1068
 
            __GLX_PUT_SIZE(compsize);
1069
 
            __GLX_SWAP_REPLY_SIZE();
1070
 
            __GLX_SEND_HEADER();
1071
 
            __GLX_SEND_INT_ARRAY(compsize);
1072
 
        }
1073
 
        return Success;
1074
 
}
1075
 
 
1076
 
int __glXDispSwap_GetTexGendv(__GLXclientState *cl, GLbyte *pc)
1077
 
{
1078
 
        GLenum pname;
1079
 
        GLint compsize;
1080
 
        __GLXcontext *cx;
1081
 
        ClientPtr client = cl->client;
1082
 
        int error;
1083
 
        GLdouble answerBuffer[200];
1084
 
        char *answer;
1085
 
        __GLX_DECLARE_SWAP_VARIABLES;
1086
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1087
 
 
1088
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
1089
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
1090
 
        if (!cx) {
1091
 
                return error;
1092
 
        }
1093
 
        pc += __GLX_SINGLE_HDR_SIZE;
1094
 
        __GLX_SWAP_INT(pc + 4);
1095
 
        pname = *(GLenum *)(pc + 4);
1096
 
        compsize = __glGetTexGendv_size(pname);
1097
 
        if (compsize < 0) compsize = 0;
1098
 
        __GLX_SWAP_INT(pc + 0);
1099
 
 
1100
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*8,8);
1101
 
        __glXClearErrorOccured();
1102
 
        glGetTexGendv( 
1103
 
                *(GLenum   *)(pc + 0),
1104
 
                *(GLenum   *)(pc + 4),
1105
 
                (GLdouble *) answer
1106
 
        );
1107
 
        __GLX_SWAP_DOUBLE_ARRAY(answer, compsize);
1108
 
        if (__glXErrorOccured()) {
1109
 
            __GLX_BEGIN_REPLY(0);
1110
 
            __GLX_SWAP_REPLY_HEADER();
1111
 
            __GLX_PUT_SIZE(0);
1112
 
            __GLX_SEND_HEADER();
1113
 
        } else if (compsize == 1) {
1114
 
            __GLX_BEGIN_REPLY(0);
1115
 
            __GLX_SWAP_REPLY_HEADER();
1116
 
            __GLX_PUT_SIZE(1);
1117
 
            __GLX_SWAP_REPLY_SIZE();
1118
 
            __GLX_PUT_DOUBLE();
1119
 
            __GLX_SEND_HEADER();
1120
 
        } else {
1121
 
            __GLX_BEGIN_REPLY(compsize*8);
1122
 
            __GLX_SWAP_REPLY_HEADER();
1123
 
            __GLX_PUT_SIZE(compsize);
1124
 
            __GLX_SWAP_REPLY_SIZE();
1125
 
            __GLX_SEND_HEADER();
1126
 
            __GLX_SEND_DOUBLE_ARRAY(compsize);
1127
 
        }
1128
 
        return Success;
1129
 
}
1130
 
 
1131
 
int __glXDispSwap_GetTexGenfv(__GLXclientState *cl, GLbyte *pc)
1132
 
{
1133
 
        GLenum pname;
1134
 
        GLint compsize;
1135
 
        __GLXcontext *cx;
1136
 
        ClientPtr client = cl->client;
1137
 
        int error;
1138
 
        GLfloat answerBuffer[200];
1139
 
        char *answer;
1140
 
        __GLX_DECLARE_SWAP_VARIABLES;
1141
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1142
 
 
1143
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
1144
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
1145
 
        if (!cx) {
1146
 
                return error;
1147
 
        }
1148
 
        pc += __GLX_SINGLE_HDR_SIZE;
1149
 
        __GLX_SWAP_INT(pc + 4);
1150
 
        pname = *(GLenum *)(pc + 4);
1151
 
        compsize = __glGetTexGenfv_size(pname);
1152
 
        if (compsize < 0) compsize = 0;
1153
 
        __GLX_SWAP_INT(pc + 0);
1154
 
 
1155
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
1156
 
        __glXClearErrorOccured();
1157
 
        glGetTexGenfv( 
1158
 
                *(GLenum   *)(pc + 0),
1159
 
                *(GLenum   *)(pc + 4),
1160
 
                (GLfloat  *) answer
1161
 
        );
1162
 
        __GLX_SWAP_FLOAT_ARRAY(answer, compsize);
1163
 
        if (__glXErrorOccured()) {
1164
 
            __GLX_BEGIN_REPLY(0);
1165
 
            __GLX_SWAP_REPLY_HEADER();
1166
 
            __GLX_PUT_SIZE(0);
1167
 
            __GLX_SEND_HEADER();
1168
 
        } else if (compsize == 1) {
1169
 
            __GLX_BEGIN_REPLY(0);
1170
 
            __GLX_SWAP_REPLY_HEADER();
1171
 
            __GLX_PUT_SIZE(1);
1172
 
            __GLX_SWAP_REPLY_SIZE();
1173
 
            __GLX_PUT_FLOAT();
1174
 
            __GLX_SEND_HEADER();
1175
 
        } else {
1176
 
            __GLX_BEGIN_REPLY(compsize*4);
1177
 
            __GLX_SWAP_REPLY_HEADER();
1178
 
            __GLX_PUT_SIZE(compsize);
1179
 
            __GLX_SWAP_REPLY_SIZE();
1180
 
            __GLX_SEND_HEADER();
1181
 
            __GLX_SEND_FLOAT_ARRAY(compsize);
1182
 
        }
1183
 
        return Success;
1184
 
}
1185
 
 
1186
 
int __glXDispSwap_GetTexGeniv(__GLXclientState *cl, GLbyte *pc)
1187
 
{
1188
 
        GLenum pname;
1189
 
        GLint compsize;
1190
 
        __GLXcontext *cx;
1191
 
        ClientPtr client = cl->client;
1192
 
        int error;
1193
 
        GLint answerBuffer[200];
1194
 
        char *answer;
1195
 
        __GLX_DECLARE_SWAP_VARIABLES;
1196
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1197
 
 
1198
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
1199
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
1200
 
        if (!cx) {
1201
 
                return error;
1202
 
        }
1203
 
        pc += __GLX_SINGLE_HDR_SIZE;
1204
 
        __GLX_SWAP_INT(pc + 4);
1205
 
        pname = *(GLenum *)(pc + 4);
1206
 
        compsize = __glGetTexGeniv_size(pname);
1207
 
        if (compsize < 0) compsize = 0;
1208
 
        __GLX_SWAP_INT(pc + 0);
1209
 
 
1210
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
1211
 
        __glXClearErrorOccured();
1212
 
        glGetTexGeniv( 
1213
 
                *(GLenum   *)(pc + 0),
1214
 
                *(GLenum   *)(pc + 4),
1215
 
                (GLint    *) answer
1216
 
        );
1217
 
        __GLX_SWAP_INT_ARRAY(answer, compsize);
1218
 
        if (__glXErrorOccured()) {
1219
 
            __GLX_BEGIN_REPLY(0);
1220
 
            __GLX_SWAP_REPLY_HEADER();
1221
 
            __GLX_PUT_SIZE(0);
1222
 
            __GLX_SEND_HEADER();
1223
 
        } else if (compsize == 1) {
1224
 
            __GLX_BEGIN_REPLY(0);
1225
 
            __GLX_SWAP_REPLY_HEADER();
1226
 
            __GLX_PUT_SIZE(1);
1227
 
            __GLX_SWAP_REPLY_SIZE();
1228
 
            __GLX_PUT_INT();
1229
 
            __GLX_SEND_HEADER();
1230
 
        } else {
1231
 
            __GLX_BEGIN_REPLY(compsize*4);
1232
 
            __GLX_SWAP_REPLY_HEADER();
1233
 
            __GLX_PUT_SIZE(compsize);
1234
 
            __GLX_SWAP_REPLY_SIZE();
1235
 
            __GLX_SEND_HEADER();
1236
 
            __GLX_SEND_INT_ARRAY(compsize);
1237
 
        }
1238
 
        return Success;
1239
 
}
1240
 
 
1241
 
int __glXDispSwap_GetTexParameterfv(__GLXclientState *cl, GLbyte *pc)
1242
 
{
1243
 
        GLenum pname;
1244
 
        GLint compsize;
1245
 
        __GLXcontext *cx;
1246
 
        ClientPtr client = cl->client;
1247
 
        int error;
1248
 
        GLfloat answerBuffer[200];
1249
 
        char *answer;
1250
 
        __GLX_DECLARE_SWAP_VARIABLES;
1251
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1252
 
 
1253
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
1254
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
1255
 
        if (!cx) {
1256
 
                return error;
1257
 
        }
1258
 
        pc += __GLX_SINGLE_HDR_SIZE;
1259
 
        __GLX_SWAP_INT(pc + 4);
1260
 
        pname = *(GLenum *)(pc + 4);
1261
 
        compsize = __glGetTexParameterfv_size(pname);
1262
 
        if (compsize < 0) compsize = 0;
1263
 
        __GLX_SWAP_INT(pc + 0);
1264
 
 
1265
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
1266
 
        __glXClearErrorOccured();
1267
 
        glGetTexParameterfv( 
1268
 
                *(GLenum   *)(pc + 0),
1269
 
                *(GLenum   *)(pc + 4),
1270
 
                (GLfloat  *) answer
1271
 
        );
1272
 
        __GLX_SWAP_FLOAT_ARRAY(answer, compsize);
1273
 
        if (__glXErrorOccured()) {
1274
 
            __GLX_BEGIN_REPLY(0);
1275
 
            __GLX_SWAP_REPLY_HEADER();
1276
 
            __GLX_PUT_SIZE(0);
1277
 
            __GLX_SEND_HEADER();
1278
 
        } else if (compsize == 1) {
1279
 
            __GLX_BEGIN_REPLY(0);
1280
 
            __GLX_SWAP_REPLY_HEADER();
1281
 
            __GLX_PUT_SIZE(1);
1282
 
            __GLX_SWAP_REPLY_SIZE();
1283
 
            __GLX_PUT_FLOAT();
1284
 
            __GLX_SEND_HEADER();
1285
 
        } else {
1286
 
            __GLX_BEGIN_REPLY(compsize*4);
1287
 
            __GLX_SWAP_REPLY_HEADER();
1288
 
            __GLX_PUT_SIZE(compsize);
1289
 
            __GLX_SWAP_REPLY_SIZE();
1290
 
            __GLX_SEND_HEADER();
1291
 
            __GLX_SEND_FLOAT_ARRAY(compsize);
1292
 
        }
1293
 
        return Success;
1294
 
}
1295
 
 
1296
 
int __glXDispSwap_GetTexParameteriv(__GLXclientState *cl, GLbyte *pc)
1297
 
{
1298
 
        GLenum pname;
1299
 
        GLint compsize;
1300
 
        __GLXcontext *cx;
1301
 
        ClientPtr client = cl->client;
1302
 
        int error;
1303
 
        GLint answerBuffer[200];
1304
 
        char *answer;
1305
 
        __GLX_DECLARE_SWAP_VARIABLES;
1306
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1307
 
 
1308
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
1309
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
1310
 
        if (!cx) {
1311
 
                return error;
1312
 
        }
1313
 
        pc += __GLX_SINGLE_HDR_SIZE;
1314
 
        __GLX_SWAP_INT(pc + 4);
1315
 
        pname = *(GLenum *)(pc + 4);
1316
 
        compsize = __glGetTexParameteriv_size(pname);
1317
 
        if (compsize < 0) compsize = 0;
1318
 
        __GLX_SWAP_INT(pc + 0);
1319
 
 
1320
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
1321
 
        __glXClearErrorOccured();
1322
 
        glGetTexParameteriv( 
1323
 
                *(GLenum   *)(pc + 0),
1324
 
                *(GLenum   *)(pc + 4),
1325
 
                (GLint    *) answer
1326
 
        );
1327
 
        __GLX_SWAP_INT_ARRAY(answer, compsize);
1328
 
        if (__glXErrorOccured()) {
1329
 
            __GLX_BEGIN_REPLY(0);
1330
 
            __GLX_SWAP_REPLY_HEADER();
1331
 
            __GLX_PUT_SIZE(0);
1332
 
            __GLX_SEND_HEADER();
1333
 
        } else if (compsize == 1) {
1334
 
            __GLX_BEGIN_REPLY(0);
1335
 
            __GLX_SWAP_REPLY_HEADER();
1336
 
            __GLX_PUT_SIZE(1);
1337
 
            __GLX_SWAP_REPLY_SIZE();
1338
 
            __GLX_PUT_INT();
1339
 
            __GLX_SEND_HEADER();
1340
 
        } else {
1341
 
            __GLX_BEGIN_REPLY(compsize*4);
1342
 
            __GLX_SWAP_REPLY_HEADER();
1343
 
            __GLX_PUT_SIZE(compsize);
1344
 
            __GLX_SWAP_REPLY_SIZE();
1345
 
            __GLX_SEND_HEADER();
1346
 
            __GLX_SEND_INT_ARRAY(compsize);
1347
 
        }
1348
 
        return Success;
1349
 
}
1350
 
 
1351
 
int __glXDispSwap_GetTexLevelParameterfv(__GLXclientState *cl, GLbyte *pc)
1352
 
{
1353
 
        GLenum pname;
1354
 
        GLint compsize;
1355
 
        __GLXcontext *cx;
1356
 
        ClientPtr client = cl->client;
1357
 
        int error;
1358
 
        GLfloat answerBuffer[200];
1359
 
        char *answer;
1360
 
        __GLX_DECLARE_SWAP_VARIABLES;
1361
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1362
 
 
1363
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
1364
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
1365
 
        if (!cx) {
1366
 
                return error;
1367
 
        }
1368
 
        pc += __GLX_SINGLE_HDR_SIZE;
1369
 
        __GLX_SWAP_INT(pc + 8);
1370
 
        pname = *(GLenum *)(pc + 8);
1371
 
        compsize = __glGetTexLevelParameterfv_size(pname);
1372
 
        if (compsize < 0) compsize = 0;
1373
 
        __GLX_SWAP_INT(pc + 0);
1374
 
        __GLX_SWAP_INT(pc + 4);
1375
 
 
1376
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
1377
 
        __glXClearErrorOccured();
1378
 
        glGetTexLevelParameterfv( 
1379
 
                *(GLenum   *)(pc + 0),
1380
 
                *(GLint    *)(pc + 4),
1381
 
                *(GLenum   *)(pc + 8),
1382
 
                (GLfloat  *) answer
1383
 
        );
1384
 
        __GLX_SWAP_FLOAT_ARRAY(answer, compsize);
1385
 
        if (__glXErrorOccured()) {
1386
 
            __GLX_BEGIN_REPLY(0);
1387
 
            __GLX_SWAP_REPLY_HEADER();
1388
 
            __GLX_PUT_SIZE(0);
1389
 
            __GLX_SEND_HEADER();
1390
 
        } else if (compsize == 1) {
1391
 
            __GLX_BEGIN_REPLY(0);
1392
 
            __GLX_SWAP_REPLY_HEADER();
1393
 
            __GLX_PUT_SIZE(1);
1394
 
            __GLX_SWAP_REPLY_SIZE();
1395
 
            __GLX_PUT_FLOAT();
1396
 
            __GLX_SEND_HEADER();
1397
 
        } else {
1398
 
            __GLX_BEGIN_REPLY(compsize*4);
1399
 
            __GLX_SWAP_REPLY_HEADER();
1400
 
            __GLX_PUT_SIZE(compsize);
1401
 
            __GLX_SWAP_REPLY_SIZE();
1402
 
            __GLX_SEND_HEADER();
1403
 
            __GLX_SEND_FLOAT_ARRAY(compsize);
1404
 
        }
1405
 
        return Success;
1406
 
}
1407
 
 
1408
 
int __glXDispSwap_GetTexLevelParameteriv(__GLXclientState *cl, GLbyte *pc)
1409
 
{
1410
 
        GLenum pname;
1411
 
        GLint compsize;
1412
 
        __GLXcontext *cx;
1413
 
        ClientPtr client = cl->client;
1414
 
        int error;
1415
 
        GLint answerBuffer[200];
1416
 
        char *answer;
1417
 
        __GLX_DECLARE_SWAP_VARIABLES;
1418
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1419
 
 
1420
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
1421
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
1422
 
        if (!cx) {
1423
 
                return error;
1424
 
        }
1425
 
        pc += __GLX_SINGLE_HDR_SIZE;
1426
 
        __GLX_SWAP_INT(pc + 8);
1427
 
        pname = *(GLenum *)(pc + 8);
1428
 
        compsize = __glGetTexLevelParameteriv_size(pname);
1429
 
        if (compsize < 0) compsize = 0;
1430
 
        __GLX_SWAP_INT(pc + 0);
1431
 
        __GLX_SWAP_INT(pc + 4);
1432
 
 
1433
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
1434
 
        __glXClearErrorOccured();
1435
 
        glGetTexLevelParameteriv( 
1436
 
                *(GLenum   *)(pc + 0),
1437
 
                *(GLint    *)(pc + 4),
1438
 
                *(GLenum   *)(pc + 8),
1439
 
                (GLint    *) answer
1440
 
        );
1441
 
        __GLX_SWAP_INT_ARRAY(answer, compsize);
1442
 
        if (__glXErrorOccured()) {
1443
 
            __GLX_BEGIN_REPLY(0);
1444
 
            __GLX_SWAP_REPLY_HEADER();
1445
 
            __GLX_PUT_SIZE(0);
1446
 
            __GLX_SEND_HEADER();
1447
 
        } else if (compsize == 1) {
1448
 
            __GLX_BEGIN_REPLY(0);
1449
 
            __GLX_SWAP_REPLY_HEADER();
1450
 
            __GLX_PUT_SIZE(1);
1451
 
            __GLX_SWAP_REPLY_SIZE();
1452
 
            __GLX_PUT_INT();
1453
 
            __GLX_SEND_HEADER();
1454
 
        } else {
1455
 
            __GLX_BEGIN_REPLY(compsize*4);
1456
 
            __GLX_SWAP_REPLY_HEADER();
1457
 
            __GLX_PUT_SIZE(compsize);
1458
 
            __GLX_SWAP_REPLY_SIZE();
1459
 
            __GLX_SEND_HEADER();
1460
 
            __GLX_SEND_INT_ARRAY(compsize);
1461
 
        }
1462
 
        return Success;
1463
 
}
1464
 
 
1465
 
int __glXDispSwap_IsEnabled(__GLXclientState *cl, GLbyte *pc)
1466
 
{
1467
 
        GLboolean retval;
1468
 
        __GLXcontext *cx;
1469
 
        ClientPtr client = cl->client;
1470
 
        int error;
1471
 
        __GLX_DECLARE_SWAP_VARIABLES;
1472
 
 
1473
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
1474
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
1475
 
        if (!cx) {
1476
 
                return error;
1477
 
        }
1478
 
        pc += __GLX_SINGLE_HDR_SIZE;
1479
 
        __GLX_SWAP_INT(pc + 0);
1480
 
 
1481
 
        retval =
1482
 
        glIsEnabled( 
1483
 
                *(GLenum   *)(pc + 0)
1484
 
        );
1485
 
        __GLX_PUT_RETVAL(retval);
1486
 
        __GLX_SWAP_REPLY_RETVAL();
1487
 
        __GLX_BEGIN_REPLY(0);
1488
 
        __GLX_SWAP_REPLY_HEADER();
1489
 
        __GLX_SEND_HEADER();
1490
 
        return Success;
1491
 
}
1492
 
 
1493
 
int __glXDispSwap_IsList(__GLXclientState *cl, GLbyte *pc)
1494
 
{
1495
 
        GLboolean retval;
1496
 
        __GLXcontext *cx;
1497
 
        ClientPtr client = cl->client;
1498
 
        int error;
1499
 
        __GLX_DECLARE_SWAP_VARIABLES;
1500
 
 
1501
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
1502
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
1503
 
        if (!cx) {
1504
 
                return error;
1505
 
        }
1506
 
        pc += __GLX_SINGLE_HDR_SIZE;
1507
 
        __GLX_SWAP_INT(pc + 0);
1508
 
 
1509
 
        retval =
1510
 
        glIsList( 
1511
 
                *(GLuint   *)(pc + 0)
1512
 
        );
1513
 
        __GLX_PUT_RETVAL(retval);
1514
 
        __GLX_SWAP_REPLY_RETVAL();
1515
 
        __GLX_BEGIN_REPLY(0);
1516
 
        __GLX_SWAP_REPLY_HEADER();
1517
 
        __GLX_SEND_HEADER();
1518
 
        return Success;
1519
 
}
1520
 
 
1521
 
int __glXDispSwap_AreTexturesResident(__GLXclientState *cl, GLbyte *pc)
1522
 
{
1523
 
        GLsizei n;
1524
 
        GLboolean retval;
1525
 
        __GLXcontext *cx;
1526
 
        ClientPtr client = cl->client;
1527
 
        int error;
1528
 
        GLboolean answerBuffer[200];
1529
 
        char *answer;
1530
 
        __GLX_DECLARE_SWAP_VARIABLES;
1531
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1532
 
 
1533
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
1534
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
1535
 
        if (!cx) {
1536
 
                return error;
1537
 
        }
1538
 
        pc += __GLX_SINGLE_HDR_SIZE;
1539
 
        __GLX_SWAP_INT(pc + 0);
1540
 
        n = *(GLsizei *)(pc + 0);
1541
 
        __GLX_SWAP_INT_ARRAY(pc + 4, n);
1542
 
 
1543
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,n,1);
1544
 
        retval =
1545
 
        glAreTexturesResident( 
1546
 
                *(GLsizei  *)(pc + 0),
1547
 
                (GLuint   *)(pc + 4),
1548
 
                (GLboolean *) answer
1549
 
        );
1550
 
        __GLX_PUT_RETVAL(retval);
1551
 
        __GLX_SWAP_REPLY_RETVAL();
1552
 
        __GLX_BEGIN_REPLY(n);
1553
 
        __GLX_SWAP_REPLY_HEADER();
1554
 
        __GLX_SEND_HEADER();
1555
 
        __GLX_SEND_BYTE_ARRAY(n);
1556
 
        return Success;
1557
 
}
1558
 
 
1559
 
int __glXDispSwap_DeleteTextures(__GLXclientState *cl, GLbyte *pc)
1560
 
{
1561
 
        GLsizei n;
1562
 
        __GLXcontext *cx;
1563
 
        int error;
1564
 
        __GLX_DECLARE_SWAP_VARIABLES;
1565
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1566
 
 
1567
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
1568
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
1569
 
        if (!cx) {
1570
 
                return error;
1571
 
        }
1572
 
        pc += __GLX_SINGLE_HDR_SIZE;
1573
 
        __GLX_SWAP_INT(pc + 0);
1574
 
        n = *(GLsizei *)(pc + 0);
1575
 
        __GLX_SWAP_INT_ARRAY(pc + 4, n);
1576
 
 
1577
 
        glDeleteTextures( 
1578
 
                *(GLsizei  *)(pc + 0),
1579
 
                (GLuint   *)(pc + 4)
1580
 
        );
1581
 
        return Success;
1582
 
}
1583
 
 
1584
 
int __glXDispSwap_GenTextures(__GLXclientState *cl, GLbyte *pc)
1585
 
{
1586
 
        GLsizei n;
1587
 
        __GLXcontext *cx;
1588
 
        ClientPtr client = cl->client;
1589
 
        int error;
1590
 
        GLuint answerBuffer[200];
1591
 
        char *answer;
1592
 
        __GLX_DECLARE_SWAP_VARIABLES;
1593
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1594
 
 
1595
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
1596
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
1597
 
        if (!cx) {
1598
 
                return error;
1599
 
        }
1600
 
        pc += __GLX_SINGLE_HDR_SIZE;
1601
 
        __GLX_SWAP_INT(pc + 0);
1602
 
        n = *(GLsizei *)(pc + 0);
1603
 
 
1604
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,n*4,4);
1605
 
        glGenTextures( 
1606
 
                *(GLsizei  *)(pc + 0),
1607
 
                (GLuint   *) answer
1608
 
        );
1609
 
        __GLX_SWAP_INT_ARRAY(answer, n);
1610
 
        __GLX_BEGIN_REPLY(n*4);
1611
 
        __GLX_SWAP_REPLY_HEADER();
1612
 
        __GLX_SEND_HEADER();
1613
 
        __GLX_SEND_INT_ARRAY(n);
1614
 
        return Success;
1615
 
}
1616
 
 
1617
 
int __glXDispSwap_IsTexture(__GLXclientState *cl, GLbyte *pc)
1618
 
{
1619
 
        GLboolean retval;
1620
 
        __GLXcontext *cx;
1621
 
        ClientPtr client = cl->client;
1622
 
        int error;
1623
 
        __GLX_DECLARE_SWAP_VARIABLES;
1624
 
 
1625
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
1626
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
1627
 
        if (!cx) {
1628
 
                return error;
1629
 
        }
1630
 
        pc += __GLX_SINGLE_HDR_SIZE;
1631
 
        __GLX_SWAP_INT(pc + 0);
1632
 
 
1633
 
        retval =
1634
 
        glIsTexture( 
1635
 
                *(GLuint   *)(pc + 0)
1636
 
        );
1637
 
        __GLX_PUT_RETVAL(retval);
1638
 
        __GLX_SWAP_REPLY_RETVAL();
1639
 
        __GLX_BEGIN_REPLY(0);
1640
 
        __GLX_SWAP_REPLY_HEADER();
1641
 
        __GLX_SEND_HEADER();
1642
 
        return Success;
1643
 
}
1644
 
 
1645
 
int __glXDispSwap_GetColorTableParameterfv(__GLXclientState *cl, GLbyte *pc)
1646
 
{
1647
 
        GLenum pname;
1648
 
        GLint compsize;
1649
 
        __GLXcontext *cx;
1650
 
        ClientPtr client = cl->client;
1651
 
        int error;
1652
 
        GLfloat answerBuffer[200];
1653
 
        char *answer;
1654
 
        __GLX_DECLARE_SWAP_VARIABLES;
1655
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1656
 
 
1657
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
1658
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
1659
 
        if (!cx) {
1660
 
                return error;
1661
 
        }
1662
 
        pc += __GLX_SINGLE_HDR_SIZE;
1663
 
        __GLX_SWAP_INT(pc + 4);
1664
 
        pname = *(GLenum *)(pc + 4);
1665
 
        compsize = __glGetColorTableParameterfv_size(pname);
1666
 
        if (compsize < 0) compsize = 0;
1667
 
        __GLX_SWAP_INT(pc + 0);
1668
 
 
1669
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
1670
 
        __glXClearErrorOccured();
1671
 
        glGetColorTableParameterfv( 
1672
 
                *(GLenum   *)(pc + 0),
1673
 
                *(GLenum   *)(pc + 4),
1674
 
                (GLfloat  *) answer
1675
 
        );
1676
 
        __GLX_SWAP_FLOAT_ARRAY(answer, compsize);
1677
 
        if (__glXErrorOccured()) {
1678
 
            __GLX_BEGIN_REPLY(0);
1679
 
            __GLX_SWAP_REPLY_HEADER();
1680
 
            __GLX_PUT_SIZE(0);
1681
 
            __GLX_SEND_HEADER();
1682
 
        } else if (compsize == 1) {
1683
 
            __GLX_BEGIN_REPLY(0);
1684
 
            __GLX_SWAP_REPLY_HEADER();
1685
 
            __GLX_PUT_SIZE(1);
1686
 
            __GLX_SWAP_REPLY_SIZE();
1687
 
            __GLX_PUT_FLOAT();
1688
 
            __GLX_SEND_HEADER();
1689
 
        } else {
1690
 
            __GLX_BEGIN_REPLY(compsize*4);
1691
 
            __GLX_SWAP_REPLY_HEADER();
1692
 
            __GLX_PUT_SIZE(compsize);
1693
 
            __GLX_SWAP_REPLY_SIZE();
1694
 
            __GLX_SEND_HEADER();
1695
 
            __GLX_SEND_FLOAT_ARRAY(compsize);
1696
 
        }
1697
 
        return Success;
1698
 
}
1699
 
 
1700
 
int __glXDispSwap_GetColorTableParameteriv(__GLXclientState *cl, GLbyte *pc)
1701
 
{
1702
 
        GLenum pname;
1703
 
        GLint compsize;
1704
 
        __GLXcontext *cx;
1705
 
        ClientPtr client = cl->client;
1706
 
        int error;
1707
 
        GLint answerBuffer[200];
1708
 
        char *answer;
1709
 
        __GLX_DECLARE_SWAP_VARIABLES;
1710
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1711
 
 
1712
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
1713
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
1714
 
        if (!cx) {
1715
 
                return error;
1716
 
        }
1717
 
        pc += __GLX_SINGLE_HDR_SIZE;
1718
 
        __GLX_SWAP_INT(pc + 4);
1719
 
        pname = *(GLenum *)(pc + 4);
1720
 
        compsize = __glGetColorTableParameteriv_size(pname);
1721
 
        if (compsize < 0) compsize = 0;
1722
 
        __GLX_SWAP_INT(pc + 0);
1723
 
 
1724
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
1725
 
        __glXClearErrorOccured();
1726
 
        glGetColorTableParameteriv( 
1727
 
                *(GLenum   *)(pc + 0),
1728
 
                *(GLenum   *)(pc + 4),
1729
 
                (GLint    *) answer
1730
 
        );
1731
 
        __GLX_SWAP_INT_ARRAY(answer, compsize);
1732
 
        if (__glXErrorOccured()) {
1733
 
            __GLX_BEGIN_REPLY(0);
1734
 
            __GLX_SWAP_REPLY_HEADER();
1735
 
            __GLX_PUT_SIZE(0);
1736
 
            __GLX_SEND_HEADER();
1737
 
        } else if (compsize == 1) {
1738
 
            __GLX_BEGIN_REPLY(0);
1739
 
            __GLX_SWAP_REPLY_HEADER();
1740
 
            __GLX_PUT_SIZE(1);
1741
 
            __GLX_SWAP_REPLY_SIZE();
1742
 
            __GLX_PUT_INT();
1743
 
            __GLX_SEND_HEADER();
1744
 
        } else {
1745
 
            __GLX_BEGIN_REPLY(compsize*4);
1746
 
            __GLX_SWAP_REPLY_HEADER();
1747
 
            __GLX_PUT_SIZE(compsize);
1748
 
            __GLX_SWAP_REPLY_SIZE();
1749
 
            __GLX_SEND_HEADER();
1750
 
            __GLX_SEND_INT_ARRAY(compsize);
1751
 
        }
1752
 
        return Success;
1753
 
}
1754
 
 
1755
 
int __glXDispSwap_GetConvolutionParameterfv(__GLXclientState *cl, GLbyte *pc)
1756
 
{
1757
 
        GLenum pname;
1758
 
        GLint compsize;
1759
 
        __GLXcontext *cx;
1760
 
        ClientPtr client = cl->client;
1761
 
        int error;
1762
 
        GLfloat answerBuffer[200];
1763
 
        char *answer;
1764
 
        __GLX_DECLARE_SWAP_VARIABLES;
1765
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1766
 
 
1767
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
1768
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
1769
 
        if (!cx) {
1770
 
                return error;
1771
 
        }
1772
 
        pc += __GLX_SINGLE_HDR_SIZE;
1773
 
        __GLX_SWAP_INT(pc + 4);
1774
 
        pname = *(GLenum *)(pc + 4);
1775
 
        compsize = __glGetConvolutionParameterfv_size(pname);
1776
 
        if (compsize < 0) compsize = 0;
1777
 
        __GLX_SWAP_INT(pc + 0);
1778
 
 
1779
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
1780
 
        __glXClearErrorOccured();
1781
 
        glGetConvolutionParameterfv( 
1782
 
                *(GLenum   *)(pc + 0),
1783
 
                *(GLenum   *)(pc + 4),
1784
 
                (GLfloat  *) answer
1785
 
        );
1786
 
        __GLX_SWAP_FLOAT_ARRAY(answer, compsize);
1787
 
        if (__glXErrorOccured()) {
1788
 
            __GLX_BEGIN_REPLY(0);
1789
 
            __GLX_SWAP_REPLY_HEADER();
1790
 
            __GLX_PUT_SIZE(0);
1791
 
            __GLX_SEND_HEADER();
1792
 
        } else if (compsize == 1) {
1793
 
            __GLX_BEGIN_REPLY(0);
1794
 
            __GLX_SWAP_REPLY_HEADER();
1795
 
            __GLX_PUT_SIZE(1);
1796
 
            __GLX_SWAP_REPLY_SIZE();
1797
 
            __GLX_PUT_FLOAT();
1798
 
            __GLX_SEND_HEADER();
1799
 
        } else {
1800
 
            __GLX_BEGIN_REPLY(compsize*4);
1801
 
            __GLX_SWAP_REPLY_HEADER();
1802
 
            __GLX_PUT_SIZE(compsize);
1803
 
            __GLX_SWAP_REPLY_SIZE();
1804
 
            __GLX_SEND_HEADER();
1805
 
            __GLX_SEND_FLOAT_ARRAY(compsize);
1806
 
        }
1807
 
        return Success;
1808
 
}
1809
 
 
1810
 
int __glXDispSwap_GetConvolutionParameteriv(__GLXclientState *cl, GLbyte *pc)
1811
 
{
1812
 
        GLenum pname;
1813
 
        GLint compsize;
1814
 
        __GLXcontext *cx;
1815
 
        ClientPtr client = cl->client;
1816
 
        int error;
1817
 
        GLint answerBuffer[200];
1818
 
        char *answer;
1819
 
        __GLX_DECLARE_SWAP_VARIABLES;
1820
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1821
 
 
1822
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
1823
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
1824
 
        if (!cx) {
1825
 
                return error;
1826
 
        }
1827
 
        pc += __GLX_SINGLE_HDR_SIZE;
1828
 
        __GLX_SWAP_INT(pc + 4);
1829
 
        pname = *(GLenum *)(pc + 4);
1830
 
        compsize = __glGetConvolutionParameteriv_size(pname);
1831
 
        if (compsize < 0) compsize = 0;
1832
 
        __GLX_SWAP_INT(pc + 0);
1833
 
 
1834
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
1835
 
        __glXClearErrorOccured();
1836
 
        glGetConvolutionParameteriv( 
1837
 
                *(GLenum   *)(pc + 0),
1838
 
                *(GLenum   *)(pc + 4),
1839
 
                (GLint    *) answer
1840
 
        );
1841
 
        __GLX_SWAP_INT_ARRAY(answer, compsize);
1842
 
        if (__glXErrorOccured()) {
1843
 
            __GLX_BEGIN_REPLY(0);
1844
 
            __GLX_SWAP_REPLY_HEADER();
1845
 
            __GLX_PUT_SIZE(0);
1846
 
            __GLX_SEND_HEADER();
1847
 
        } else if (compsize == 1) {
1848
 
            __GLX_BEGIN_REPLY(0);
1849
 
            __GLX_SWAP_REPLY_HEADER();
1850
 
            __GLX_PUT_SIZE(1);
1851
 
            __GLX_SWAP_REPLY_SIZE();
1852
 
            __GLX_PUT_INT();
1853
 
            __GLX_SEND_HEADER();
1854
 
        } else {
1855
 
            __GLX_BEGIN_REPLY(compsize*4);
1856
 
            __GLX_SWAP_REPLY_HEADER();
1857
 
            __GLX_PUT_SIZE(compsize);
1858
 
            __GLX_SWAP_REPLY_SIZE();
1859
 
            __GLX_SEND_HEADER();
1860
 
            __GLX_SEND_INT_ARRAY(compsize);
1861
 
        }
1862
 
        return Success;
1863
 
}
1864
 
 
1865
 
int __glXDispSwap_GetHistogramParameterfv(__GLXclientState *cl, GLbyte *pc)
1866
 
{
1867
 
        GLenum pname;
1868
 
        GLint compsize;
1869
 
        __GLXcontext *cx;
1870
 
        ClientPtr client = cl->client;
1871
 
        int error;
1872
 
        GLfloat answerBuffer[200];
1873
 
        char *answer;
1874
 
        __GLX_DECLARE_SWAP_VARIABLES;
1875
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1876
 
 
1877
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
1878
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
1879
 
        if (!cx) {
1880
 
                return error;
1881
 
        }
1882
 
        pc += __GLX_SINGLE_HDR_SIZE;
1883
 
        __GLX_SWAP_INT(pc + 4);
1884
 
        pname = *(GLenum *)(pc + 4);
1885
 
        compsize = __glGetHistogramParameterfv_size(pname);
1886
 
        if (compsize < 0) compsize = 0;
1887
 
        __GLX_SWAP_INT(pc + 0);
1888
 
 
1889
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
1890
 
        __glXClearErrorOccured();
1891
 
        glGetHistogramParameterfv( 
1892
 
                *(GLenum   *)(pc + 0),
1893
 
                *(GLenum   *)(pc + 4),
1894
 
                (GLfloat  *) answer
1895
 
        );
1896
 
        __GLX_SWAP_FLOAT_ARRAY(answer, compsize);
1897
 
        if (__glXErrorOccured()) {
1898
 
            __GLX_BEGIN_REPLY(0);
1899
 
            __GLX_SWAP_REPLY_HEADER();
1900
 
            __GLX_PUT_SIZE(0);
1901
 
            __GLX_SEND_HEADER();
1902
 
        } else if (compsize == 1) {
1903
 
            __GLX_BEGIN_REPLY(0);
1904
 
            __GLX_SWAP_REPLY_HEADER();
1905
 
            __GLX_PUT_SIZE(1);
1906
 
            __GLX_SWAP_REPLY_SIZE();
1907
 
            __GLX_PUT_FLOAT();
1908
 
            __GLX_SEND_HEADER();
1909
 
        } else {
1910
 
            __GLX_BEGIN_REPLY(compsize*4);
1911
 
            __GLX_SWAP_REPLY_HEADER();
1912
 
            __GLX_PUT_SIZE(compsize);
1913
 
            __GLX_SWAP_REPLY_SIZE();
1914
 
            __GLX_SEND_HEADER();
1915
 
            __GLX_SEND_FLOAT_ARRAY(compsize);
1916
 
        }
1917
 
        return Success;
1918
 
}
1919
 
 
1920
 
int __glXDispSwap_GetHistogramParameteriv(__GLXclientState *cl, GLbyte *pc)
1921
 
{
1922
 
        GLenum pname;
1923
 
        GLint compsize;
1924
 
        __GLXcontext *cx;
1925
 
        ClientPtr client = cl->client;
1926
 
        int error;
1927
 
        GLint answerBuffer[200];
1928
 
        char *answer;
1929
 
        __GLX_DECLARE_SWAP_VARIABLES;
1930
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1931
 
 
1932
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
1933
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
1934
 
        if (!cx) {
1935
 
                return error;
1936
 
        }
1937
 
        pc += __GLX_SINGLE_HDR_SIZE;
1938
 
        __GLX_SWAP_INT(pc + 4);
1939
 
        pname = *(GLenum *)(pc + 4);
1940
 
        compsize = __glGetHistogramParameteriv_size(pname);
1941
 
        if (compsize < 0) compsize = 0;
1942
 
        __GLX_SWAP_INT(pc + 0);
1943
 
 
1944
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
1945
 
        __glXClearErrorOccured();
1946
 
        glGetHistogramParameteriv( 
1947
 
                *(GLenum   *)(pc + 0),
1948
 
                *(GLenum   *)(pc + 4),
1949
 
                (GLint    *) answer
1950
 
        );
1951
 
        __GLX_SWAP_INT_ARRAY(answer, compsize);
1952
 
        if (__glXErrorOccured()) {
1953
 
            __GLX_BEGIN_REPLY(0);
1954
 
            __GLX_SWAP_REPLY_HEADER();
1955
 
            __GLX_PUT_SIZE(0);
1956
 
            __GLX_SEND_HEADER();
1957
 
        } else if (compsize == 1) {
1958
 
            __GLX_BEGIN_REPLY(0);
1959
 
            __GLX_SWAP_REPLY_HEADER();
1960
 
            __GLX_PUT_SIZE(1);
1961
 
            __GLX_SWAP_REPLY_SIZE();
1962
 
            __GLX_PUT_INT();
1963
 
            __GLX_SEND_HEADER();
1964
 
        } else {
1965
 
            __GLX_BEGIN_REPLY(compsize*4);
1966
 
            __GLX_SWAP_REPLY_HEADER();
1967
 
            __GLX_PUT_SIZE(compsize);
1968
 
            __GLX_SWAP_REPLY_SIZE();
1969
 
            __GLX_SEND_HEADER();
1970
 
            __GLX_SEND_INT_ARRAY(compsize);
1971
 
        }
1972
 
        return Success;
1973
 
}
1974
 
 
1975
 
int __glXDispSwap_GetMinmaxParameterfv(__GLXclientState *cl, GLbyte *pc)
1976
 
{
1977
 
        GLenum pname;
1978
 
        GLint compsize;
1979
 
        __GLXcontext *cx;
1980
 
        ClientPtr client = cl->client;
1981
 
        int error;
1982
 
        GLfloat answerBuffer[200];
1983
 
        char *answer;
1984
 
        __GLX_DECLARE_SWAP_VARIABLES;
1985
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
1986
 
 
1987
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
1988
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
1989
 
        if (!cx) {
1990
 
                return error;
1991
 
        }
1992
 
        pc += __GLX_SINGLE_HDR_SIZE;
1993
 
        __GLX_SWAP_INT(pc + 4);
1994
 
        pname = *(GLenum *)(pc + 4);
1995
 
        compsize = __glGetMinmaxParameterfv_size(pname);
1996
 
        if (compsize < 0) compsize = 0;
1997
 
        __GLX_SWAP_INT(pc + 0);
1998
 
 
1999
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
2000
 
        __glXClearErrorOccured();
2001
 
        glGetMinmaxParameterfv( 
2002
 
                *(GLenum   *)(pc + 0),
2003
 
                *(GLenum   *)(pc + 4),
2004
 
                (GLfloat  *) answer
2005
 
        );
2006
 
        __GLX_SWAP_FLOAT_ARRAY(answer, compsize);
2007
 
        if (__glXErrorOccured()) {
2008
 
            __GLX_BEGIN_REPLY(0);
2009
 
            __GLX_SWAP_REPLY_HEADER();
2010
 
            __GLX_PUT_SIZE(0);
2011
 
            __GLX_SEND_HEADER();
2012
 
        } else if (compsize == 1) {
2013
 
            __GLX_BEGIN_REPLY(0);
2014
 
            __GLX_SWAP_REPLY_HEADER();
2015
 
            __GLX_PUT_SIZE(1);
2016
 
            __GLX_SWAP_REPLY_SIZE();
2017
 
            __GLX_PUT_FLOAT();
2018
 
            __GLX_SEND_HEADER();
2019
 
        } else {
2020
 
            __GLX_BEGIN_REPLY(compsize*4);
2021
 
            __GLX_SWAP_REPLY_HEADER();
2022
 
            __GLX_PUT_SIZE(compsize);
2023
 
            __GLX_SWAP_REPLY_SIZE();
2024
 
            __GLX_SEND_HEADER();
2025
 
            __GLX_SEND_FLOAT_ARRAY(compsize);
2026
 
        }
2027
 
        return Success;
2028
 
}
2029
 
 
2030
 
int __glXDispSwap_GetMinmaxParameteriv(__GLXclientState *cl, GLbyte *pc)
2031
 
{
2032
 
        GLenum pname;
2033
 
        GLint compsize;
2034
 
        __GLXcontext *cx;
2035
 
        ClientPtr client = cl->client;
2036
 
        int error;
2037
 
        GLint answerBuffer[200];
2038
 
        char *answer;
2039
 
        __GLX_DECLARE_SWAP_VARIABLES;
2040
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2041
 
 
2042
 
        __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
2043
 
        cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
2044
 
        if (!cx) {
2045
 
                return error;
2046
 
        }
2047
 
        pc += __GLX_SINGLE_HDR_SIZE;
2048
 
        __GLX_SWAP_INT(pc + 4);
2049
 
        pname = *(GLenum *)(pc + 4);
2050
 
        compsize = __glGetMinmaxParameteriv_size(pname);
2051
 
        if (compsize < 0) compsize = 0;
2052
 
        __GLX_SWAP_INT(pc + 0);
2053
 
 
2054
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
2055
 
        __glXClearErrorOccured();
2056
 
        glGetMinmaxParameteriv( 
2057
 
                *(GLenum   *)(pc + 0),
2058
 
                *(GLenum   *)(pc + 4),
2059
 
                (GLint    *) answer
2060
 
        );
2061
 
        __GLX_SWAP_INT_ARRAY(answer, compsize);
2062
 
        if (__glXErrorOccured()) {
2063
 
            __GLX_BEGIN_REPLY(0);
2064
 
            __GLX_SWAP_REPLY_HEADER();
2065
 
            __GLX_PUT_SIZE(0);
2066
 
            __GLX_SEND_HEADER();
2067
 
        } else if (compsize == 1) {
2068
 
            __GLX_BEGIN_REPLY(0);
2069
 
            __GLX_SWAP_REPLY_HEADER();
2070
 
            __GLX_PUT_SIZE(1);
2071
 
            __GLX_SWAP_REPLY_SIZE();
2072
 
            __GLX_PUT_INT();
2073
 
            __GLX_SEND_HEADER();
2074
 
        } else {
2075
 
            __GLX_BEGIN_REPLY(compsize*4);
2076
 
            __GLX_SWAP_REPLY_HEADER();
2077
 
            __GLX_PUT_SIZE(compsize);
2078
 
            __GLX_SWAP_REPLY_SIZE();
2079
 
            __GLX_SEND_HEADER();
2080
 
            __GLX_SEND_INT_ARRAY(compsize);
2081
 
        }
2082
 
        return Success;
2083
 
}
2084
 
 
2085
 
int __glXDispSwap_AreTexturesResidentEXT(__GLXclientState *cl, GLbyte *pc)
2086
 
{
2087
 
        GLsizei n;
2088
 
        GLboolean retval;
2089
 
        __GLXcontext *cx;
2090
 
        ClientPtr client = cl->client;
2091
 
        int error;
2092
 
        GLboolean answerBuffer[200];
2093
 
        char *answer;
2094
 
        __GLX_DECLARE_SWAP_VARIABLES;
2095
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2096
 
 
2097
 
        __GLX_SWAP_INT(&((xGLXVendorPrivateReq *)pc)->contextTag);
2098
 
        cx = __glXForceCurrent(cl, __GLX_GET_VENDPRIV_CONTEXT_TAG(pc), &error);
2099
 
        if (!cx) {
2100
 
                return error;
2101
 
        }
2102
 
        pc += __GLX_VENDPRIV_HDR_SIZE;
2103
 
        __GLX_SWAP_INT(pc + 0);
2104
 
        n = *(GLsizei *)(pc + 0);
2105
 
        __GLX_SWAP_INT_ARRAY(pc + 4, n);
2106
 
 
2107
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,n,1);
2108
 
        retval =
2109
 
        glAreTexturesResidentEXT( 
2110
 
                *(GLsizei  *)(pc + 0),
2111
 
                (GLuint   *)(pc + 4),
2112
 
                (GLboolean *) answer
2113
 
        );
2114
 
        __GLX_PUT_RETVAL(retval);
2115
 
        __GLX_SWAP_REPLY_RETVAL();
2116
 
        __GLX_BEGIN_REPLY(n);
2117
 
        __GLX_SWAP_REPLY_HEADER();
2118
 
        __GLX_SEND_HEADER();
2119
 
        __GLX_SEND_BYTE_ARRAY(n);
2120
 
        return Success;
2121
 
}
2122
 
 
2123
 
int __glXDispSwap_DeleteTexturesEXT(__GLXclientState *cl, GLbyte *pc)
2124
 
{
2125
 
        GLsizei n;
2126
 
        __GLXcontext *cx;
2127
 
        int error;
2128
 
        __GLX_DECLARE_SWAP_VARIABLES;
2129
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2130
 
 
2131
 
        __GLX_SWAP_INT(&((xGLXVendorPrivateReq *)pc)->contextTag);
2132
 
        cx = __glXForceCurrent(cl, __GLX_GET_VENDPRIV_CONTEXT_TAG(pc), &error);
2133
 
        if (!cx) {
2134
 
                return error;
2135
 
        }
2136
 
        pc += __GLX_VENDPRIV_HDR_SIZE;
2137
 
        __GLX_SWAP_INT(pc + 0);
2138
 
        n = *(GLsizei *)(pc + 0);
2139
 
        __GLX_SWAP_INT_ARRAY(pc + 4, n);
2140
 
 
2141
 
        glDeleteTexturesEXT( 
2142
 
                *(GLsizei  *)(pc + 0),
2143
 
                (GLuint   *)(pc + 4)
2144
 
        );
2145
 
        return Success;
2146
 
}
2147
 
 
2148
 
int __glXDispSwap_GenTexturesEXT(__GLXclientState *cl, GLbyte *pc)
2149
 
{
2150
 
        GLsizei n;
2151
 
        __GLXcontext *cx;
2152
 
        ClientPtr client = cl->client;
2153
 
        int error;
2154
 
        GLuint answerBuffer[200];
2155
 
        char *answer;
2156
 
        __GLX_DECLARE_SWAP_VARIABLES;
2157
 
        __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
2158
 
 
2159
 
        __GLX_SWAP_INT(&((xGLXVendorPrivateReq *)pc)->contextTag);
2160
 
        cx = __glXForceCurrent(cl, __GLX_GET_VENDPRIV_CONTEXT_TAG(pc), &error);
2161
 
        if (!cx) {
2162
 
                return error;
2163
 
        }
2164
 
        pc += __GLX_VENDPRIV_HDR_SIZE;
2165
 
        __GLX_SWAP_INT(pc + 0);
2166
 
        n = *(GLsizei *)(pc + 0);
2167
 
 
2168
 
        __GLX_GET_ANSWER_BUFFER(answer,cl,n*4,4);
2169
 
        glGenTexturesEXT( 
2170
 
                *(GLsizei  *)(pc + 0),
2171
 
                (GLuint   *) answer
2172
 
        );
2173
 
        __GLX_SWAP_INT_ARRAY(answer, n);
2174
 
        __GLX_BEGIN_REPLY(n*4);
2175
 
        __GLX_SWAP_REPLY_HEADER();
2176
 
        __GLX_SEND_HEADER();
2177
 
        __GLX_SEND_INT_ARRAY(n);
2178
 
        return Success;
2179
 
}
2180
 
 
2181
 
int __glXDispSwap_IsTextureEXT(__GLXclientState *cl, GLbyte *pc)
2182
 
{
2183
 
        GLboolean retval;
2184
 
        __GLXcontext *cx;
2185
 
        ClientPtr client = cl->client;
2186
 
        int error;
2187
 
        __GLX_DECLARE_SWAP_VARIABLES;
2188
 
 
2189
 
        __GLX_SWAP_INT(&((xGLXVendorPrivateReq *)pc)->contextTag);
2190
 
        cx = __glXForceCurrent(cl, __GLX_GET_VENDPRIV_CONTEXT_TAG(pc), &error);
2191
 
        if (!cx) {
2192
 
                return error;
2193
 
        }
2194
 
        pc += __GLX_VENDPRIV_HDR_SIZE;
2195
 
        __GLX_SWAP_INT(pc + 0);
2196
 
 
2197
 
        retval =
2198
 
        glIsTextureEXT( 
2199
 
                *(GLuint   *)(pc + 0)
2200
 
        );
2201
 
        __GLX_PUT_RETVAL(retval);
2202
 
        __GLX_SWAP_REPLY_RETVAL();
2203
 
        __GLX_BEGIN_REPLY(0);
2204
 
        __GLX_SWAP_REPLY_HEADER();
2205
 
        __GLX_SEND_HEADER();
2206
 
        return Success;
2207
 
}
2208