projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
mesa: merge gallium-0.2 into gallium-master-merge
[mesa.git] / src / glx / x11 / indirect.c
1 /* DO NOT EDIT - This file generated automatically by glX_proto_send.py (from Mesa) script */
2
3 /*
4 * (C) Copyright IBM Corporation 2004, 2005
5 * All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sub license,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the next
15 * paragraph) shall be included in all copies or substantial portions of the
16 * Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
21 * IBM,
22 * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
23 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
24 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25 * SOFTWARE.
26 */
27
28
29 #include <GL/gl.h>
30 #include "indirect.h"
31 #include "glxclient.h"
32 #include "indirect_size.h"
33 #include "dispatch.h"
34 #include "glapi.h"
35 #include "glthread.h"
36 #include <GL/glxproto.h>
37 #ifdef USE_XCB
38 #include <X11/Xlib-xcb.h>
39 #include <xcb/xcb.h>
40 #include <xcb/glx.h>
41 #endif /* USE_XCB */
42
43 #define __GLX_PAD(n) (((n) + 3) & ~3)
44
45 # if defined(__i386__) && defined(__GNUC__) && !defined(__CYGWIN__) && !defined(__MINGW32__)
46 # define FASTCALL __attribute__((fastcall))
47 # else
48 # define FASTCALL
49 # endif
50 # if defined(__GNUC__)
51 # define NOINLINE __attribute__((noinline))
52 # else
53 # define NOINLINE
54 # endif
55
56 #if !defined __GNUC__ || __GNUC__ < 3
57 # define __builtin_expect(x, y) x
58 #endif
59
60 /* If the size and opcode values are known at compile-time, this will, on
61 * x86 at least, emit them with a single instruction.
62 */
63 #define emit_header(dest, op, size) \
64 do { union { short s[2]; int i; } temp; \
65 temp.s[0] = (size); temp.s[1] = (op); \
66 *((int *)(dest)) = temp.i; } while(0)
67
68 NOINLINE CARD32
69 __glXReadReply(Display * dpy, size_t size, void *dest,
70 GLboolean reply_is_always_array)
71 {
72 xGLXSingleReply reply;
73
74 (void) _XReply(dpy, (xReply *) & reply, 0, False);
75 if (size != 0) {
76 if ((reply.length > 0) || reply_is_always_array) {
77 const GLint bytes = (reply_is_always_array)
78 ? (4 * reply.length) : (reply.size * size);
79 const GLint extra = 4 - (bytes & 3);
80
81 _XRead(dpy, dest, bytes);
82 if (extra < 4) {
83 _XEatData(dpy, extra);
84 }
85 } else {
86 (void) memcpy(dest, &(reply.pad3), size);
87 }
88 }
89
90 return reply.retval;
91 }
92
93 NOINLINE void
94 __glXReadPixelReply(Display * dpy, __GLXcontext * gc, unsigned max_dim,
95 GLint width, GLint height, GLint depth, GLenum format,
96 GLenum type, void *dest, GLboolean dimensions_in_reply)
97 {
98 xGLXSingleReply reply;
99 GLint size;
100
101 (void) _XReply(dpy, (xReply *) & reply, 0, False);
102
103 if (dimensions_in_reply) {
104 width = reply.pad3;
105 height = reply.pad4;
106 depth = reply.pad5;
107
108 if ((height == 0) || (max_dim < 2)) {
109 height = 1;
110 }
111 if ((depth == 0) || (max_dim < 3)) {
112 depth = 1;
113 }
114 }
115
116 size = reply.length * 4;
117 if (size != 0) {
118 void *buf = Xmalloc(size);
119
120 if (buf == NULL) {
121 _XEatData(dpy, size);
122 __glXSetError(gc, GL_OUT_OF_MEMORY);
123 } else {
124 const GLint extra = 4 - (size & 3);
125
126 _XRead(dpy, buf, size);
127 if (extra < 4) {
128 _XEatData(dpy, extra);
129 }
130
131 __glEmptyImage(gc, 3, width, height, depth, format, type,
132 buf, dest);
133 Xfree(buf);
134 }
135 }
136 }
137
138 #define X_GLXSingle 0
139
140 NOINLINE FASTCALL GLubyte *
141 __glXSetupSingleRequest(__GLXcontext * gc, GLint sop, GLint cmdlen)
142 {
143 xGLXSingleReq *req;
144 Display *const dpy = gc->currentDpy;
145
146 (void) __glXFlushRenderBuffer(gc, gc->pc);
147 LockDisplay(dpy);
148 GetReqExtra(GLXSingle, cmdlen, req);
149 req->reqType = gc->majorOpcode;
150 req->contextTag = gc->currentContextTag;
151 req->glxCode = sop;
152 return (GLubyte *) (req) + sz_xGLXSingleReq;
153 }
154
155 NOINLINE FASTCALL GLubyte *
156 __glXSetupVendorRequest(__GLXcontext * gc, GLint code, GLint vop,
157 GLint cmdlen)
158 {
159 xGLXVendorPrivateReq *req;
160 Display *const dpy = gc->currentDpy;
161
162 (void) __glXFlushRenderBuffer(gc, gc->pc);
163 LockDisplay(dpy);
164 GetReqExtra(GLXVendorPrivate, cmdlen, req);
165 req->reqType = gc->majorOpcode;
166 req->glxCode = code;
167 req->vendorCode = vop;
168 req->contextTag = gc->currentContextTag;
169 return (GLubyte *) (req) + sz_xGLXVendorPrivateReq;
170 }
171
172 const GLuint __glXDefaultPixelStore[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 };
173
174 #define zero (__glXDefaultPixelStore+0)
175 #define one (__glXDefaultPixelStore+8)
176 #define default_pixel_store_1D (__glXDefaultPixelStore+4)
177 #define default_pixel_store_1D_size 20
178 #define default_pixel_store_2D (__glXDefaultPixelStore+4)
179 #define default_pixel_store_2D_size 20
180 #define default_pixel_store_3D (__glXDefaultPixelStore+0)
181 #define default_pixel_store_3D_size 36
182 #define default_pixel_store_4D (__glXDefaultPixelStore+0)
183 #define default_pixel_store_4D_size 36
184
185 static FASTCALL NOINLINE void
186 generic_3_byte(GLint rop, const void *ptr)
187 {
188 __GLXcontext *const gc = __glXGetCurrentContext();
189 const GLuint cmdlen = 8;
190
191 emit_header(gc->pc, rop, cmdlen);
192 (void) memcpy((void *) (gc->pc + 4), ptr, 4);
193 gc->pc += cmdlen;
194 if (__builtin_expect(gc->pc > gc->limit, 0)) {
195 (void) __glXFlushRenderBuffer(gc, gc->pc);
196 }
197 }
198
199 static FASTCALL NOINLINE void
200 generic_4_byte(GLint rop, const void *ptr)
201 {
202 __GLXcontext *const gc = __glXGetCurrentContext();
203 const GLuint cmdlen = 8;
204
205 emit_header(gc->pc, rop, cmdlen);
206 (void) memcpy((void *) (gc->pc + 4), ptr, 4);
207 gc->pc += cmdlen;
208 if (__builtin_expect(gc->pc > gc->limit, 0)) {
209 (void) __glXFlushRenderBuffer(gc, gc->pc);
210 }
211 }
212
213 static FASTCALL NOINLINE void
214 generic_6_byte(GLint rop, const void *ptr)
215 {
216 __GLXcontext *const gc = __glXGetCurrentContext();
217 const GLuint cmdlen = 12;
218
219 emit_header(gc->pc, rop, cmdlen);
220 (void) memcpy((void *) (gc->pc + 4), ptr, 8);
221 gc->pc += cmdlen;
222 if (__builtin_expect(gc->pc > gc->limit, 0)) {
223 (void) __glXFlushRenderBuffer(gc, gc->pc);
224 }
225 }
226
227 static FASTCALL NOINLINE void
228 generic_8_byte(GLint rop, const void *ptr)
229 {
230 __GLXcontext *const gc = __glXGetCurrentContext();
231 const GLuint cmdlen = 12;
232
233 emit_header(gc->pc, rop, cmdlen);
234 (void) memcpy((void *) (gc->pc + 4), ptr, 8);
235 gc->pc += cmdlen;
236 if (__builtin_expect(gc->pc > gc->limit, 0)) {
237 (void) __glXFlushRenderBuffer(gc, gc->pc);
238 }
239 }
240
241 static FASTCALL NOINLINE void
242 generic_12_byte(GLint rop, const void *ptr)
243 {
244 __GLXcontext *const gc = __glXGetCurrentContext();
245 const GLuint cmdlen = 16;
246
247 emit_header(gc->pc, rop, cmdlen);
248 (void) memcpy((void *) (gc->pc + 4), ptr, 12);
249 gc->pc += cmdlen;
250 if (__builtin_expect(gc->pc > gc->limit, 0)) {
251 (void) __glXFlushRenderBuffer(gc, gc->pc);
252 }
253 }
254
255 static FASTCALL NOINLINE void
256 generic_16_byte(GLint rop, const void *ptr)
257 {
258 __GLXcontext *const gc = __glXGetCurrentContext();
259 const GLuint cmdlen = 20;
260
261 emit_header(gc->pc, rop, cmdlen);
262 (void) memcpy((void *) (gc->pc + 4), ptr, 16);
263 gc->pc += cmdlen;
264 if (__builtin_expect(gc->pc > gc->limit, 0)) {
265 (void) __glXFlushRenderBuffer(gc, gc->pc);
266 }
267 }
268
269 static FASTCALL NOINLINE void
270 generic_24_byte(GLint rop, const void *ptr)
271 {
272 __GLXcontext *const gc = __glXGetCurrentContext();
273 const GLuint cmdlen = 28;
274
275 emit_header(gc->pc, rop, cmdlen);
276 (void) memcpy((void *) (gc->pc + 4), ptr, 24);
277 gc->pc += cmdlen;
278 if (__builtin_expect(gc->pc > gc->limit, 0)) {
279 (void) __glXFlushRenderBuffer(gc, gc->pc);
280 }
281 }
282
283 static FASTCALL NOINLINE void
284 generic_32_byte(GLint rop, const void *ptr)
285 {
286 __GLXcontext *const gc = __glXGetCurrentContext();
287 const GLuint cmdlen = 36;
288
289 emit_header(gc->pc, rop, cmdlen);
290 (void) memcpy((void *) (gc->pc + 4), ptr, 32);
291 gc->pc += cmdlen;
292 if (__builtin_expect(gc->pc > gc->limit, 0)) {
293 (void) __glXFlushRenderBuffer(gc, gc->pc);
294 }
295 }
296
297 #define X_GLsop_NewList 101
298 void
299 __indirect_glNewList(GLuint list, GLenum mode)
300 {
301 __GLXcontext *const gc = __glXGetCurrentContext();
302 Display *const dpy = gc->currentDpy;
303 #ifndef USE_XCB
304 const GLuint cmdlen = 8;
305 #endif
306 if (__builtin_expect(dpy != NULL, 1)) {
307 #ifdef USE_XCB
308 xcb_connection_t *c = XGetXCBConnection(dpy);
309 (void) __glXFlushRenderBuffer(gc, gc->pc);
310 xcb_glx_new_list(c, gc->currentContextTag, list, mode);
311 #else
312 GLubyte const *pc =
313 __glXSetupSingleRequest(gc, X_GLsop_NewList, cmdlen);
314 (void) memcpy((void *) (pc + 0), (void *) (&list), 4);
315 (void) memcpy((void *) (pc + 4), (void *) (&mode), 4);
316 UnlockDisplay(dpy);
317 SyncHandle();
318 #endif /* USE_XCB */
319 }
320 return;
321 }
322
323 #define X_GLsop_EndList 102
324 void
325 __indirect_glEndList(void)
326 {
327 __GLXcontext *const gc = __glXGetCurrentContext();
328 Display *const dpy = gc->currentDpy;
329 #ifndef USE_XCB
330 const GLuint cmdlen = 0;
331 #endif
332 if (__builtin_expect(dpy != NULL, 1)) {
333 #ifdef USE_XCB
334 xcb_connection_t *c = XGetXCBConnection(dpy);
335 (void) __glXFlushRenderBuffer(gc, gc->pc);
336 xcb_glx_end_list(c, gc->currentContextTag);
337 #else
338 (void) __glXSetupSingleRequest(gc, X_GLsop_EndList, cmdlen);
339 UnlockDisplay(dpy);
340 SyncHandle();
341 #endif /* USE_XCB */
342 }
343 return;
344 }
345
346 #define X_GLrop_CallList 1
347 void
348 __indirect_glCallList(GLuint list)
349 {
350 __GLXcontext *const gc = __glXGetCurrentContext();
351 const GLuint cmdlen = 8;
352 emit_header(gc->pc, X_GLrop_CallList, cmdlen);
353 (void) memcpy((void *) (gc->pc + 4), (void *) (&list), 4);
354 gc->pc += cmdlen;
355 if (__builtin_expect(gc->pc > gc->limit, 0)) {
356 (void) __glXFlushRenderBuffer(gc, gc->pc);
357 }
358 }
359
360 #define X_GLrop_CallLists 2
361 void
362 __indirect_glCallLists(GLsizei n, GLenum type, const GLvoid * lists)
363 {
364 __GLXcontext *const gc = __glXGetCurrentContext();
365 const GLuint compsize = __glCallLists_size(type);
366 const GLuint cmdlen = 12 + __GLX_PAD((compsize * n));
367 if (n < 0) {
368 __glXSetError(gc, GL_INVALID_VALUE);
369 return;
370 }
371 if (__builtin_expect((n >= 0) && (gc->currentDpy != NULL), 1)) {
372 if (cmdlen <= gc->maxSmallRenderCommandSize) {
373 if ((gc->pc + cmdlen) > gc->bufEnd) {
374 (void) __glXFlushRenderBuffer(gc, gc->pc);
375 }
376 emit_header(gc->pc, X_GLrop_CallLists, cmdlen);
377 (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
378 (void) memcpy((void *) (gc->pc + 8), (void *) (&type), 4);
379 (void) memcpy((void *) (gc->pc + 12), (void *) (lists),
380 (compsize * n));
381 gc->pc += cmdlen;
382 if (__builtin_expect(gc->pc > gc->limit, 0)) {
383 (void) __glXFlushRenderBuffer(gc, gc->pc);
384 }
385 } else {
386 const GLint op = X_GLrop_CallLists;
387 const GLuint cmdlenLarge = cmdlen + 4;
388 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
389 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
390 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
391 (void) memcpy((void *) (pc + 8), (void *) (&n), 4);
392 (void) memcpy((void *) (pc + 12), (void *) (&type), 4);
393 __glXSendLargeCommand(gc, pc, 16, lists, (compsize * n));
394 }
395 }
396 }
397
398 #define X_GLsop_DeleteLists 103
399 void
400 __indirect_glDeleteLists(GLuint list, GLsizei range)
401 {
402 __GLXcontext *const gc = __glXGetCurrentContext();
403 Display *const dpy = gc->currentDpy;
404 #ifndef USE_XCB
405 const GLuint cmdlen = 8;
406 #endif
407 if (__builtin_expect(dpy != NULL, 1)) {
408 #ifdef USE_XCB
409 xcb_connection_t *c = XGetXCBConnection(dpy);
410 (void) __glXFlushRenderBuffer(gc, gc->pc);
411 xcb_glx_delete_lists(c, gc->currentContextTag, list, range);
412 #else
413 GLubyte const *pc =
414 __glXSetupSingleRequest(gc, X_GLsop_DeleteLists, cmdlen);
415 (void) memcpy((void *) (pc + 0), (void *) (&list), 4);
416 (void) memcpy((void *) (pc + 4), (void *) (&range), 4);
417 UnlockDisplay(dpy);
418 SyncHandle();
419 #endif /* USE_XCB */
420 }
421 return;
422 }
423
424 #define X_GLsop_GenLists 104
425 GLuint
426 __indirect_glGenLists(GLsizei range)
427 {
428 __GLXcontext *const gc = __glXGetCurrentContext();
429 Display *const dpy = gc->currentDpy;
430 GLuint retval = (GLuint) 0;
431 #ifndef USE_XCB
432 const GLuint cmdlen = 4;
433 #endif
434 if (__builtin_expect(dpy != NULL, 1)) {
435 #ifdef USE_XCB
436 xcb_connection_t *c = XGetXCBConnection(dpy);
437 (void) __glXFlushRenderBuffer(gc, gc->pc);
438 xcb_glx_gen_lists_reply_t *reply =
439 xcb_glx_gen_lists_reply(c,
440 xcb_glx_gen_lists(c,
441 gc->currentContextTag,
442 range), NULL);
443 retval = reply->ret_val;
444 free(reply);
445 #else
446 GLubyte const *pc =
447 __glXSetupSingleRequest(gc, X_GLsop_GenLists, cmdlen);
448 (void) memcpy((void *) (pc + 0), (void *) (&range), 4);
449 retval = (GLuint) __glXReadReply(dpy, 0, NULL, GL_FALSE);
450 UnlockDisplay(dpy);
451 SyncHandle();
452 #endif /* USE_XCB */
453 }
454 return retval;
455 }
456
457 #define X_GLrop_ListBase 3
458 void
459 __indirect_glListBase(GLuint base)
460 {
461 __GLXcontext *const gc = __glXGetCurrentContext();
462 const GLuint cmdlen = 8;
463 emit_header(gc->pc, X_GLrop_ListBase, cmdlen);
464 (void) memcpy((void *) (gc->pc + 4), (void *) (&base), 4);
465 gc->pc += cmdlen;
466 if (__builtin_expect(gc->pc > gc->limit, 0)) {
467 (void) __glXFlushRenderBuffer(gc, gc->pc);
468 }
469 }
470
471 #define X_GLrop_Begin 4
472 void
473 __indirect_glBegin(GLenum mode)
474 {
475 __GLXcontext *const gc = __glXGetCurrentContext();
476 const GLuint cmdlen = 8;
477 emit_header(gc->pc, X_GLrop_Begin, cmdlen);
478 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
479 gc->pc += cmdlen;
480 if (__builtin_expect(gc->pc > gc->limit, 0)) {
481 (void) __glXFlushRenderBuffer(gc, gc->pc);
482 }
483 }
484
485 #define X_GLrop_Bitmap 5
486 void
487 __indirect_glBitmap(GLsizei width, GLsizei height, GLfloat xorig,
488 GLfloat yorig, GLfloat xmove, GLfloat ymove,
489 const GLubyte *bitmap)
490 {
491 __GLXcontext *const gc = __glXGetCurrentContext();
492 const GLuint compsize =
493 (bitmap != NULL) ? __glImageSize(width, height, 1, GL_COLOR_INDEX,
494 GL_BITMAP, 0) : 0;
495 const GLuint cmdlen = 48 + __GLX_PAD(compsize);
496 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
497 if (cmdlen <= gc->maxSmallRenderCommandSize) {
498 if ((gc->pc + cmdlen) > gc->bufEnd) {
499 (void) __glXFlushRenderBuffer(gc, gc->pc);
500 }
501 emit_header(gc->pc, X_GLrop_Bitmap, cmdlen);
502 (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4);
503 (void) memcpy((void *) (gc->pc + 28), (void *) (&height), 4);
504 (void) memcpy((void *) (gc->pc + 32), (void *) (&xorig), 4);
505 (void) memcpy((void *) (gc->pc + 36), (void *) (&yorig), 4);
506 (void) memcpy((void *) (gc->pc + 40), (void *) (&xmove), 4);
507 (void) memcpy((void *) (gc->pc + 44), (void *) (&ymove), 4);
508 if (compsize > 0) {
509 (*gc->fillImage) (gc, 2, width, height, 1, GL_COLOR_INDEX,
510 GL_BITMAP, bitmap, gc->pc + 48, gc->pc + 4);
511 } else {
512 (void) memcpy(gc->pc + 4, default_pixel_store_2D,
513 default_pixel_store_2D_size);
514 }
515 gc->pc += cmdlen;
516 if (gc->pc > gc->limit) {
517 (void) __glXFlushRenderBuffer(gc, gc->pc);
518 }
519 } else {
520 const GLint op = X_GLrop_Bitmap;
521 const GLuint cmdlenLarge = cmdlen + 4;
522 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
523 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
524 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
525 (void) memcpy((void *) (pc + 28), (void *) (&width), 4);
526 (void) memcpy((void *) (pc + 32), (void *) (&height), 4);
527 (void) memcpy((void *) (pc + 36), (void *) (&xorig), 4);
528 (void) memcpy((void *) (pc + 40), (void *) (&yorig), 4);
529 (void) memcpy((void *) (pc + 44), (void *) (&xmove), 4);
530 (void) memcpy((void *) (pc + 48), (void *) (&ymove), 4);
531 __glXSendLargeImage(gc, compsize, 2, width, height, 1,
532 GL_COLOR_INDEX, GL_BITMAP, bitmap, pc + 52,
533 pc + 8);
534 }
535 }
536 }
537
538 #define X_GLrop_Color3bv 6
539 void
540 __indirect_glColor3b(GLbyte red, GLbyte green, GLbyte blue)
541 {
542 __GLXcontext *const gc = __glXGetCurrentContext();
543 const GLuint cmdlen = 8;
544 emit_header(gc->pc, X_GLrop_Color3bv, cmdlen);
545 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
546 (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
547 (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
548 gc->pc += cmdlen;
549 if (__builtin_expect(gc->pc > gc->limit, 0)) {
550 (void) __glXFlushRenderBuffer(gc, gc->pc);
551 }
552 }
553
554 #define X_GLrop_Color3bv 6
555 void
556 __indirect_glColor3bv(const GLbyte *v)
557 {
558 generic_3_byte(X_GLrop_Color3bv, v);
559 }
560
561 #define X_GLrop_Color3dv 7
562 void
563 __indirect_glColor3d(GLdouble red, GLdouble green, GLdouble blue)
564 {
565 __GLXcontext *const gc = __glXGetCurrentContext();
566 const GLuint cmdlen = 28;
567 emit_header(gc->pc, X_GLrop_Color3dv, cmdlen);
568 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 8);
569 (void) memcpy((void *) (gc->pc + 12), (void *) (&green), 8);
570 (void) memcpy((void *) (gc->pc + 20), (void *) (&blue), 8);
571 gc->pc += cmdlen;
572 if (__builtin_expect(gc->pc > gc->limit, 0)) {
573 (void) __glXFlushRenderBuffer(gc, gc->pc);
574 }
575 }
576
577 #define X_GLrop_Color3dv 7
578 void
579 __indirect_glColor3dv(const GLdouble * v)
580 {
581 generic_24_byte(X_GLrop_Color3dv, v);
582 }
583
584 #define X_GLrop_Color3fv 8
585 void
586 __indirect_glColor3f(GLfloat red, GLfloat green, GLfloat blue)
587 {
588 __GLXcontext *const gc = __glXGetCurrentContext();
589 const GLuint cmdlen = 16;
590 emit_header(gc->pc, X_GLrop_Color3fv, cmdlen);
591 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
592 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
593 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
594 gc->pc += cmdlen;
595 if (__builtin_expect(gc->pc > gc->limit, 0)) {
596 (void) __glXFlushRenderBuffer(gc, gc->pc);
597 }
598 }
599
600 #define X_GLrop_Color3fv 8
601 void
602 __indirect_glColor3fv(const GLfloat * v)
603 {
604 generic_12_byte(X_GLrop_Color3fv, v);
605 }
606
607 #define X_GLrop_Color3iv 9
608 void
609 __indirect_glColor3i(GLint red, GLint green, GLint blue)
610 {
611 __GLXcontext *const gc = __glXGetCurrentContext();
612 const GLuint cmdlen = 16;
613 emit_header(gc->pc, X_GLrop_Color3iv, cmdlen);
614 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
615 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
616 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
617 gc->pc += cmdlen;
618 if (__builtin_expect(gc->pc > gc->limit, 0)) {
619 (void) __glXFlushRenderBuffer(gc, gc->pc);
620 }
621 }
622
623 #define X_GLrop_Color3iv 9
624 void
625 __indirect_glColor3iv(const GLint * v)
626 {
627 generic_12_byte(X_GLrop_Color3iv, v);
628 }
629
630 #define X_GLrop_Color3sv 10
631 void
632 __indirect_glColor3s(GLshort red, GLshort green, GLshort blue)
633 {
634 __GLXcontext *const gc = __glXGetCurrentContext();
635 const GLuint cmdlen = 12;
636 emit_header(gc->pc, X_GLrop_Color3sv, cmdlen);
637 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
638 (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
639 (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
640 gc->pc += cmdlen;
641 if (__builtin_expect(gc->pc > gc->limit, 0)) {
642 (void) __glXFlushRenderBuffer(gc, gc->pc);
643 }
644 }
645
646 #define X_GLrop_Color3sv 10
647 void
648 __indirect_glColor3sv(const GLshort * v)
649 {
650 generic_6_byte(X_GLrop_Color3sv, v);
651 }
652
653 #define X_GLrop_Color3ubv 11
654 void
655 __indirect_glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
656 {
657 __GLXcontext *const gc = __glXGetCurrentContext();
658 const GLuint cmdlen = 8;
659 emit_header(gc->pc, X_GLrop_Color3ubv, cmdlen);
660 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
661 (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
662 (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
663 gc->pc += cmdlen;
664 if (__builtin_expect(gc->pc > gc->limit, 0)) {
665 (void) __glXFlushRenderBuffer(gc, gc->pc);
666 }
667 }
668
669 #define X_GLrop_Color3ubv 11
670 void
671 __indirect_glColor3ubv(const GLubyte *v)
672 {
673 generic_3_byte(X_GLrop_Color3ubv, v);
674 }
675
676 #define X_GLrop_Color3uiv 12
677 void
678 __indirect_glColor3ui(GLuint red, GLuint green, GLuint blue)
679 {
680 __GLXcontext *const gc = __glXGetCurrentContext();
681 const GLuint cmdlen = 16;
682 emit_header(gc->pc, X_GLrop_Color3uiv, cmdlen);
683 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
684 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
685 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
686 gc->pc += cmdlen;
687 if (__builtin_expect(gc->pc > gc->limit, 0)) {
688 (void) __glXFlushRenderBuffer(gc, gc->pc);
689 }
690 }
691
692 #define X_GLrop_Color3uiv 12
693 void
694 __indirect_glColor3uiv(const GLuint * v)
695 {
696 generic_12_byte(X_GLrop_Color3uiv, v);
697 }
698
699 #define X_GLrop_Color3usv 13
700 void
701 __indirect_glColor3us(GLushort red, GLushort green, GLushort blue)
702 {
703 __GLXcontext *const gc = __glXGetCurrentContext();
704 const GLuint cmdlen = 12;
705 emit_header(gc->pc, X_GLrop_Color3usv, cmdlen);
706 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
707 (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
708 (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
709 gc->pc += cmdlen;
710 if (__builtin_expect(gc->pc > gc->limit, 0)) {
711 (void) __glXFlushRenderBuffer(gc, gc->pc);
712 }
713 }
714
715 #define X_GLrop_Color3usv 13
716 void
717 __indirect_glColor3usv(const GLushort * v)
718 {
719 generic_6_byte(X_GLrop_Color3usv, v);
720 }
721
722 #define X_GLrop_Color4bv 14
723 void
724 __indirect_glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
725 {
726 __GLXcontext *const gc = __glXGetCurrentContext();
727 const GLuint cmdlen = 8;
728 emit_header(gc->pc, X_GLrop_Color4bv, cmdlen);
729 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
730 (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
731 (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
732 (void) memcpy((void *) (gc->pc + 7), (void *) (&alpha), 1);
733 gc->pc += cmdlen;
734 if (__builtin_expect(gc->pc > gc->limit, 0)) {
735 (void) __glXFlushRenderBuffer(gc, gc->pc);
736 }
737 }
738
739 #define X_GLrop_Color4bv 14
740 void
741 __indirect_glColor4bv(const GLbyte *v)
742 {
743 generic_4_byte(X_GLrop_Color4bv, v);
744 }
745
746 #define X_GLrop_Color4dv 15
747 void
748 __indirect_glColor4d(GLdouble red, GLdouble green, GLdouble blue,
749 GLdouble alpha)
750 {
751 __GLXcontext *const gc = __glXGetCurrentContext();
752 const GLuint cmdlen = 36;
753 emit_header(gc->pc, X_GLrop_Color4dv, cmdlen);
754 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 8);
755 (void) memcpy((void *) (gc->pc + 12), (void *) (&green), 8);
756 (void) memcpy((void *) (gc->pc + 20), (void *) (&blue), 8);
757 (void) memcpy((void *) (gc->pc + 28), (void *) (&alpha), 8);
758 gc->pc += cmdlen;
759 if (__builtin_expect(gc->pc > gc->limit, 0)) {
760 (void) __glXFlushRenderBuffer(gc, gc->pc);
761 }
762 }
763
764 #define X_GLrop_Color4dv 15
765 void
766 __indirect_glColor4dv(const GLdouble * v)
767 {
768 generic_32_byte(X_GLrop_Color4dv, v);
769 }
770
771 #define X_GLrop_Color4fv 16
772 void
773 __indirect_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
774 {
775 __GLXcontext *const gc = __glXGetCurrentContext();
776 const GLuint cmdlen = 20;
777 emit_header(gc->pc, X_GLrop_Color4fv, cmdlen);
778 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
779 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
780 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
781 (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
782 gc->pc += cmdlen;
783 if (__builtin_expect(gc->pc > gc->limit, 0)) {
784 (void) __glXFlushRenderBuffer(gc, gc->pc);
785 }
786 }
787
788 #define X_GLrop_Color4fv 16
789 void
790 __indirect_glColor4fv(const GLfloat * v)
791 {
792 generic_16_byte(X_GLrop_Color4fv, v);
793 }
794
795 #define X_GLrop_Color4iv 17
796 void
797 __indirect_glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
798 {
799 __GLXcontext *const gc = __glXGetCurrentContext();
800 const GLuint cmdlen = 20;
801 emit_header(gc->pc, X_GLrop_Color4iv, cmdlen);
802 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
803 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
804 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
805 (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
806 gc->pc += cmdlen;
807 if (__builtin_expect(gc->pc > gc->limit, 0)) {
808 (void) __glXFlushRenderBuffer(gc, gc->pc);
809 }
810 }
811
812 #define X_GLrop_Color4iv 17
813 void
814 __indirect_glColor4iv(const GLint * v)
815 {
816 generic_16_byte(X_GLrop_Color4iv, v);
817 }
818
819 #define X_GLrop_Color4sv 18
820 void
821 __indirect_glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
822 {
823 __GLXcontext *const gc = __glXGetCurrentContext();
824 const GLuint cmdlen = 12;
825 emit_header(gc->pc, X_GLrop_Color4sv, cmdlen);
826 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
827 (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
828 (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
829 (void) memcpy((void *) (gc->pc + 10), (void *) (&alpha), 2);
830 gc->pc += cmdlen;
831 if (__builtin_expect(gc->pc > gc->limit, 0)) {
832 (void) __glXFlushRenderBuffer(gc, gc->pc);
833 }
834 }
835
836 #define X_GLrop_Color4sv 18
837 void
838 __indirect_glColor4sv(const GLshort * v)
839 {
840 generic_8_byte(X_GLrop_Color4sv, v);
841 }
842
843 #define X_GLrop_Color4ubv 19
844 void
845 __indirect_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
846 {
847 __GLXcontext *const gc = __glXGetCurrentContext();
848 const GLuint cmdlen = 8;
849 emit_header(gc->pc, X_GLrop_Color4ubv, cmdlen);
850 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
851 (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
852 (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
853 (void) memcpy((void *) (gc->pc + 7), (void *) (&alpha), 1);
854 gc->pc += cmdlen;
855 if (__builtin_expect(gc->pc > gc->limit, 0)) {
856 (void) __glXFlushRenderBuffer(gc, gc->pc);
857 }
858 }
859
860 #define X_GLrop_Color4ubv 19
861 void
862 __indirect_glColor4ubv(const GLubyte *v)
863 {
864 generic_4_byte(X_GLrop_Color4ubv, v);
865 }
866
867 #define X_GLrop_Color4uiv 20
868 void
869 __indirect_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
870 {
871 __GLXcontext *const gc = __glXGetCurrentContext();
872 const GLuint cmdlen = 20;
873 emit_header(gc->pc, X_GLrop_Color4uiv, cmdlen);
874 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
875 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
876 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
877 (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
878 gc->pc += cmdlen;
879 if (__builtin_expect(gc->pc > gc->limit, 0)) {
880 (void) __glXFlushRenderBuffer(gc, gc->pc);
881 }
882 }
883
884 #define X_GLrop_Color4uiv 20
885 void
886 __indirect_glColor4uiv(const GLuint * v)
887 {
888 generic_16_byte(X_GLrop_Color4uiv, v);
889 }
890
891 #define X_GLrop_Color4usv 21
892 void
893 __indirect_glColor4us(GLushort red, GLushort green, GLushort blue,
894 GLushort alpha)
895 {
896 __GLXcontext *const gc = __glXGetCurrentContext();
897 const GLuint cmdlen = 12;
898 emit_header(gc->pc, X_GLrop_Color4usv, cmdlen);
899 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
900 (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
901 (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
902 (void) memcpy((void *) (gc->pc + 10), (void *) (&alpha), 2);
903 gc->pc += cmdlen;
904 if (__builtin_expect(gc->pc > gc->limit, 0)) {
905 (void) __glXFlushRenderBuffer(gc, gc->pc);
906 }
907 }
908
909 #define X_GLrop_Color4usv 21
910 void
911 __indirect_glColor4usv(const GLushort * v)
912 {
913 generic_8_byte(X_GLrop_Color4usv, v);
914 }
915
916 #define X_GLrop_EdgeFlagv 22
917 void
918 __indirect_glEdgeFlag(GLboolean flag)
919 {
920 __GLXcontext *const gc = __glXGetCurrentContext();
921 const GLuint cmdlen = 8;
922 emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
923 (void) memcpy((void *) (gc->pc + 4), (void *) (&flag), 1);
924 gc->pc += cmdlen;
925 if (__builtin_expect(gc->pc > gc->limit, 0)) {
926 (void) __glXFlushRenderBuffer(gc, gc->pc);
927 }
928 }
929
930 #define X_GLrop_EdgeFlagv 22
931 void
932 __indirect_glEdgeFlagv(const GLboolean * flag)
933 {
934 __GLXcontext *const gc = __glXGetCurrentContext();
935 const GLuint cmdlen = 8;
936 emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
937 (void) memcpy((void *) (gc->pc + 4), (void *) (flag), 1);
938 gc->pc += cmdlen;
939 if (__builtin_expect(gc->pc > gc->limit, 0)) {
940 (void) __glXFlushRenderBuffer(gc, gc->pc);
941 }
942 }
943
944 #define X_GLrop_End 23
945 void
946 __indirect_glEnd(void)
947 {
948 __GLXcontext *const gc = __glXGetCurrentContext();
949 const GLuint cmdlen = 4;
950 emit_header(gc->pc, X_GLrop_End, cmdlen);
951 gc->pc += cmdlen;
952 if (__builtin_expect(gc->pc > gc->limit, 0)) {
953 (void) __glXFlushRenderBuffer(gc, gc->pc);
954 }
955 }
956
957 #define X_GLrop_Indexdv 24
958 void
959 __indirect_glIndexd(GLdouble c)
960 {
961 __GLXcontext *const gc = __glXGetCurrentContext();
962 const GLuint cmdlen = 12;
963 emit_header(gc->pc, X_GLrop_Indexdv, cmdlen);
964 (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 8);
965 gc->pc += cmdlen;
966 if (__builtin_expect(gc->pc > gc->limit, 0)) {
967 (void) __glXFlushRenderBuffer(gc, gc->pc);
968 }
969 }
970
971 #define X_GLrop_Indexdv 24
972 void
973 __indirect_glIndexdv(const GLdouble * c)
974 {
975 generic_8_byte(X_GLrop_Indexdv, c);
976 }
977
978 #define X_GLrop_Indexfv 25
979 void
980 __indirect_glIndexf(GLfloat c)
981 {
982 __GLXcontext *const gc = __glXGetCurrentContext();
983 const GLuint cmdlen = 8;
984 emit_header(gc->pc, X_GLrop_Indexfv, cmdlen);
985 (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 4);
986 gc->pc += cmdlen;
987 if (__builtin_expect(gc->pc > gc->limit, 0)) {
988 (void) __glXFlushRenderBuffer(gc, gc->pc);
989 }
990 }
991
992 #define X_GLrop_Indexfv 25
993 void
994 __indirect_glIndexfv(const GLfloat * c)
995 {
996 generic_4_byte(X_GLrop_Indexfv, c);
997 }
998
999 #define X_GLrop_Indexiv 26
1000 void
1001 __indirect_glIndexi(GLint c)
1002 {
1003 __GLXcontext *const gc = __glXGetCurrentContext();
1004 const GLuint cmdlen = 8;
1005 emit_header(gc->pc, X_GLrop_Indexiv, cmdlen);
1006 (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 4);
1007 gc->pc += cmdlen;
1008 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1009 (void) __glXFlushRenderBuffer(gc, gc->pc);
1010 }
1011 }
1012
1013 #define X_GLrop_Indexiv 26
1014 void
1015 __indirect_glIndexiv(const GLint * c)
1016 {
1017 generic_4_byte(X_GLrop_Indexiv, c);
1018 }
1019
1020 #define X_GLrop_Indexsv 27
1021 void
1022 __indirect_glIndexs(GLshort c)
1023 {
1024 __GLXcontext *const gc = __glXGetCurrentContext();
1025 const GLuint cmdlen = 8;
1026 emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
1027 (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 2);
1028 gc->pc += cmdlen;
1029 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1030 (void) __glXFlushRenderBuffer(gc, gc->pc);
1031 }
1032 }
1033
1034 #define X_GLrop_Indexsv 27
1035 void
1036 __indirect_glIndexsv(const GLshort * c)
1037 {
1038 __GLXcontext *const gc = __glXGetCurrentContext();
1039 const GLuint cmdlen = 8;
1040 emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
1041 (void) memcpy((void *) (gc->pc + 4), (void *) (c), 2);
1042 gc->pc += cmdlen;
1043 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1044 (void) __glXFlushRenderBuffer(gc, gc->pc);
1045 }
1046 }
1047
1048 #define X_GLrop_Normal3bv 28
1049 void
1050 __indirect_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
1051 {
1052 __GLXcontext *const gc = __glXGetCurrentContext();
1053 const GLuint cmdlen = 8;
1054 emit_header(gc->pc, X_GLrop_Normal3bv, cmdlen);
1055 (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 1);
1056 (void) memcpy((void *) (gc->pc + 5), (void *) (&ny), 1);
1057 (void) memcpy((void *) (gc->pc + 6), (void *) (&nz), 1);
1058 gc->pc += cmdlen;
1059 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1060 (void) __glXFlushRenderBuffer(gc, gc->pc);
1061 }
1062 }
1063
1064 #define X_GLrop_Normal3bv 28
1065 void
1066 __indirect_glNormal3bv(const GLbyte *v)
1067 {
1068 generic_3_byte(X_GLrop_Normal3bv, v);
1069 }
1070
1071 #define X_GLrop_Normal3dv 29
1072 void
1073 __indirect_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
1074 {
1075 __GLXcontext *const gc = __glXGetCurrentContext();
1076 const GLuint cmdlen = 28;
1077 emit_header(gc->pc, X_GLrop_Normal3dv, cmdlen);
1078 (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 8);
1079 (void) memcpy((void *) (gc->pc + 12), (void *) (&ny), 8);
1080 (void) memcpy((void *) (gc->pc + 20), (void *) (&nz), 8);
1081 gc->pc += cmdlen;
1082 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1083 (void) __glXFlushRenderBuffer(gc, gc->pc);
1084 }
1085 }
1086
1087 #define X_GLrop_Normal3dv 29
1088 void
1089 __indirect_glNormal3dv(const GLdouble * v)
1090 {
1091 generic_24_byte(X_GLrop_Normal3dv, v);
1092 }
1093
1094 #define X_GLrop_Normal3fv 30
1095 void
1096 __indirect_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
1097 {
1098 __GLXcontext *const gc = __glXGetCurrentContext();
1099 const GLuint cmdlen = 16;
1100 emit_header(gc->pc, X_GLrop_Normal3fv, cmdlen);
1101 (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 4);
1102 (void) memcpy((void *) (gc->pc + 8), (void *) (&ny), 4);
1103 (void) memcpy((void *) (gc->pc + 12), (void *) (&nz), 4);
1104 gc->pc += cmdlen;
1105 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1106 (void) __glXFlushRenderBuffer(gc, gc->pc);
1107 }
1108 }
1109
1110 #define X_GLrop_Normal3fv 30
1111 void
1112 __indirect_glNormal3fv(const GLfloat * v)
1113 {
1114 generic_12_byte(X_GLrop_Normal3fv, v);
1115 }
1116
1117 #define X_GLrop_Normal3iv 31
1118 void
1119 __indirect_glNormal3i(GLint nx, GLint ny, GLint nz)
1120 {
1121 __GLXcontext *const gc = __glXGetCurrentContext();
1122 const GLuint cmdlen = 16;
1123 emit_header(gc->pc, X_GLrop_Normal3iv, cmdlen);
1124 (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 4);
1125 (void) memcpy((void *) (gc->pc + 8), (void *) (&ny), 4);
1126 (void) memcpy((void *) (gc->pc + 12), (void *) (&nz), 4);
1127 gc->pc += cmdlen;
1128 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1129 (void) __glXFlushRenderBuffer(gc, gc->pc);
1130 }
1131 }
1132
1133 #define X_GLrop_Normal3iv 31
1134 void
1135 __indirect_glNormal3iv(const GLint * v)
1136 {
1137 generic_12_byte(X_GLrop_Normal3iv, v);
1138 }
1139
1140 #define X_GLrop_Normal3sv 32
1141 void
1142 __indirect_glNormal3s(GLshort nx, GLshort ny, GLshort nz)
1143 {
1144 __GLXcontext *const gc = __glXGetCurrentContext();
1145 const GLuint cmdlen = 12;
1146 emit_header(gc->pc, X_GLrop_Normal3sv, cmdlen);
1147 (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 2);
1148 (void) memcpy((void *) (gc->pc + 6), (void *) (&ny), 2);
1149 (void) memcpy((void *) (gc->pc + 8), (void *) (&nz), 2);
1150 gc->pc += cmdlen;
1151 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1152 (void) __glXFlushRenderBuffer(gc, gc->pc);
1153 }
1154 }
1155
1156 #define X_GLrop_Normal3sv 32
1157 void
1158 __indirect_glNormal3sv(const GLshort * v)
1159 {
1160 generic_6_byte(X_GLrop_Normal3sv, v);
1161 }
1162
1163 #define X_GLrop_RasterPos2dv 33
1164 void
1165 __indirect_glRasterPos2d(GLdouble x, GLdouble y)
1166 {
1167 __GLXcontext *const gc = __glXGetCurrentContext();
1168 const GLuint cmdlen = 20;
1169 emit_header(gc->pc, X_GLrop_RasterPos2dv, cmdlen);
1170 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
1171 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
1172 gc->pc += cmdlen;
1173 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1174 (void) __glXFlushRenderBuffer(gc, gc->pc);
1175 }
1176 }
1177
1178 #define X_GLrop_RasterPos2dv 33
1179 void
1180 __indirect_glRasterPos2dv(const GLdouble * v)
1181 {
1182 generic_16_byte(X_GLrop_RasterPos2dv, v);
1183 }
1184
1185 #define X_GLrop_RasterPos2fv 34
1186 void
1187 __indirect_glRasterPos2f(GLfloat x, GLfloat y)
1188 {
1189 __GLXcontext *const gc = __glXGetCurrentContext();
1190 const GLuint cmdlen = 12;
1191 emit_header(gc->pc, X_GLrop_RasterPos2fv, cmdlen);
1192 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1193 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1194 gc->pc += cmdlen;
1195 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1196 (void) __glXFlushRenderBuffer(gc, gc->pc);
1197 }
1198 }
1199
1200 #define X_GLrop_RasterPos2fv 34
1201 void
1202 __indirect_glRasterPos2fv(const GLfloat * v)
1203 {
1204 generic_8_byte(X_GLrop_RasterPos2fv, v);
1205 }
1206
1207 #define X_GLrop_RasterPos2iv 35
1208 void
1209 __indirect_glRasterPos2i(GLint x, GLint y)
1210 {
1211 __GLXcontext *const gc = __glXGetCurrentContext();
1212 const GLuint cmdlen = 12;
1213 emit_header(gc->pc, X_GLrop_RasterPos2iv, cmdlen);
1214 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1215 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1216 gc->pc += cmdlen;
1217 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1218 (void) __glXFlushRenderBuffer(gc, gc->pc);
1219 }
1220 }
1221
1222 #define X_GLrop_RasterPos2iv 35
1223 void
1224 __indirect_glRasterPos2iv(const GLint * v)
1225 {
1226 generic_8_byte(X_GLrop_RasterPos2iv, v);
1227 }
1228
1229 #define X_GLrop_RasterPos2sv 36
1230 void
1231 __indirect_glRasterPos2s(GLshort x, GLshort y)
1232 {
1233 __GLXcontext *const gc = __glXGetCurrentContext();
1234 const GLuint cmdlen = 8;
1235 emit_header(gc->pc, X_GLrop_RasterPos2sv, cmdlen);
1236 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
1237 (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
1238 gc->pc += cmdlen;
1239 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1240 (void) __glXFlushRenderBuffer(gc, gc->pc);
1241 }
1242 }
1243
1244 #define X_GLrop_RasterPos2sv 36
1245 void
1246 __indirect_glRasterPos2sv(const GLshort * v)
1247 {
1248 generic_4_byte(X_GLrop_RasterPos2sv, v);
1249 }
1250
1251 #define X_GLrop_RasterPos3dv 37
1252 void
1253 __indirect_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
1254 {
1255 __GLXcontext *const gc = __glXGetCurrentContext();
1256 const GLuint cmdlen = 28;
1257 emit_header(gc->pc, X_GLrop_RasterPos3dv, cmdlen);
1258 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
1259 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
1260 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
1261 gc->pc += cmdlen;
1262 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1263 (void) __glXFlushRenderBuffer(gc, gc->pc);
1264 }
1265 }
1266
1267 #define X_GLrop_RasterPos3dv 37
1268 void
1269 __indirect_glRasterPos3dv(const GLdouble * v)
1270 {
1271 generic_24_byte(X_GLrop_RasterPos3dv, v);
1272 }
1273
1274 #define X_GLrop_RasterPos3fv 38
1275 void
1276 __indirect_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
1277 {
1278 __GLXcontext *const gc = __glXGetCurrentContext();
1279 const GLuint cmdlen = 16;
1280 emit_header(gc->pc, X_GLrop_RasterPos3fv, cmdlen);
1281 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1282 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1283 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
1284 gc->pc += cmdlen;
1285 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1286 (void) __glXFlushRenderBuffer(gc, gc->pc);
1287 }
1288 }
1289
1290 #define X_GLrop_RasterPos3fv 38
1291 void
1292 __indirect_glRasterPos3fv(const GLfloat * v)
1293 {
1294 generic_12_byte(X_GLrop_RasterPos3fv, v);
1295 }
1296
1297 #define X_GLrop_RasterPos3iv 39
1298 void
1299 __indirect_glRasterPos3i(GLint x, GLint y, GLint z)
1300 {
1301 __GLXcontext *const gc = __glXGetCurrentContext();
1302 const GLuint cmdlen = 16;
1303 emit_header(gc->pc, X_GLrop_RasterPos3iv, cmdlen);
1304 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1305 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1306 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
1307 gc->pc += cmdlen;
1308 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1309 (void) __glXFlushRenderBuffer(gc, gc->pc);
1310 }
1311 }
1312
1313 #define X_GLrop_RasterPos3iv 39
1314 void
1315 __indirect_glRasterPos3iv(const GLint * v)
1316 {
1317 generic_12_byte(X_GLrop_RasterPos3iv, v);
1318 }
1319
1320 #define X_GLrop_RasterPos3sv 40
1321 void
1322 __indirect_glRasterPos3s(GLshort x, GLshort y, GLshort z)
1323 {
1324 __GLXcontext *const gc = __glXGetCurrentContext();
1325 const GLuint cmdlen = 12;
1326 emit_header(gc->pc, X_GLrop_RasterPos3sv, cmdlen);
1327 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
1328 (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
1329 (void) memcpy((void *) (gc->pc + 8), (void *) (&z), 2);
1330 gc->pc += cmdlen;
1331 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1332 (void) __glXFlushRenderBuffer(gc, gc->pc);
1333 }
1334 }
1335
1336 #define X_GLrop_RasterPos3sv 40
1337 void
1338 __indirect_glRasterPos3sv(const GLshort * v)
1339 {
1340 generic_6_byte(X_GLrop_RasterPos3sv, v);
1341 }
1342
1343 #define X_GLrop_RasterPos4dv 41
1344 void
1345 __indirect_glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1346 {
1347 __GLXcontext *const gc = __glXGetCurrentContext();
1348 const GLuint cmdlen = 36;
1349 emit_header(gc->pc, X_GLrop_RasterPos4dv, cmdlen);
1350 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
1351 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
1352 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
1353 (void) memcpy((void *) (gc->pc + 28), (void *) (&w), 8);
1354 gc->pc += cmdlen;
1355 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1356 (void) __glXFlushRenderBuffer(gc, gc->pc);
1357 }
1358 }
1359
1360 #define X_GLrop_RasterPos4dv 41
1361 void
1362 __indirect_glRasterPos4dv(const GLdouble * v)
1363 {
1364 generic_32_byte(X_GLrop_RasterPos4dv, v);
1365 }
1366
1367 #define X_GLrop_RasterPos4fv 42
1368 void
1369 __indirect_glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1370 {
1371 __GLXcontext *const gc = __glXGetCurrentContext();
1372 const GLuint cmdlen = 20;
1373 emit_header(gc->pc, X_GLrop_RasterPos4fv, cmdlen);
1374 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1375 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1376 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
1377 (void) memcpy((void *) (gc->pc + 16), (void *) (&w), 4);
1378 gc->pc += cmdlen;
1379 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1380 (void) __glXFlushRenderBuffer(gc, gc->pc);
1381 }
1382 }
1383
1384 #define X_GLrop_RasterPos4fv 42
1385 void
1386 __indirect_glRasterPos4fv(const GLfloat * v)
1387 {
1388 generic_16_byte(X_GLrop_RasterPos4fv, v);
1389 }
1390
1391 #define X_GLrop_RasterPos4iv 43
1392 void
1393 __indirect_glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
1394 {
1395 __GLXcontext *const gc = __glXGetCurrentContext();
1396 const GLuint cmdlen = 20;
1397 emit_header(gc->pc, X_GLrop_RasterPos4iv, cmdlen);
1398 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1399 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1400 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
1401 (void) memcpy((void *) (gc->pc + 16), (void *) (&w), 4);
1402 gc->pc += cmdlen;
1403 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1404 (void) __glXFlushRenderBuffer(gc, gc->pc);
1405 }
1406 }
1407
1408 #define X_GLrop_RasterPos4iv 43
1409 void
1410 __indirect_glRasterPos4iv(const GLint * v)
1411 {
1412 generic_16_byte(X_GLrop_RasterPos4iv, v);
1413 }
1414
1415 #define X_GLrop_RasterPos4sv 44
1416 void
1417 __indirect_glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
1418 {
1419 __GLXcontext *const gc = __glXGetCurrentContext();
1420 const GLuint cmdlen = 12;
1421 emit_header(gc->pc, X_GLrop_RasterPos4sv, cmdlen);
1422 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
1423 (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
1424 (void) memcpy((void *) (gc->pc + 8), (void *) (&z), 2);
1425 (void) memcpy((void *) (gc->pc + 10), (void *) (&w), 2);
1426 gc->pc += cmdlen;
1427 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1428 (void) __glXFlushRenderBuffer(gc, gc->pc);
1429 }
1430 }
1431
1432 #define X_GLrop_RasterPos4sv 44
1433 void
1434 __indirect_glRasterPos4sv(const GLshort * v)
1435 {
1436 generic_8_byte(X_GLrop_RasterPos4sv, v);
1437 }
1438
1439 #define X_GLrop_Rectdv 45
1440 void
1441 __indirect_glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
1442 {
1443 __GLXcontext *const gc = __glXGetCurrentContext();
1444 const GLuint cmdlen = 36;
1445 emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
1446 (void) memcpy((void *) (gc->pc + 4), (void *) (&x1), 8);
1447 (void) memcpy((void *) (gc->pc + 12), (void *) (&y1), 8);
1448 (void) memcpy((void *) (gc->pc + 20), (void *) (&x2), 8);
1449 (void) memcpy((void *) (gc->pc + 28), (void *) (&y2), 8);
1450 gc->pc += cmdlen;
1451 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1452 (void) __glXFlushRenderBuffer(gc, gc->pc);
1453 }
1454 }
1455
1456 #define X_GLrop_Rectdv 45
1457 void
1458 __indirect_glRectdv(const GLdouble * v1, const GLdouble * v2)
1459 {
1460 __GLXcontext *const gc = __glXGetCurrentContext();
1461 const GLuint cmdlen = 36;
1462 emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
1463 (void) memcpy((void *) (gc->pc + 4), (void *) (v1), 16);
1464 (void) memcpy((void *) (gc->pc + 20), (void *) (v2), 16);
1465 gc->pc += cmdlen;
1466 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1467 (void) __glXFlushRenderBuffer(gc, gc->pc);
1468 }
1469 }
1470
1471 #define X_GLrop_Rectfv 46
1472 void
1473 __indirect_glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
1474 {
1475 __GLXcontext *const gc = __glXGetCurrentContext();
1476 const GLuint cmdlen = 20;
1477 emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
1478 (void) memcpy((void *) (gc->pc + 4), (void *) (&x1), 4);
1479 (void) memcpy((void *) (gc->pc + 8), (void *) (&y1), 4);
1480 (void) memcpy((void *) (gc->pc + 12), (void *) (&x2), 4);
1481 (void) memcpy((void *) (gc->pc + 16), (void *) (&y2), 4);
1482 gc->pc += cmdlen;
1483 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1484 (void) __glXFlushRenderBuffer(gc, gc->pc);
1485 }
1486 }
1487
1488 #define X_GLrop_Rectfv 46
1489 void
1490 __indirect_glRectfv(const GLfloat * v1, const GLfloat * v2)
1491 {
1492 __GLXcontext *const gc = __glXGetCurrentContext();
1493 const GLuint cmdlen = 20;
1494 emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
1495 (void) memcpy((void *) (gc->pc + 4), (void *) (v1), 8);
1496 (void) memcpy((void *) (gc->pc + 12), (void *) (v2), 8);
1497 gc->pc += cmdlen;
1498 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1499 (void) __glXFlushRenderBuffer(gc, gc->pc);
1500 }
1501 }
1502
1503 #define X_GLrop_Rectiv 47
1504 void
1505 __indirect_glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
1506 {
1507 __GLXcontext *const gc = __glXGetCurrentContext();
1508 const GLuint cmdlen = 20;
1509 emit_header(gc->pc, X_GLrop_Rectiv, cmdlen);
1510 (void) memcpy((void *) (gc->pc + 4), (void *) (&x1), 4);
1511 (void) memcpy((void *) (gc->pc + 8), (void *) (&y1), 4);
1512 (void) memcpy((void *) (gc->pc + 12), (void *) (&x2), 4);
1513 (void) memcpy((void *) (gc->pc + 16), (void *) (&y2), 4);
1514 gc->pc += cmdlen;
1515 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1516 (void) __glXFlushRenderBuffer(gc, gc->pc);
1517 }
1518 }
1519
1520 #define X_GLrop_Rectiv 47
1521 void
1522 __indirect_glRectiv(const GLint * v1, const GLint * v2)
1523 {
1524 __GLXcontext *const gc = __glXGetCurrentContext();
1525 const GLuint cmdlen = 20;
1526 emit_header(gc->pc, X_GLrop_Rectiv, cmdlen);
1527 (void) memcpy((void *) (gc->pc + 4), (void *) (v1), 8);
1528 (void) memcpy((void *) (gc->pc + 12), (void *) (v2), 8);
1529 gc->pc += cmdlen;
1530 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1531 (void) __glXFlushRenderBuffer(gc, gc->pc);
1532 }
1533 }
1534
1535 #define X_GLrop_Rectsv 48
1536 void
1537 __indirect_glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
1538 {
1539 __GLXcontext *const gc = __glXGetCurrentContext();
1540 const GLuint cmdlen = 12;
1541 emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
1542 (void) memcpy((void *) (gc->pc + 4), (void *) (&x1), 2);
1543 (void) memcpy((void *) (gc->pc + 6), (void *) (&y1), 2);
1544 (void) memcpy((void *) (gc->pc + 8), (void *) (&x2), 2);
1545 (void) memcpy((void *) (gc->pc + 10), (void *) (&y2), 2);
1546 gc->pc += cmdlen;
1547 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1548 (void) __glXFlushRenderBuffer(gc, gc->pc);
1549 }
1550 }
1551
1552 #define X_GLrop_Rectsv 48
1553 void
1554 __indirect_glRectsv(const GLshort * v1, const GLshort * v2)
1555 {
1556 __GLXcontext *const gc = __glXGetCurrentContext();
1557 const GLuint cmdlen = 12;
1558 emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
1559 (void) memcpy((void *) (gc->pc + 4), (void *) (v1), 4);
1560 (void) memcpy((void *) (gc->pc + 8), (void *) (v2), 4);
1561 gc->pc += cmdlen;
1562 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1563 (void) __glXFlushRenderBuffer(gc, gc->pc);
1564 }
1565 }
1566
1567 #define X_GLrop_TexCoord1dv 49
1568 void
1569 __indirect_glTexCoord1d(GLdouble s)
1570 {
1571 __GLXcontext *const gc = __glXGetCurrentContext();
1572 const GLuint cmdlen = 12;
1573 emit_header(gc->pc, X_GLrop_TexCoord1dv, cmdlen);
1574 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
1575 gc->pc += cmdlen;
1576 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1577 (void) __glXFlushRenderBuffer(gc, gc->pc);
1578 }
1579 }
1580
1581 #define X_GLrop_TexCoord1dv 49
1582 void
1583 __indirect_glTexCoord1dv(const GLdouble * v)
1584 {
1585 generic_8_byte(X_GLrop_TexCoord1dv, v);
1586 }
1587
1588 #define X_GLrop_TexCoord1fv 50
1589 void
1590 __indirect_glTexCoord1f(GLfloat s)
1591 {
1592 __GLXcontext *const gc = __glXGetCurrentContext();
1593 const GLuint cmdlen = 8;
1594 emit_header(gc->pc, X_GLrop_TexCoord1fv, cmdlen);
1595 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1596 gc->pc += cmdlen;
1597 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1598 (void) __glXFlushRenderBuffer(gc, gc->pc);
1599 }
1600 }
1601
1602 #define X_GLrop_TexCoord1fv 50
1603 void
1604 __indirect_glTexCoord1fv(const GLfloat * v)
1605 {
1606 generic_4_byte(X_GLrop_TexCoord1fv, v);
1607 }
1608
1609 #define X_GLrop_TexCoord1iv 51
1610 void
1611 __indirect_glTexCoord1i(GLint s)
1612 {
1613 __GLXcontext *const gc = __glXGetCurrentContext();
1614 const GLuint cmdlen = 8;
1615 emit_header(gc->pc, X_GLrop_TexCoord1iv, cmdlen);
1616 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1617 gc->pc += cmdlen;
1618 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1619 (void) __glXFlushRenderBuffer(gc, gc->pc);
1620 }
1621 }
1622
1623 #define X_GLrop_TexCoord1iv 51
1624 void
1625 __indirect_glTexCoord1iv(const GLint * v)
1626 {
1627 generic_4_byte(X_GLrop_TexCoord1iv, v);
1628 }
1629
1630 #define X_GLrop_TexCoord1sv 52
1631 void
1632 __indirect_glTexCoord1s(GLshort s)
1633 {
1634 __GLXcontext *const gc = __glXGetCurrentContext();
1635 const GLuint cmdlen = 8;
1636 emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
1637 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 2);
1638 gc->pc += cmdlen;
1639 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1640 (void) __glXFlushRenderBuffer(gc, gc->pc);
1641 }
1642 }
1643
1644 #define X_GLrop_TexCoord1sv 52
1645 void
1646 __indirect_glTexCoord1sv(const GLshort * v)
1647 {
1648 __GLXcontext *const gc = __glXGetCurrentContext();
1649 const GLuint cmdlen = 8;
1650 emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
1651 (void) memcpy((void *) (gc->pc + 4), (void *) (v), 2);
1652 gc->pc += cmdlen;
1653 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1654 (void) __glXFlushRenderBuffer(gc, gc->pc);
1655 }
1656 }
1657
1658 #define X_GLrop_TexCoord2dv 53
1659 void
1660 __indirect_glTexCoord2d(GLdouble s, GLdouble t)
1661 {
1662 __GLXcontext *const gc = __glXGetCurrentContext();
1663 const GLuint cmdlen = 20;
1664 emit_header(gc->pc, X_GLrop_TexCoord2dv, cmdlen);
1665 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
1666 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
1667 gc->pc += cmdlen;
1668 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1669 (void) __glXFlushRenderBuffer(gc, gc->pc);
1670 }
1671 }
1672
1673 #define X_GLrop_TexCoord2dv 53
1674 void
1675 __indirect_glTexCoord2dv(const GLdouble * v)
1676 {
1677 generic_16_byte(X_GLrop_TexCoord2dv, v);
1678 }
1679
1680 #define X_GLrop_TexCoord2fv 54
1681 void
1682 __indirect_glTexCoord2f(GLfloat s, GLfloat t)
1683 {
1684 __GLXcontext *const gc = __glXGetCurrentContext();
1685 const GLuint cmdlen = 12;
1686 emit_header(gc->pc, X_GLrop_TexCoord2fv, cmdlen);
1687 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1688 (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
1689 gc->pc += cmdlen;
1690 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1691 (void) __glXFlushRenderBuffer(gc, gc->pc);
1692 }
1693 }
1694
1695 #define X_GLrop_TexCoord2fv 54
1696 void
1697 __indirect_glTexCoord2fv(const GLfloat * v)
1698 {
1699 generic_8_byte(X_GLrop_TexCoord2fv, v);
1700 }
1701
1702 #define X_GLrop_TexCoord2iv 55
1703 void
1704 __indirect_glTexCoord2i(GLint s, GLint t)
1705 {
1706 __GLXcontext *const gc = __glXGetCurrentContext();
1707 const GLuint cmdlen = 12;
1708 emit_header(gc->pc, X_GLrop_TexCoord2iv, cmdlen);
1709 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1710 (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
1711 gc->pc += cmdlen;
1712 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1713 (void) __glXFlushRenderBuffer(gc, gc->pc);
1714 }
1715 }
1716
1717 #define X_GLrop_TexCoord2iv 55
1718 void
1719 __indirect_glTexCoord2iv(const GLint * v)
1720 {
1721 generic_8_byte(X_GLrop_TexCoord2iv, v);
1722 }
1723
1724 #define X_GLrop_TexCoord2sv 56
1725 void
1726 __indirect_glTexCoord2s(GLshort s, GLshort t)
1727 {
1728 __GLXcontext *const gc = __glXGetCurrentContext();
1729 const GLuint cmdlen = 8;
1730 emit_header(gc->pc, X_GLrop_TexCoord2sv, cmdlen);
1731 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 2);
1732 (void) memcpy((void *) (gc->pc + 6), (void *) (&t), 2);
1733 gc->pc += cmdlen;
1734 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1735 (void) __glXFlushRenderBuffer(gc, gc->pc);
1736 }
1737 }
1738
1739 #define X_GLrop_TexCoord2sv 56
1740 void
1741 __indirect_glTexCoord2sv(const GLshort * v)
1742 {
1743 generic_4_byte(X_GLrop_TexCoord2sv, v);
1744 }
1745
1746 #define X_GLrop_TexCoord3dv 57
1747 void
1748 __indirect_glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
1749 {
1750 __GLXcontext *const gc = __glXGetCurrentContext();
1751 const GLuint cmdlen = 28;
1752 emit_header(gc->pc, X_GLrop_TexCoord3dv, cmdlen);
1753 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
1754 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
1755 (void) memcpy((void *) (gc->pc + 20), (void *) (&r), 8);
1756 gc->pc += cmdlen;
1757 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1758 (void) __glXFlushRenderBuffer(gc, gc->pc);
1759 }
1760 }
1761
1762 #define X_GLrop_TexCoord3dv 57
1763 void
1764 __indirect_glTexCoord3dv(const GLdouble * v)
1765 {
1766 generic_24_byte(X_GLrop_TexCoord3dv, v);
1767 }
1768
1769 #define X_GLrop_TexCoord3fv 58
1770 void
1771 __indirect_glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
1772 {
1773 __GLXcontext *const gc = __glXGetCurrentContext();
1774 const GLuint cmdlen = 16;
1775 emit_header(gc->pc, X_GLrop_TexCoord3fv, cmdlen);
1776 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1777 (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
1778 (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 4);
1779 gc->pc += cmdlen;
1780 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1781 (void) __glXFlushRenderBuffer(gc, gc->pc);
1782 }
1783 }
1784
1785 #define X_GLrop_TexCoord3fv 58
1786 void
1787 __indirect_glTexCoord3fv(const GLfloat * v)
1788 {
1789 generic_12_byte(X_GLrop_TexCoord3fv, v);
1790 }
1791
1792 #define X_GLrop_TexCoord3iv 59
1793 void
1794 __indirect_glTexCoord3i(GLint s, GLint t, GLint r)
1795 {
1796 __GLXcontext *const gc = __glXGetCurrentContext();
1797 const GLuint cmdlen = 16;
1798 emit_header(gc->pc, X_GLrop_TexCoord3iv, cmdlen);
1799 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1800 (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
1801 (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 4);
1802 gc->pc += cmdlen;
1803 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1804 (void) __glXFlushRenderBuffer(gc, gc->pc);
1805 }
1806 }
1807
1808 #define X_GLrop_TexCoord3iv 59
1809 void
1810 __indirect_glTexCoord3iv(const GLint * v)
1811 {
1812 generic_12_byte(X_GLrop_TexCoord3iv, v);
1813 }
1814
1815 #define X_GLrop_TexCoord3sv 60
1816 void
1817 __indirect_glTexCoord3s(GLshort s, GLshort t, GLshort r)
1818 {
1819 __GLXcontext *const gc = __glXGetCurrentContext();
1820 const GLuint cmdlen = 12;
1821 emit_header(gc->pc, X_GLrop_TexCoord3sv, cmdlen);
1822 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 2);
1823 (void) memcpy((void *) (gc->pc + 6), (void *) (&t), 2);
1824 (void) memcpy((void *) (gc->pc + 8), (void *) (&r), 2);
1825 gc->pc += cmdlen;
1826 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1827 (void) __glXFlushRenderBuffer(gc, gc->pc);
1828 }
1829 }
1830
1831 #define X_GLrop_TexCoord3sv 60
1832 void
1833 __indirect_glTexCoord3sv(const GLshort * v)
1834 {
1835 generic_6_byte(X_GLrop_TexCoord3sv, v);
1836 }
1837
1838 #define X_GLrop_TexCoord4dv 61
1839 void
1840 __indirect_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
1841 {
1842 __GLXcontext *const gc = __glXGetCurrentContext();
1843 const GLuint cmdlen = 36;
1844 emit_header(gc->pc, X_GLrop_TexCoord4dv, cmdlen);
1845 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
1846 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
1847 (void) memcpy((void *) (gc->pc + 20), (void *) (&r), 8);
1848 (void) memcpy((void *) (gc->pc + 28), (void *) (&q), 8);
1849 gc->pc += cmdlen;
1850 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1851 (void) __glXFlushRenderBuffer(gc, gc->pc);
1852 }
1853 }
1854
1855 #define X_GLrop_TexCoord4dv 61
1856 void
1857 __indirect_glTexCoord4dv(const GLdouble * v)
1858 {
1859 generic_32_byte(X_GLrop_TexCoord4dv, v);
1860 }
1861
1862 #define X_GLrop_TexCoord4fv 62
1863 void
1864 __indirect_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
1865 {
1866 __GLXcontext *const gc = __glXGetCurrentContext();
1867 const GLuint cmdlen = 20;
1868 emit_header(gc->pc, X_GLrop_TexCoord4fv, cmdlen);
1869 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1870 (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
1871 (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 4);
1872 (void) memcpy((void *) (gc->pc + 16), (void *) (&q), 4);
1873 gc->pc += cmdlen;
1874 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1875 (void) __glXFlushRenderBuffer(gc, gc->pc);
1876 }
1877 }
1878
1879 #define X_GLrop_TexCoord4fv 62
1880 void
1881 __indirect_glTexCoord4fv(const GLfloat * v)
1882 {
1883 generic_16_byte(X_GLrop_TexCoord4fv, v);
1884 }
1885
1886 #define X_GLrop_TexCoord4iv 63
1887 void
1888 __indirect_glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
1889 {
1890 __GLXcontext *const gc = __glXGetCurrentContext();
1891 const GLuint cmdlen = 20;
1892 emit_header(gc->pc, X_GLrop_TexCoord4iv, cmdlen);
1893 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
1894 (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
1895 (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 4);
1896 (void) memcpy((void *) (gc->pc + 16), (void *) (&q), 4);
1897 gc->pc += cmdlen;
1898 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1899 (void) __glXFlushRenderBuffer(gc, gc->pc);
1900 }
1901 }
1902
1903 #define X_GLrop_TexCoord4iv 63
1904 void
1905 __indirect_glTexCoord4iv(const GLint * v)
1906 {
1907 generic_16_byte(X_GLrop_TexCoord4iv, v);
1908 }
1909
1910 #define X_GLrop_TexCoord4sv 64
1911 void
1912 __indirect_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
1913 {
1914 __GLXcontext *const gc = __glXGetCurrentContext();
1915 const GLuint cmdlen = 12;
1916 emit_header(gc->pc, X_GLrop_TexCoord4sv, cmdlen);
1917 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 2);
1918 (void) memcpy((void *) (gc->pc + 6), (void *) (&t), 2);
1919 (void) memcpy((void *) (gc->pc + 8), (void *) (&r), 2);
1920 (void) memcpy((void *) (gc->pc + 10), (void *) (&q), 2);
1921 gc->pc += cmdlen;
1922 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1923 (void) __glXFlushRenderBuffer(gc, gc->pc);
1924 }
1925 }
1926
1927 #define X_GLrop_TexCoord4sv 64
1928 void
1929 __indirect_glTexCoord4sv(const GLshort * v)
1930 {
1931 generic_8_byte(X_GLrop_TexCoord4sv, v);
1932 }
1933
1934 #define X_GLrop_Vertex2dv 65
1935 void
1936 __indirect_glVertex2d(GLdouble x, GLdouble y)
1937 {
1938 __GLXcontext *const gc = __glXGetCurrentContext();
1939 const GLuint cmdlen = 20;
1940 emit_header(gc->pc, X_GLrop_Vertex2dv, cmdlen);
1941 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
1942 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
1943 gc->pc += cmdlen;
1944 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1945 (void) __glXFlushRenderBuffer(gc, gc->pc);
1946 }
1947 }
1948
1949 #define X_GLrop_Vertex2dv 65
1950 void
1951 __indirect_glVertex2dv(const GLdouble * v)
1952 {
1953 generic_16_byte(X_GLrop_Vertex2dv, v);
1954 }
1955
1956 #define X_GLrop_Vertex2fv 66
1957 void
1958 __indirect_glVertex2f(GLfloat x, GLfloat y)
1959 {
1960 __GLXcontext *const gc = __glXGetCurrentContext();
1961 const GLuint cmdlen = 12;
1962 emit_header(gc->pc, X_GLrop_Vertex2fv, cmdlen);
1963 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1964 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1965 gc->pc += cmdlen;
1966 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1967 (void) __glXFlushRenderBuffer(gc, gc->pc);
1968 }
1969 }
1970
1971 #define X_GLrop_Vertex2fv 66
1972 void
1973 __indirect_glVertex2fv(const GLfloat * v)
1974 {
1975 generic_8_byte(X_GLrop_Vertex2fv, v);
1976 }
1977
1978 #define X_GLrop_Vertex2iv 67
1979 void
1980 __indirect_glVertex2i(GLint x, GLint y)
1981 {
1982 __GLXcontext *const gc = __glXGetCurrentContext();
1983 const GLuint cmdlen = 12;
1984 emit_header(gc->pc, X_GLrop_Vertex2iv, cmdlen);
1985 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
1986 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
1987 gc->pc += cmdlen;
1988 if (__builtin_expect(gc->pc > gc->limit, 0)) {
1989 (void) __glXFlushRenderBuffer(gc, gc->pc);
1990 }
1991 }
1992
1993 #define X_GLrop_Vertex2iv 67
1994 void
1995 __indirect_glVertex2iv(const GLint * v)
1996 {
1997 generic_8_byte(X_GLrop_Vertex2iv, v);
1998 }
1999
2000 #define X_GLrop_Vertex2sv 68
2001 void
2002 __indirect_glVertex2s(GLshort x, GLshort y)
2003 {
2004 __GLXcontext *const gc = __glXGetCurrentContext();
2005 const GLuint cmdlen = 8;
2006 emit_header(gc->pc, X_GLrop_Vertex2sv, cmdlen);
2007 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
2008 (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
2009 gc->pc += cmdlen;
2010 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2011 (void) __glXFlushRenderBuffer(gc, gc->pc);
2012 }
2013 }
2014
2015 #define X_GLrop_Vertex2sv 68
2016 void
2017 __indirect_glVertex2sv(const GLshort * v)
2018 {
2019 generic_4_byte(X_GLrop_Vertex2sv, v);
2020 }
2021
2022 #define X_GLrop_Vertex3dv 69
2023 void
2024 __indirect_glVertex3d(GLdouble x, GLdouble y, GLdouble z)
2025 {
2026 __GLXcontext *const gc = __glXGetCurrentContext();
2027 const GLuint cmdlen = 28;
2028 emit_header(gc->pc, X_GLrop_Vertex3dv, cmdlen);
2029 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
2030 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
2031 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
2032 gc->pc += cmdlen;
2033 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2034 (void) __glXFlushRenderBuffer(gc, gc->pc);
2035 }
2036 }
2037
2038 #define X_GLrop_Vertex3dv 69
2039 void
2040 __indirect_glVertex3dv(const GLdouble * v)
2041 {
2042 generic_24_byte(X_GLrop_Vertex3dv, v);
2043 }
2044
2045 #define X_GLrop_Vertex3fv 70
2046 void
2047 __indirect_glVertex3f(GLfloat x, GLfloat y, GLfloat z)
2048 {
2049 __GLXcontext *const gc = __glXGetCurrentContext();
2050 const GLuint cmdlen = 16;
2051 emit_header(gc->pc, X_GLrop_Vertex3fv, cmdlen);
2052 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
2053 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
2054 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
2055 gc->pc += cmdlen;
2056 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2057 (void) __glXFlushRenderBuffer(gc, gc->pc);
2058 }
2059 }
2060
2061 #define X_GLrop_Vertex3fv 70
2062 void
2063 __indirect_glVertex3fv(const GLfloat * v)
2064 {
2065 generic_12_byte(X_GLrop_Vertex3fv, v);
2066 }
2067
2068 #define X_GLrop_Vertex3iv 71
2069 void
2070 __indirect_glVertex3i(GLint x, GLint y, GLint z)
2071 {
2072 __GLXcontext *const gc = __glXGetCurrentContext();
2073 const GLuint cmdlen = 16;
2074 emit_header(gc->pc, X_GLrop_Vertex3iv, cmdlen);
2075 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
2076 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
2077 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
2078 gc->pc += cmdlen;
2079 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2080 (void) __glXFlushRenderBuffer(gc, gc->pc);
2081 }
2082 }
2083
2084 #define X_GLrop_Vertex3iv 71
2085 void
2086 __indirect_glVertex3iv(const GLint * v)
2087 {
2088 generic_12_byte(X_GLrop_Vertex3iv, v);
2089 }
2090
2091 #define X_GLrop_Vertex3sv 72
2092 void
2093 __indirect_glVertex3s(GLshort x, GLshort y, GLshort z)
2094 {
2095 __GLXcontext *const gc = __glXGetCurrentContext();
2096 const GLuint cmdlen = 12;
2097 emit_header(gc->pc, X_GLrop_Vertex3sv, cmdlen);
2098 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
2099 (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
2100 (void) memcpy((void *) (gc->pc + 8), (void *) (&z), 2);
2101 gc->pc += cmdlen;
2102 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2103 (void) __glXFlushRenderBuffer(gc, gc->pc);
2104 }
2105 }
2106
2107 #define X_GLrop_Vertex3sv 72
2108 void
2109 __indirect_glVertex3sv(const GLshort * v)
2110 {
2111 generic_6_byte(X_GLrop_Vertex3sv, v);
2112 }
2113
2114 #define X_GLrop_Vertex4dv 73
2115 void
2116 __indirect_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
2117 {
2118 __GLXcontext *const gc = __glXGetCurrentContext();
2119 const GLuint cmdlen = 36;
2120 emit_header(gc->pc, X_GLrop_Vertex4dv, cmdlen);
2121 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
2122 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
2123 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
2124 (void) memcpy((void *) (gc->pc + 28), (void *) (&w), 8);
2125 gc->pc += cmdlen;
2126 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2127 (void) __glXFlushRenderBuffer(gc, gc->pc);
2128 }
2129 }
2130
2131 #define X_GLrop_Vertex4dv 73
2132 void
2133 __indirect_glVertex4dv(const GLdouble * v)
2134 {
2135 generic_32_byte(X_GLrop_Vertex4dv, v);
2136 }
2137
2138 #define X_GLrop_Vertex4fv 74
2139 void
2140 __indirect_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
2141 {
2142 __GLXcontext *const gc = __glXGetCurrentContext();
2143 const GLuint cmdlen = 20;
2144 emit_header(gc->pc, X_GLrop_Vertex4fv, cmdlen);
2145 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
2146 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
2147 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
2148 (void) memcpy((void *) (gc->pc + 16), (void *) (&w), 4);
2149 gc->pc += cmdlen;
2150 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2151 (void) __glXFlushRenderBuffer(gc, gc->pc);
2152 }
2153 }
2154
2155 #define X_GLrop_Vertex4fv 74
2156 void
2157 __indirect_glVertex4fv(const GLfloat * v)
2158 {
2159 generic_16_byte(X_GLrop_Vertex4fv, v);
2160 }
2161
2162 #define X_GLrop_Vertex4iv 75
2163 void
2164 __indirect_glVertex4i(GLint x, GLint y, GLint z, GLint w)
2165 {
2166 __GLXcontext *const gc = __glXGetCurrentContext();
2167 const GLuint cmdlen = 20;
2168 emit_header(gc->pc, X_GLrop_Vertex4iv, cmdlen);
2169 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
2170 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
2171 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
2172 (void) memcpy((void *) (gc->pc + 16), (void *) (&w), 4);
2173 gc->pc += cmdlen;
2174 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2175 (void) __glXFlushRenderBuffer(gc, gc->pc);
2176 }
2177 }
2178
2179 #define X_GLrop_Vertex4iv 75
2180 void
2181 __indirect_glVertex4iv(const GLint * v)
2182 {
2183 generic_16_byte(X_GLrop_Vertex4iv, v);
2184 }
2185
2186 #define X_GLrop_Vertex4sv 76
2187 void
2188 __indirect_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
2189 {
2190 __GLXcontext *const gc = __glXGetCurrentContext();
2191 const GLuint cmdlen = 12;
2192 emit_header(gc->pc, X_GLrop_Vertex4sv, cmdlen);
2193 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
2194 (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
2195 (void) memcpy((void *) (gc->pc + 8), (void *) (&z), 2);
2196 (void) memcpy((void *) (gc->pc + 10), (void *) (&w), 2);
2197 gc->pc += cmdlen;
2198 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2199 (void) __glXFlushRenderBuffer(gc, gc->pc);
2200 }
2201 }
2202
2203 #define X_GLrop_Vertex4sv 76
2204 void
2205 __indirect_glVertex4sv(const GLshort * v)
2206 {
2207 generic_8_byte(X_GLrop_Vertex4sv, v);
2208 }
2209
2210 #define X_GLrop_ClipPlane 77
2211 void
2212 __indirect_glClipPlane(GLenum plane, const GLdouble * equation)
2213 {
2214 __GLXcontext *const gc = __glXGetCurrentContext();
2215 const GLuint cmdlen = 40;
2216 emit_header(gc->pc, X_GLrop_ClipPlane, cmdlen);
2217 (void) memcpy((void *) (gc->pc + 4), (void *) (equation), 32);
2218 (void) memcpy((void *) (gc->pc + 36), (void *) (&plane), 4);
2219 gc->pc += cmdlen;
2220 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2221 (void) __glXFlushRenderBuffer(gc, gc->pc);
2222 }
2223 }
2224
2225 #define X_GLrop_ColorMaterial 78
2226 void
2227 __indirect_glColorMaterial(GLenum face, GLenum mode)
2228 {
2229 __GLXcontext *const gc = __glXGetCurrentContext();
2230 const GLuint cmdlen = 12;
2231 emit_header(gc->pc, X_GLrop_ColorMaterial, cmdlen);
2232 (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
2233 (void) memcpy((void *) (gc->pc + 8), (void *) (&mode), 4);
2234 gc->pc += cmdlen;
2235 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2236 (void) __glXFlushRenderBuffer(gc, gc->pc);
2237 }
2238 }
2239
2240 #define X_GLrop_CullFace 79
2241 void
2242 __indirect_glCullFace(GLenum mode)
2243 {
2244 __GLXcontext *const gc = __glXGetCurrentContext();
2245 const GLuint cmdlen = 8;
2246 emit_header(gc->pc, X_GLrop_CullFace, cmdlen);
2247 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
2248 gc->pc += cmdlen;
2249 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2250 (void) __glXFlushRenderBuffer(gc, gc->pc);
2251 }
2252 }
2253
2254 #define X_GLrop_Fogf 80
2255 void
2256 __indirect_glFogf(GLenum pname, GLfloat param)
2257 {
2258 __GLXcontext *const gc = __glXGetCurrentContext();
2259 const GLuint cmdlen = 12;
2260 emit_header(gc->pc, X_GLrop_Fogf, cmdlen);
2261 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2262 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
2263 gc->pc += cmdlen;
2264 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2265 (void) __glXFlushRenderBuffer(gc, gc->pc);
2266 }
2267 }
2268
2269 #define X_GLrop_Fogfv 81
2270 void
2271 __indirect_glFogfv(GLenum pname, const GLfloat * params)
2272 {
2273 __GLXcontext *const gc = __glXGetCurrentContext();
2274 const GLuint compsize = __glFogfv_size(pname);
2275 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2276 emit_header(gc->pc, X_GLrop_Fogfv, cmdlen);
2277 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2278 (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
2279 gc->pc += cmdlen;
2280 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2281 (void) __glXFlushRenderBuffer(gc, gc->pc);
2282 }
2283 }
2284
2285 #define X_GLrop_Fogi 82
2286 void
2287 __indirect_glFogi(GLenum pname, GLint param)
2288 {
2289 __GLXcontext *const gc = __glXGetCurrentContext();
2290 const GLuint cmdlen = 12;
2291 emit_header(gc->pc, X_GLrop_Fogi, cmdlen);
2292 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2293 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
2294 gc->pc += cmdlen;
2295 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2296 (void) __glXFlushRenderBuffer(gc, gc->pc);
2297 }
2298 }
2299
2300 #define X_GLrop_Fogiv 83
2301 void
2302 __indirect_glFogiv(GLenum pname, const GLint * params)
2303 {
2304 __GLXcontext *const gc = __glXGetCurrentContext();
2305 const GLuint compsize = __glFogiv_size(pname);
2306 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2307 emit_header(gc->pc, X_GLrop_Fogiv, cmdlen);
2308 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2309 (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
2310 gc->pc += cmdlen;
2311 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2312 (void) __glXFlushRenderBuffer(gc, gc->pc);
2313 }
2314 }
2315
2316 #define X_GLrop_FrontFace 84
2317 void
2318 __indirect_glFrontFace(GLenum mode)
2319 {
2320 __GLXcontext *const gc = __glXGetCurrentContext();
2321 const GLuint cmdlen = 8;
2322 emit_header(gc->pc, X_GLrop_FrontFace, cmdlen);
2323 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
2324 gc->pc += cmdlen;
2325 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2326 (void) __glXFlushRenderBuffer(gc, gc->pc);
2327 }
2328 }
2329
2330 #define X_GLrop_Hint 85
2331 void
2332 __indirect_glHint(GLenum target, GLenum mode)
2333 {
2334 __GLXcontext *const gc = __glXGetCurrentContext();
2335 const GLuint cmdlen = 12;
2336 emit_header(gc->pc, X_GLrop_Hint, cmdlen);
2337 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2338 (void) memcpy((void *) (gc->pc + 8), (void *) (&mode), 4);
2339 gc->pc += cmdlen;
2340 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2341 (void) __glXFlushRenderBuffer(gc, gc->pc);
2342 }
2343 }
2344
2345 #define X_GLrop_Lightf 86
2346 void
2347 __indirect_glLightf(GLenum light, GLenum pname, GLfloat param)
2348 {
2349 __GLXcontext *const gc = __glXGetCurrentContext();
2350 const GLuint cmdlen = 16;
2351 emit_header(gc->pc, X_GLrop_Lightf, cmdlen);
2352 (void) memcpy((void *) (gc->pc + 4), (void *) (&light), 4);
2353 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2354 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2355 gc->pc += cmdlen;
2356 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2357 (void) __glXFlushRenderBuffer(gc, gc->pc);
2358 }
2359 }
2360
2361 #define X_GLrop_Lightfv 87
2362 void
2363 __indirect_glLightfv(GLenum light, GLenum pname, const GLfloat * params)
2364 {
2365 __GLXcontext *const gc = __glXGetCurrentContext();
2366 const GLuint compsize = __glLightfv_size(pname);
2367 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2368 emit_header(gc->pc, X_GLrop_Lightfv, cmdlen);
2369 (void) memcpy((void *) (gc->pc + 4), (void *) (&light), 4);
2370 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2371 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2372 gc->pc += cmdlen;
2373 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2374 (void) __glXFlushRenderBuffer(gc, gc->pc);
2375 }
2376 }
2377
2378 #define X_GLrop_Lighti 88
2379 void
2380 __indirect_glLighti(GLenum light, GLenum pname, GLint param)
2381 {
2382 __GLXcontext *const gc = __glXGetCurrentContext();
2383 const GLuint cmdlen = 16;
2384 emit_header(gc->pc, X_GLrop_Lighti, cmdlen);
2385 (void) memcpy((void *) (gc->pc + 4), (void *) (&light), 4);
2386 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2387 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2388 gc->pc += cmdlen;
2389 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2390 (void) __glXFlushRenderBuffer(gc, gc->pc);
2391 }
2392 }
2393
2394 #define X_GLrop_Lightiv 89
2395 void
2396 __indirect_glLightiv(GLenum light, GLenum pname, const GLint * params)
2397 {
2398 __GLXcontext *const gc = __glXGetCurrentContext();
2399 const GLuint compsize = __glLightiv_size(pname);
2400 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2401 emit_header(gc->pc, X_GLrop_Lightiv, cmdlen);
2402 (void) memcpy((void *) (gc->pc + 4), (void *) (&light), 4);
2403 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2404 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2405 gc->pc += cmdlen;
2406 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2407 (void) __glXFlushRenderBuffer(gc, gc->pc);
2408 }
2409 }
2410
2411 #define X_GLrop_LightModelf 90
2412 void
2413 __indirect_glLightModelf(GLenum pname, GLfloat param)
2414 {
2415 __GLXcontext *const gc = __glXGetCurrentContext();
2416 const GLuint cmdlen = 12;
2417 emit_header(gc->pc, X_GLrop_LightModelf, cmdlen);
2418 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2419 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
2420 gc->pc += cmdlen;
2421 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2422 (void) __glXFlushRenderBuffer(gc, gc->pc);
2423 }
2424 }
2425
2426 #define X_GLrop_LightModelfv 91
2427 void
2428 __indirect_glLightModelfv(GLenum pname, const GLfloat * params)
2429 {
2430 __GLXcontext *const gc = __glXGetCurrentContext();
2431 const GLuint compsize = __glLightModelfv_size(pname);
2432 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2433 emit_header(gc->pc, X_GLrop_LightModelfv, cmdlen);
2434 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2435 (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
2436 gc->pc += cmdlen;
2437 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2438 (void) __glXFlushRenderBuffer(gc, gc->pc);
2439 }
2440 }
2441
2442 #define X_GLrop_LightModeli 92
2443 void
2444 __indirect_glLightModeli(GLenum pname, GLint param)
2445 {
2446 __GLXcontext *const gc = __glXGetCurrentContext();
2447 const GLuint cmdlen = 12;
2448 emit_header(gc->pc, X_GLrop_LightModeli, cmdlen);
2449 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2450 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
2451 gc->pc += cmdlen;
2452 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2453 (void) __glXFlushRenderBuffer(gc, gc->pc);
2454 }
2455 }
2456
2457 #define X_GLrop_LightModeliv 93
2458 void
2459 __indirect_glLightModeliv(GLenum pname, const GLint * params)
2460 {
2461 __GLXcontext *const gc = __glXGetCurrentContext();
2462 const GLuint compsize = __glLightModeliv_size(pname);
2463 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2464 emit_header(gc->pc, X_GLrop_LightModeliv, cmdlen);
2465 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
2466 (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
2467 gc->pc += cmdlen;
2468 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2469 (void) __glXFlushRenderBuffer(gc, gc->pc);
2470 }
2471 }
2472
2473 #define X_GLrop_LineStipple 94
2474 void
2475 __indirect_glLineStipple(GLint factor, GLushort pattern)
2476 {
2477 __GLXcontext *const gc = __glXGetCurrentContext();
2478 const GLuint cmdlen = 12;
2479 emit_header(gc->pc, X_GLrop_LineStipple, cmdlen);
2480 (void) memcpy((void *) (gc->pc + 4), (void *) (&factor), 4);
2481 (void) memcpy((void *) (gc->pc + 8), (void *) (&pattern), 2);
2482 gc->pc += cmdlen;
2483 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2484 (void) __glXFlushRenderBuffer(gc, gc->pc);
2485 }
2486 }
2487
2488 #define X_GLrop_LineWidth 95
2489 void
2490 __indirect_glLineWidth(GLfloat width)
2491 {
2492 __GLXcontext *const gc = __glXGetCurrentContext();
2493 const GLuint cmdlen = 8;
2494 emit_header(gc->pc, X_GLrop_LineWidth, cmdlen);
2495 (void) memcpy((void *) (gc->pc + 4), (void *) (&width), 4);
2496 gc->pc += cmdlen;
2497 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2498 (void) __glXFlushRenderBuffer(gc, gc->pc);
2499 }
2500 }
2501
2502 #define X_GLrop_Materialf 96
2503 void
2504 __indirect_glMaterialf(GLenum face, GLenum pname, GLfloat param)
2505 {
2506 __GLXcontext *const gc = __glXGetCurrentContext();
2507 const GLuint cmdlen = 16;
2508 emit_header(gc->pc, X_GLrop_Materialf, cmdlen);
2509 (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
2510 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2511 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2512 gc->pc += cmdlen;
2513 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2514 (void) __glXFlushRenderBuffer(gc, gc->pc);
2515 }
2516 }
2517
2518 #define X_GLrop_Materialfv 97
2519 void
2520 __indirect_glMaterialfv(GLenum face, GLenum pname, const GLfloat * params)
2521 {
2522 __GLXcontext *const gc = __glXGetCurrentContext();
2523 const GLuint compsize = __glMaterialfv_size(pname);
2524 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2525 emit_header(gc->pc, X_GLrop_Materialfv, cmdlen);
2526 (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
2527 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2528 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2529 gc->pc += cmdlen;
2530 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2531 (void) __glXFlushRenderBuffer(gc, gc->pc);
2532 }
2533 }
2534
2535 #define X_GLrop_Materiali 98
2536 void
2537 __indirect_glMateriali(GLenum face, GLenum pname, GLint param)
2538 {
2539 __GLXcontext *const gc = __glXGetCurrentContext();
2540 const GLuint cmdlen = 16;
2541 emit_header(gc->pc, X_GLrop_Materiali, cmdlen);
2542 (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
2543 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2544 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2545 gc->pc += cmdlen;
2546 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2547 (void) __glXFlushRenderBuffer(gc, gc->pc);
2548 }
2549 }
2550
2551 #define X_GLrop_Materialiv 99
2552 void
2553 __indirect_glMaterialiv(GLenum face, GLenum pname, const GLint * params)
2554 {
2555 __GLXcontext *const gc = __glXGetCurrentContext();
2556 const GLuint compsize = __glMaterialiv_size(pname);
2557 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2558 emit_header(gc->pc, X_GLrop_Materialiv, cmdlen);
2559 (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
2560 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2561 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2562 gc->pc += cmdlen;
2563 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2564 (void) __glXFlushRenderBuffer(gc, gc->pc);
2565 }
2566 }
2567
2568 #define X_GLrop_PointSize 100
2569 void
2570 __indirect_glPointSize(GLfloat size)
2571 {
2572 __GLXcontext *const gc = __glXGetCurrentContext();
2573 const GLuint cmdlen = 8;
2574 emit_header(gc->pc, X_GLrop_PointSize, cmdlen);
2575 (void) memcpy((void *) (gc->pc + 4), (void *) (&size), 4);
2576 gc->pc += cmdlen;
2577 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2578 (void) __glXFlushRenderBuffer(gc, gc->pc);
2579 }
2580 }
2581
2582 #define X_GLrop_PolygonMode 101
2583 void
2584 __indirect_glPolygonMode(GLenum face, GLenum mode)
2585 {
2586 __GLXcontext *const gc = __glXGetCurrentContext();
2587 const GLuint cmdlen = 12;
2588 emit_header(gc->pc, X_GLrop_PolygonMode, cmdlen);
2589 (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
2590 (void) memcpy((void *) (gc->pc + 8), (void *) (&mode), 4);
2591 gc->pc += cmdlen;
2592 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2593 (void) __glXFlushRenderBuffer(gc, gc->pc);
2594 }
2595 }
2596
2597 #define X_GLrop_PolygonStipple 102
2598 void
2599 __indirect_glPolygonStipple(const GLubyte *mask)
2600 {
2601 __GLXcontext *const gc = __glXGetCurrentContext();
2602 const GLuint compsize =
2603 (mask != NULL) ? __glImageSize(32, 32, 1, GL_COLOR_INDEX, GL_BITMAP,
2604 0) : 0;
2605 const GLuint cmdlen = 24 + __GLX_PAD(compsize);
2606 emit_header(gc->pc, X_GLrop_PolygonStipple, cmdlen);
2607 if (compsize > 0) {
2608 (*gc->fillImage) (gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, mask,
2609 gc->pc + 24, gc->pc + 4);
2610 } else {
2611 (void) memcpy(gc->pc + 4, default_pixel_store_2D,
2612 default_pixel_store_2D_size);
2613 }
2614 gc->pc += cmdlen;
2615 if (gc->pc > gc->limit) {
2616 (void) __glXFlushRenderBuffer(gc, gc->pc);
2617 }
2618 }
2619
2620 #define X_GLrop_Scissor 103
2621 void
2622 __indirect_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
2623 {
2624 __GLXcontext *const gc = __glXGetCurrentContext();
2625 const GLuint cmdlen = 20;
2626 emit_header(gc->pc, X_GLrop_Scissor, cmdlen);
2627 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
2628 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
2629 (void) memcpy((void *) (gc->pc + 12), (void *) (&width), 4);
2630 (void) memcpy((void *) (gc->pc + 16), (void *) (&height), 4);
2631 gc->pc += cmdlen;
2632 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2633 (void) __glXFlushRenderBuffer(gc, gc->pc);
2634 }
2635 }
2636
2637 #define X_GLrop_ShadeModel 104
2638 void
2639 __indirect_glShadeModel(GLenum mode)
2640 {
2641 __GLXcontext *const gc = __glXGetCurrentContext();
2642 const GLuint cmdlen = 8;
2643 emit_header(gc->pc, X_GLrop_ShadeModel, cmdlen);
2644 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
2645 gc->pc += cmdlen;
2646 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2647 (void) __glXFlushRenderBuffer(gc, gc->pc);
2648 }
2649 }
2650
2651 #define X_GLrop_TexParameterf 105
2652 void
2653 __indirect_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
2654 {
2655 __GLXcontext *const gc = __glXGetCurrentContext();
2656 const GLuint cmdlen = 16;
2657 emit_header(gc->pc, X_GLrop_TexParameterf, cmdlen);
2658 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2659 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2660 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2661 gc->pc += cmdlen;
2662 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2663 (void) __glXFlushRenderBuffer(gc, gc->pc);
2664 }
2665 }
2666
2667 #define X_GLrop_TexParameterfv 106
2668 void
2669 __indirect_glTexParameterfv(GLenum target, GLenum pname,
2670 const GLfloat * params)
2671 {
2672 __GLXcontext *const gc = __glXGetCurrentContext();
2673 const GLuint compsize = __glTexParameterfv_size(pname);
2674 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2675 emit_header(gc->pc, X_GLrop_TexParameterfv, cmdlen);
2676 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2677 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2678 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2679 gc->pc += cmdlen;
2680 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2681 (void) __glXFlushRenderBuffer(gc, gc->pc);
2682 }
2683 }
2684
2685 #define X_GLrop_TexParameteri 107
2686 void
2687 __indirect_glTexParameteri(GLenum target, GLenum pname, GLint param)
2688 {
2689 __GLXcontext *const gc = __glXGetCurrentContext();
2690 const GLuint cmdlen = 16;
2691 emit_header(gc->pc, X_GLrop_TexParameteri, cmdlen);
2692 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2693 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2694 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2695 gc->pc += cmdlen;
2696 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2697 (void) __glXFlushRenderBuffer(gc, gc->pc);
2698 }
2699 }
2700
2701 #define X_GLrop_TexParameteriv 108
2702 void
2703 __indirect_glTexParameteriv(GLenum target, GLenum pname, const GLint * params)
2704 {
2705 __GLXcontext *const gc = __glXGetCurrentContext();
2706 const GLuint compsize = __glTexParameteriv_size(pname);
2707 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2708 emit_header(gc->pc, X_GLrop_TexParameteriv, cmdlen);
2709 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2710 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2711 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2712 gc->pc += cmdlen;
2713 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2714 (void) __glXFlushRenderBuffer(gc, gc->pc);
2715 }
2716 }
2717
2718 static void
2719 __glx_TexImage_1D2D(unsigned opcode, unsigned dim, GLenum target, GLint level,
2720 GLint internalformat, GLsizei width, GLsizei height,
2721 GLint border, GLenum format, GLenum type,
2722 const GLvoid * pixels)
2723 {
2724 __GLXcontext *const gc = __glXGetCurrentContext();
2725 const GLuint compsize =
2726 __glImageSize(width, height, 1, format, type, target);
2727 const GLuint cmdlen = 56 + __GLX_PAD(compsize);
2728 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
2729 if (cmdlen <= gc->maxSmallRenderCommandSize) {
2730 if ((gc->pc + cmdlen) > gc->bufEnd) {
2731 (void) __glXFlushRenderBuffer(gc, gc->pc);
2732 }
2733 emit_header(gc->pc, opcode, cmdlen);
2734 (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4);
2735 (void) memcpy((void *) (gc->pc + 28), (void *) (&level), 4);
2736 (void) memcpy((void *) (gc->pc + 32), (void *) (&internalformat),
2737 4);
2738 (void) memcpy((void *) (gc->pc + 36), (void *) (&width), 4);
2739 (void) memcpy((void *) (gc->pc + 40), (void *) (&height), 4);
2740 (void) memcpy((void *) (gc->pc + 44), (void *) (&border), 4);
2741 (void) memcpy((void *) (gc->pc + 48), (void *) (&format), 4);
2742 (void) memcpy((void *) (gc->pc + 52), (void *) (&type), 4);
2743 if ((compsize > 0) && (pixels != NULL)) {
2744 (*gc->fillImage) (gc, dim, width, height, 1, format, type,
2745 pixels, gc->pc + 56, gc->pc + 4);
2746 } else {
2747 (void) memcpy(gc->pc + 4, default_pixel_store_2D,
2748 default_pixel_store_2D_size);
2749 }
2750 gc->pc += cmdlen;
2751 if (gc->pc > gc->limit) {
2752 (void) __glXFlushRenderBuffer(gc, gc->pc);
2753 }
2754 } else {
2755 const GLint op = opcode;
2756 const GLuint cmdlenLarge = cmdlen + 4;
2757 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
2758 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
2759 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
2760 (void) memcpy((void *) (pc + 28), (void *) (&target), 4);
2761 (void) memcpy((void *) (pc + 32), (void *) (&level), 4);
2762 (void) memcpy((void *) (pc + 36), (void *) (&internalformat), 4);
2763 (void) memcpy((void *) (pc + 40), (void *) (&width), 4);
2764 (void) memcpy((void *) (pc + 44), (void *) (&height), 4);
2765 (void) memcpy((void *) (pc + 48), (void *) (&border), 4);
2766 (void) memcpy((void *) (pc + 52), (void *) (&format), 4);
2767 (void) memcpy((void *) (pc + 56), (void *) (&type), 4);
2768 __glXSendLargeImage(gc, compsize, dim, width, height, 1, format,
2769 type, pixels, pc + 60, pc + 8);
2770 }
2771 }
2772 }
2773
2774 #define X_GLrop_TexImage1D 109
2775 void
2776 __indirect_glTexImage1D(GLenum target, GLint level, GLint internalformat,
2777 GLsizei width, GLint border, GLenum format,
2778 GLenum type, const GLvoid * pixels)
2779 {
2780 __glx_TexImage_1D2D(X_GLrop_TexImage1D, 1, target, level, internalformat,
2781 width, 1, border, format, type, pixels);
2782 }
2783
2784 #define X_GLrop_TexImage2D 110
2785 void
2786 __indirect_glTexImage2D(GLenum target, GLint level, GLint internalformat,
2787 GLsizei width, GLsizei height, GLint border,
2788 GLenum format, GLenum type, const GLvoid * pixels)
2789 {
2790 __glx_TexImage_1D2D(X_GLrop_TexImage2D, 2, target, level, internalformat,
2791 width, height, border, format, type, pixels);
2792 }
2793
2794 #define X_GLrop_TexEnvf 111
2795 void
2796 __indirect_glTexEnvf(GLenum target, GLenum pname, GLfloat param)
2797 {
2798 __GLXcontext *const gc = __glXGetCurrentContext();
2799 const GLuint cmdlen = 16;
2800 emit_header(gc->pc, X_GLrop_TexEnvf, cmdlen);
2801 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2802 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2803 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2804 gc->pc += cmdlen;
2805 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2806 (void) __glXFlushRenderBuffer(gc, gc->pc);
2807 }
2808 }
2809
2810 #define X_GLrop_TexEnvfv 112
2811 void
2812 __indirect_glTexEnvfv(GLenum target, GLenum pname, const GLfloat * params)
2813 {
2814 __GLXcontext *const gc = __glXGetCurrentContext();
2815 const GLuint compsize = __glTexEnvfv_size(pname);
2816 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2817 emit_header(gc->pc, X_GLrop_TexEnvfv, cmdlen);
2818 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2819 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2820 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2821 gc->pc += cmdlen;
2822 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2823 (void) __glXFlushRenderBuffer(gc, gc->pc);
2824 }
2825 }
2826
2827 #define X_GLrop_TexEnvi 113
2828 void
2829 __indirect_glTexEnvi(GLenum target, GLenum pname, GLint param)
2830 {
2831 __GLXcontext *const gc = __glXGetCurrentContext();
2832 const GLuint cmdlen = 16;
2833 emit_header(gc->pc, X_GLrop_TexEnvi, cmdlen);
2834 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2835 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2836 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2837 gc->pc += cmdlen;
2838 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2839 (void) __glXFlushRenderBuffer(gc, gc->pc);
2840 }
2841 }
2842
2843 #define X_GLrop_TexEnviv 114
2844 void
2845 __indirect_glTexEnviv(GLenum target, GLenum pname, const GLint * params)
2846 {
2847 __GLXcontext *const gc = __glXGetCurrentContext();
2848 const GLuint compsize = __glTexEnviv_size(pname);
2849 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2850 emit_header(gc->pc, X_GLrop_TexEnviv, cmdlen);
2851 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
2852 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2853 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2854 gc->pc += cmdlen;
2855 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2856 (void) __glXFlushRenderBuffer(gc, gc->pc);
2857 }
2858 }
2859
2860 #define X_GLrop_TexGend 115
2861 void
2862 __indirect_glTexGend(GLenum coord, GLenum pname, GLdouble param)
2863 {
2864 __GLXcontext *const gc = __glXGetCurrentContext();
2865 const GLuint cmdlen = 20;
2866 emit_header(gc->pc, X_GLrop_TexGend, cmdlen);
2867 (void) memcpy((void *) (gc->pc + 4), (void *) (&param), 8);
2868 (void) memcpy((void *) (gc->pc + 12), (void *) (&coord), 4);
2869 (void) memcpy((void *) (gc->pc + 16), (void *) (&pname), 4);
2870 gc->pc += cmdlen;
2871 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2872 (void) __glXFlushRenderBuffer(gc, gc->pc);
2873 }
2874 }
2875
2876 #define X_GLrop_TexGendv 116
2877 void
2878 __indirect_glTexGendv(GLenum coord, GLenum pname, const GLdouble * params)
2879 {
2880 __GLXcontext *const gc = __glXGetCurrentContext();
2881 const GLuint compsize = __glTexGendv_size(pname);
2882 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8));
2883 emit_header(gc->pc, X_GLrop_TexGendv, cmdlen);
2884 (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
2885 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2886 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 8));
2887 gc->pc += cmdlen;
2888 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2889 (void) __glXFlushRenderBuffer(gc, gc->pc);
2890 }
2891 }
2892
2893 #define X_GLrop_TexGenf 117
2894 void
2895 __indirect_glTexGenf(GLenum coord, GLenum pname, GLfloat param)
2896 {
2897 __GLXcontext *const gc = __glXGetCurrentContext();
2898 const GLuint cmdlen = 16;
2899 emit_header(gc->pc, X_GLrop_TexGenf, cmdlen);
2900 (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
2901 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2902 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2903 gc->pc += cmdlen;
2904 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2905 (void) __glXFlushRenderBuffer(gc, gc->pc);
2906 }
2907 }
2908
2909 #define X_GLrop_TexGenfv 118
2910 void
2911 __indirect_glTexGenfv(GLenum coord, GLenum pname, const GLfloat * params)
2912 {
2913 __GLXcontext *const gc = __glXGetCurrentContext();
2914 const GLuint compsize = __glTexGenfv_size(pname);
2915 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2916 emit_header(gc->pc, X_GLrop_TexGenfv, cmdlen);
2917 (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
2918 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2919 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2920 gc->pc += cmdlen;
2921 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2922 (void) __glXFlushRenderBuffer(gc, gc->pc);
2923 }
2924 }
2925
2926 #define X_GLrop_TexGeni 119
2927 void
2928 __indirect_glTexGeni(GLenum coord, GLenum pname, GLint param)
2929 {
2930 __GLXcontext *const gc = __glXGetCurrentContext();
2931 const GLuint cmdlen = 16;
2932 emit_header(gc->pc, X_GLrop_TexGeni, cmdlen);
2933 (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
2934 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2935 (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
2936 gc->pc += cmdlen;
2937 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2938 (void) __glXFlushRenderBuffer(gc, gc->pc);
2939 }
2940 }
2941
2942 #define X_GLrop_TexGeniv 120
2943 void
2944 __indirect_glTexGeniv(GLenum coord, GLenum pname, const GLint * params)
2945 {
2946 __GLXcontext *const gc = __glXGetCurrentContext();
2947 const GLuint compsize = __glTexGeniv_size(pname);
2948 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2949 emit_header(gc->pc, X_GLrop_TexGeniv, cmdlen);
2950 (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
2951 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
2952 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
2953 gc->pc += cmdlen;
2954 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2955 (void) __glXFlushRenderBuffer(gc, gc->pc);
2956 }
2957 }
2958
2959 #define X_GLrop_InitNames 121
2960 void
2961 __indirect_glInitNames(void)
2962 {
2963 __GLXcontext *const gc = __glXGetCurrentContext();
2964 const GLuint cmdlen = 4;
2965 emit_header(gc->pc, X_GLrop_InitNames, cmdlen);
2966 gc->pc += cmdlen;
2967 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2968 (void) __glXFlushRenderBuffer(gc, gc->pc);
2969 }
2970 }
2971
2972 #define X_GLrop_LoadName 122
2973 void
2974 __indirect_glLoadName(GLuint name)
2975 {
2976 __GLXcontext *const gc = __glXGetCurrentContext();
2977 const GLuint cmdlen = 8;
2978 emit_header(gc->pc, X_GLrop_LoadName, cmdlen);
2979 (void) memcpy((void *) (gc->pc + 4), (void *) (&name), 4);
2980 gc->pc += cmdlen;
2981 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2982 (void) __glXFlushRenderBuffer(gc, gc->pc);
2983 }
2984 }
2985
2986 #define X_GLrop_PassThrough 123
2987 void
2988 __indirect_glPassThrough(GLfloat token)
2989 {
2990 __GLXcontext *const gc = __glXGetCurrentContext();
2991 const GLuint cmdlen = 8;
2992 emit_header(gc->pc, X_GLrop_PassThrough, cmdlen);
2993 (void) memcpy((void *) (gc->pc + 4), (void *) (&token), 4);
2994 gc->pc += cmdlen;
2995 if (__builtin_expect(gc->pc > gc->limit, 0)) {
2996 (void) __glXFlushRenderBuffer(gc, gc->pc);
2997 }
2998 }
2999
3000 #define X_GLrop_PopName 124
3001 void
3002 __indirect_glPopName(void)
3003 {
3004 __GLXcontext *const gc = __glXGetCurrentContext();
3005 const GLuint cmdlen = 4;
3006 emit_header(gc->pc, X_GLrop_PopName, cmdlen);
3007 gc->pc += cmdlen;
3008 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3009 (void) __glXFlushRenderBuffer(gc, gc->pc);
3010 }
3011 }
3012
3013 #define X_GLrop_PushName 125
3014 void
3015 __indirect_glPushName(GLuint name)
3016 {
3017 __GLXcontext *const gc = __glXGetCurrentContext();
3018 const GLuint cmdlen = 8;
3019 emit_header(gc->pc, X_GLrop_PushName, cmdlen);
3020 (void) memcpy((void *) (gc->pc + 4), (void *) (&name), 4);
3021 gc->pc += cmdlen;
3022 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3023 (void) __glXFlushRenderBuffer(gc, gc->pc);
3024 }
3025 }
3026
3027 #define X_GLrop_DrawBuffer 126
3028 void
3029 __indirect_glDrawBuffer(GLenum mode)
3030 {
3031 __GLXcontext *const gc = __glXGetCurrentContext();
3032 const GLuint cmdlen = 8;
3033 emit_header(gc->pc, X_GLrop_DrawBuffer, cmdlen);
3034 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
3035 gc->pc += cmdlen;
3036 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3037 (void) __glXFlushRenderBuffer(gc, gc->pc);
3038 }
3039 }
3040
3041 #define X_GLrop_Clear 127
3042 void
3043 __indirect_glClear(GLbitfield mask)
3044 {
3045 __GLXcontext *const gc = __glXGetCurrentContext();
3046 const GLuint cmdlen = 8;
3047 emit_header(gc->pc, X_GLrop_Clear, cmdlen);
3048 (void) memcpy((void *) (gc->pc + 4), (void *) (&mask), 4);
3049 gc->pc += cmdlen;
3050 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3051 (void) __glXFlushRenderBuffer(gc, gc->pc);
3052 }
3053 }
3054
3055 #define X_GLrop_ClearAccum 128
3056 void
3057 __indirect_glClearAccum(GLfloat red, GLfloat green, GLfloat blue,
3058 GLfloat alpha)
3059 {
3060 __GLXcontext *const gc = __glXGetCurrentContext();
3061 const GLuint cmdlen = 20;
3062 emit_header(gc->pc, X_GLrop_ClearAccum, cmdlen);
3063 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
3064 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
3065 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
3066 (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
3067 gc->pc += cmdlen;
3068 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3069 (void) __glXFlushRenderBuffer(gc, gc->pc);
3070 }
3071 }
3072
3073 #define X_GLrop_ClearIndex 129
3074 void
3075 __indirect_glClearIndex(GLfloat c)
3076 {
3077 __GLXcontext *const gc = __glXGetCurrentContext();
3078 const GLuint cmdlen = 8;
3079 emit_header(gc->pc, X_GLrop_ClearIndex, cmdlen);
3080 (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 4);
3081 gc->pc += cmdlen;
3082 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3083 (void) __glXFlushRenderBuffer(gc, gc->pc);
3084 }
3085 }
3086
3087 #define X_GLrop_ClearColor 130
3088 void
3089 __indirect_glClearColor(GLclampf red, GLclampf green, GLclampf blue,
3090 GLclampf alpha)
3091 {
3092 __GLXcontext *const gc = __glXGetCurrentContext();
3093 const GLuint cmdlen = 20;
3094 emit_header(gc->pc, X_GLrop_ClearColor, cmdlen);
3095 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
3096 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
3097 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
3098 (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
3099 gc->pc += cmdlen;
3100 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3101 (void) __glXFlushRenderBuffer(gc, gc->pc);
3102 }
3103 }
3104
3105 #define X_GLrop_ClearStencil 131
3106 void
3107 __indirect_glClearStencil(GLint s)
3108 {
3109 __GLXcontext *const gc = __glXGetCurrentContext();
3110 const GLuint cmdlen = 8;
3111 emit_header(gc->pc, X_GLrop_ClearStencil, cmdlen);
3112 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
3113 gc->pc += cmdlen;
3114 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3115 (void) __glXFlushRenderBuffer(gc, gc->pc);
3116 }
3117 }
3118
3119 #define X_GLrop_ClearDepth 132
3120 void
3121 __indirect_glClearDepth(GLclampd depth)
3122 {
3123 __GLXcontext *const gc = __glXGetCurrentContext();
3124 const GLuint cmdlen = 12;
3125 emit_header(gc->pc, X_GLrop_ClearDepth, cmdlen);
3126 (void) memcpy((void *) (gc->pc + 4), (void *) (&depth), 8);
3127 gc->pc += cmdlen;
3128 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3129 (void) __glXFlushRenderBuffer(gc, gc->pc);
3130 }
3131 }
3132
3133 #define X_GLrop_StencilMask 133
3134 void
3135 __indirect_glStencilMask(GLuint mask)
3136 {
3137 __GLXcontext *const gc = __glXGetCurrentContext();
3138 const GLuint cmdlen = 8;
3139 emit_header(gc->pc, X_GLrop_StencilMask, cmdlen);
3140 (void) memcpy((void *) (gc->pc + 4), (void *) (&mask), 4);
3141 gc->pc += cmdlen;
3142 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3143 (void) __glXFlushRenderBuffer(gc, gc->pc);
3144 }
3145 }
3146
3147 #define X_GLrop_ColorMask 134
3148 void
3149 __indirect_glColorMask(GLboolean red, GLboolean green, GLboolean blue,
3150 GLboolean alpha)
3151 {
3152 __GLXcontext *const gc = __glXGetCurrentContext();
3153 const GLuint cmdlen = 8;
3154 emit_header(gc->pc, X_GLrop_ColorMask, cmdlen);
3155 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
3156 (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
3157 (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
3158 (void) memcpy((void *) (gc->pc + 7), (void *) (&alpha), 1);
3159 gc->pc += cmdlen;
3160 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3161 (void) __glXFlushRenderBuffer(gc, gc->pc);
3162 }
3163 }
3164
3165 #define X_GLrop_DepthMask 135
3166 void
3167 __indirect_glDepthMask(GLboolean flag)
3168 {
3169 __GLXcontext *const gc = __glXGetCurrentContext();
3170 const GLuint cmdlen = 8;
3171 emit_header(gc->pc, X_GLrop_DepthMask, cmdlen);
3172 (void) memcpy((void *) (gc->pc + 4), (void *) (&flag), 1);
3173 gc->pc += cmdlen;
3174 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3175 (void) __glXFlushRenderBuffer(gc, gc->pc);
3176 }
3177 }
3178
3179 #define X_GLrop_IndexMask 136
3180 void
3181 __indirect_glIndexMask(GLuint mask)
3182 {
3183 __GLXcontext *const gc = __glXGetCurrentContext();
3184 const GLuint cmdlen = 8;
3185 emit_header(gc->pc, X_GLrop_IndexMask, cmdlen);
3186 (void) memcpy((void *) (gc->pc + 4), (void *) (&mask), 4);
3187 gc->pc += cmdlen;
3188 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3189 (void) __glXFlushRenderBuffer(gc, gc->pc);
3190 }
3191 }
3192
3193 #define X_GLrop_Accum 137
3194 void
3195 __indirect_glAccum(GLenum op, GLfloat value)
3196 {
3197 __GLXcontext *const gc = __glXGetCurrentContext();
3198 const GLuint cmdlen = 12;
3199 emit_header(gc->pc, X_GLrop_Accum, cmdlen);
3200 (void) memcpy((void *) (gc->pc + 4), (void *) (&op), 4);
3201 (void) memcpy((void *) (gc->pc + 8), (void *) (&value), 4);
3202 gc->pc += cmdlen;
3203 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3204 (void) __glXFlushRenderBuffer(gc, gc->pc);
3205 }
3206 }
3207
3208 #define X_GLrop_PopAttrib 141
3209 void
3210 __indirect_glPopAttrib(void)
3211 {
3212 __GLXcontext *const gc = __glXGetCurrentContext();
3213 const GLuint cmdlen = 4;
3214 emit_header(gc->pc, X_GLrop_PopAttrib, cmdlen);
3215 gc->pc += cmdlen;
3216 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3217 (void) __glXFlushRenderBuffer(gc, gc->pc);
3218 }
3219 }
3220
3221 #define X_GLrop_PushAttrib 142
3222 void
3223 __indirect_glPushAttrib(GLbitfield mask)
3224 {
3225 __GLXcontext *const gc = __glXGetCurrentContext();
3226 const GLuint cmdlen = 8;
3227 emit_header(gc->pc, X_GLrop_PushAttrib, cmdlen);
3228 (void) memcpy((void *) (gc->pc + 4), (void *) (&mask), 4);
3229 gc->pc += cmdlen;
3230 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3231 (void) __glXFlushRenderBuffer(gc, gc->pc);
3232 }
3233 }
3234
3235 #define X_GLrop_MapGrid1d 147
3236 void
3237 __indirect_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
3238 {
3239 __GLXcontext *const gc = __glXGetCurrentContext();
3240 const GLuint cmdlen = 24;
3241 emit_header(gc->pc, X_GLrop_MapGrid1d, cmdlen);
3242 (void) memcpy((void *) (gc->pc + 4), (void *) (&u1), 8);
3243 (void) memcpy((void *) (gc->pc + 12), (void *) (&u2), 8);
3244 (void) memcpy((void *) (gc->pc + 20), (void *) (&un), 4);
3245 gc->pc += cmdlen;
3246 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3247 (void) __glXFlushRenderBuffer(gc, gc->pc);
3248 }
3249 }
3250
3251 #define X_GLrop_MapGrid1f 148
3252 void
3253 __indirect_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
3254 {
3255 __GLXcontext *const gc = __glXGetCurrentContext();
3256 const GLuint cmdlen = 16;
3257 emit_header(gc->pc, X_GLrop_MapGrid1f, cmdlen);
3258 (void) memcpy((void *) (gc->pc + 4), (void *) (&un), 4);
3259 (void) memcpy((void *) (gc->pc + 8), (void *) (&u1), 4);
3260 (void) memcpy((void *) (gc->pc + 12), (void *) (&u2), 4);
3261 gc->pc += cmdlen;
3262 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3263 (void) __glXFlushRenderBuffer(gc, gc->pc);
3264 }
3265 }
3266
3267 #define X_GLrop_MapGrid2d 149
3268 void
3269 __indirect_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn,
3270 GLdouble v1, GLdouble v2)
3271 {
3272 __GLXcontext *const gc = __glXGetCurrentContext();
3273 const GLuint cmdlen = 44;
3274 emit_header(gc->pc, X_GLrop_MapGrid2d, cmdlen);
3275 (void) memcpy((void *) (gc->pc + 4), (void *) (&u1), 8);
3276 (void) memcpy((void *) (gc->pc + 12), (void *) (&u2), 8);
3277 (void) memcpy((void *) (gc->pc + 20), (void *) (&v1), 8);
3278 (void) memcpy((void *) (gc->pc + 28), (void *) (&v2), 8);
3279 (void) memcpy((void *) (gc->pc + 36), (void *) (&un), 4);
3280 (void) memcpy((void *) (gc->pc + 40), (void *) (&vn), 4);
3281 gc->pc += cmdlen;
3282 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3283 (void) __glXFlushRenderBuffer(gc, gc->pc);
3284 }
3285 }
3286
3287 #define X_GLrop_MapGrid2f 150
3288 void
3289 __indirect_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1,
3290 GLfloat v2)
3291 {
3292 __GLXcontext *const gc = __glXGetCurrentContext();
3293 const GLuint cmdlen = 28;
3294 emit_header(gc->pc, X_GLrop_MapGrid2f, cmdlen);
3295 (void) memcpy((void *) (gc->pc + 4), (void *) (&un), 4);
3296 (void) memcpy((void *) (gc->pc + 8), (void *) (&u1), 4);
3297 (void) memcpy((void *) (gc->pc + 12), (void *) (&u2), 4);
3298 (void) memcpy((void *) (gc->pc + 16), (void *) (&vn), 4);
3299 (void) memcpy((void *) (gc->pc + 20), (void *) (&v1), 4);
3300 (void) memcpy((void *) (gc->pc + 24), (void *) (&v2), 4);
3301 gc->pc += cmdlen;
3302 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3303 (void) __glXFlushRenderBuffer(gc, gc->pc);
3304 }
3305 }
3306
3307 #define X_GLrop_EvalCoord1dv 151
3308 void
3309 __indirect_glEvalCoord1d(GLdouble u)
3310 {
3311 __GLXcontext *const gc = __glXGetCurrentContext();
3312 const GLuint cmdlen = 12;
3313 emit_header(gc->pc, X_GLrop_EvalCoord1dv, cmdlen);
3314 (void) memcpy((void *) (gc->pc + 4), (void *) (&u), 8);
3315 gc->pc += cmdlen;
3316 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3317 (void) __glXFlushRenderBuffer(gc, gc->pc);
3318 }
3319 }
3320
3321 #define X_GLrop_EvalCoord1dv 151
3322 void
3323 __indirect_glEvalCoord1dv(const GLdouble * u)
3324 {
3325 generic_8_byte(X_GLrop_EvalCoord1dv, u);
3326 }
3327
3328 #define X_GLrop_EvalCoord1fv 152
3329 void
3330 __indirect_glEvalCoord1f(GLfloat u)
3331 {
3332 __GLXcontext *const gc = __glXGetCurrentContext();
3333 const GLuint cmdlen = 8;
3334 emit_header(gc->pc, X_GLrop_EvalCoord1fv, cmdlen);
3335 (void) memcpy((void *) (gc->pc + 4), (void *) (&u), 4);
3336 gc->pc += cmdlen;
3337 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3338 (void) __glXFlushRenderBuffer(gc, gc->pc);
3339 }
3340 }
3341
3342 #define X_GLrop_EvalCoord1fv 152
3343 void
3344 __indirect_glEvalCoord1fv(const GLfloat * u)
3345 {
3346 generic_4_byte(X_GLrop_EvalCoord1fv, u);
3347 }
3348
3349 #define X_GLrop_EvalCoord2dv 153
3350 void
3351 __indirect_glEvalCoord2d(GLdouble u, GLdouble v)
3352 {
3353 __GLXcontext *const gc = __glXGetCurrentContext();
3354 const GLuint cmdlen = 20;
3355 emit_header(gc->pc, X_GLrop_EvalCoord2dv, cmdlen);
3356 (void) memcpy((void *) (gc->pc + 4), (void *) (&u), 8);
3357 (void) memcpy((void *) (gc->pc + 12), (void *) (&v), 8);
3358 gc->pc += cmdlen;
3359 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3360 (void) __glXFlushRenderBuffer(gc, gc->pc);
3361 }
3362 }
3363
3364 #define X_GLrop_EvalCoord2dv 153
3365 void
3366 __indirect_glEvalCoord2dv(const GLdouble * u)
3367 {
3368 generic_16_byte(X_GLrop_EvalCoord2dv, u);
3369 }
3370
3371 #define X_GLrop_EvalCoord2fv 154
3372 void
3373 __indirect_glEvalCoord2f(GLfloat u, GLfloat v)
3374 {
3375 __GLXcontext *const gc = __glXGetCurrentContext();
3376 const GLuint cmdlen = 12;
3377 emit_header(gc->pc, X_GLrop_EvalCoord2fv, cmdlen);
3378 (void) memcpy((void *) (gc->pc + 4), (void *) (&u), 4);
3379 (void) memcpy((void *) (gc->pc + 8), (void *) (&v), 4);
3380 gc->pc += cmdlen;
3381 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3382 (void) __glXFlushRenderBuffer(gc, gc->pc);
3383 }
3384 }
3385
3386 #define X_GLrop_EvalCoord2fv 154
3387 void
3388 __indirect_glEvalCoord2fv(const GLfloat * u)
3389 {
3390 generic_8_byte(X_GLrop_EvalCoord2fv, u);
3391 }
3392
3393 #define X_GLrop_EvalMesh1 155
3394 void
3395 __indirect_glEvalMesh1(GLenum mode, GLint i1, GLint i2)
3396 {
3397 __GLXcontext *const gc = __glXGetCurrentContext();
3398 const GLuint cmdlen = 16;
3399 emit_header(gc->pc, X_GLrop_EvalMesh1, cmdlen);
3400 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
3401 (void) memcpy((void *) (gc->pc + 8), (void *) (&i1), 4);
3402 (void) memcpy((void *) (gc->pc + 12), (void *) (&i2), 4);
3403 gc->pc += cmdlen;
3404 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3405 (void) __glXFlushRenderBuffer(gc, gc->pc);
3406 }
3407 }
3408
3409 #define X_GLrop_EvalPoint1 156
3410 void
3411 __indirect_glEvalPoint1(GLint i)
3412 {
3413 __GLXcontext *const gc = __glXGetCurrentContext();
3414 const GLuint cmdlen = 8;
3415 emit_header(gc->pc, X_GLrop_EvalPoint1, cmdlen);
3416 (void) memcpy((void *) (gc->pc + 4), (void *) (&i), 4);
3417 gc->pc += cmdlen;
3418 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3419 (void) __glXFlushRenderBuffer(gc, gc->pc);
3420 }
3421 }
3422
3423 #define X_GLrop_EvalMesh2 157
3424 void
3425 __indirect_glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
3426 {
3427 __GLXcontext *const gc = __glXGetCurrentContext();
3428 const GLuint cmdlen = 24;
3429 emit_header(gc->pc, X_GLrop_EvalMesh2, cmdlen);
3430 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
3431 (void) memcpy((void *) (gc->pc + 8), (void *) (&i1), 4);
3432 (void) memcpy((void *) (gc->pc + 12), (void *) (&i2), 4);
3433 (void) memcpy((void *) (gc->pc + 16), (void *) (&j1), 4);
3434 (void) memcpy((void *) (gc->pc + 20), (void *) (&j2), 4);
3435 gc->pc += cmdlen;
3436 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3437 (void) __glXFlushRenderBuffer(gc, gc->pc);
3438 }
3439 }
3440
3441 #define X_GLrop_EvalPoint2 158
3442 void
3443 __indirect_glEvalPoint2(GLint i, GLint j)
3444 {
3445 __GLXcontext *const gc = __glXGetCurrentContext();
3446 const GLuint cmdlen = 12;
3447 emit_header(gc->pc, X_GLrop_EvalPoint2, cmdlen);
3448 (void) memcpy((void *) (gc->pc + 4), (void *) (&i), 4);
3449 (void) memcpy((void *) (gc->pc + 8), (void *) (&j), 4);
3450 gc->pc += cmdlen;
3451 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3452 (void) __glXFlushRenderBuffer(gc, gc->pc);
3453 }
3454 }
3455
3456 #define X_GLrop_AlphaFunc 159
3457 void
3458 __indirect_glAlphaFunc(GLenum func, GLclampf ref)
3459 {
3460 __GLXcontext *const gc = __glXGetCurrentContext();
3461 const GLuint cmdlen = 12;
3462 emit_header(gc->pc, X_GLrop_AlphaFunc, cmdlen);
3463 (void) memcpy((void *) (gc->pc + 4), (void *) (&func), 4);
3464 (void) memcpy((void *) (gc->pc + 8), (void *) (&ref), 4);
3465 gc->pc += cmdlen;
3466 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3467 (void) __glXFlushRenderBuffer(gc, gc->pc);
3468 }
3469 }
3470
3471 #define X_GLrop_BlendFunc 160
3472 void
3473 __indirect_glBlendFunc(GLenum sfactor, GLenum dfactor)
3474 {
3475 __GLXcontext *const gc = __glXGetCurrentContext();
3476 const GLuint cmdlen = 12;
3477 emit_header(gc->pc, X_GLrop_BlendFunc, cmdlen);
3478 (void) memcpy((void *) (gc->pc + 4), (void *) (&sfactor), 4);
3479 (void) memcpy((void *) (gc->pc + 8), (void *) (&dfactor), 4);
3480 gc->pc += cmdlen;
3481 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3482 (void) __glXFlushRenderBuffer(gc, gc->pc);
3483 }
3484 }
3485
3486 #define X_GLrop_LogicOp 161
3487 void
3488 __indirect_glLogicOp(GLenum opcode)
3489 {
3490 __GLXcontext *const gc = __glXGetCurrentContext();
3491 const GLuint cmdlen = 8;
3492 emit_header(gc->pc, X_GLrop_LogicOp, cmdlen);
3493 (void) memcpy((void *) (gc->pc + 4), (void *) (&opcode), 4);
3494 gc->pc += cmdlen;
3495 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3496 (void) __glXFlushRenderBuffer(gc, gc->pc);
3497 }
3498 }
3499
3500 #define X_GLrop_StencilFunc 162
3501 void
3502 __indirect_glStencilFunc(GLenum func, GLint ref, GLuint mask)
3503 {
3504 __GLXcontext *const gc = __glXGetCurrentContext();
3505 const GLuint cmdlen = 16;
3506 emit_header(gc->pc, X_GLrop_StencilFunc, cmdlen);
3507 (void) memcpy((void *) (gc->pc + 4), (void *) (&func), 4);
3508 (void) memcpy((void *) (gc->pc + 8), (void *) (&ref), 4);
3509 (void) memcpy((void *) (gc->pc + 12), (void *) (&mask), 4);
3510 gc->pc += cmdlen;
3511 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3512 (void) __glXFlushRenderBuffer(gc, gc->pc);
3513 }
3514 }
3515
3516 #define X_GLrop_StencilOp 163
3517 void
3518 __indirect_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
3519 {
3520 __GLXcontext *const gc = __glXGetCurrentContext();
3521 const GLuint cmdlen = 16;
3522 emit_header(gc->pc, X_GLrop_StencilOp, cmdlen);
3523 (void) memcpy((void *) (gc->pc + 4), (void *) (&fail), 4);
3524 (void) memcpy((void *) (gc->pc + 8), (void *) (&zfail), 4);
3525 (void) memcpy((void *) (gc->pc + 12), (void *) (&zpass), 4);
3526 gc->pc += cmdlen;
3527 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3528 (void) __glXFlushRenderBuffer(gc, gc->pc);
3529 }
3530 }
3531
3532 #define X_GLrop_DepthFunc 164
3533 void
3534 __indirect_glDepthFunc(GLenum func)
3535 {
3536 __GLXcontext *const gc = __glXGetCurrentContext();
3537 const GLuint cmdlen = 8;
3538 emit_header(gc->pc, X_GLrop_DepthFunc, cmdlen);
3539 (void) memcpy((void *) (gc->pc + 4), (void *) (&func), 4);
3540 gc->pc += cmdlen;
3541 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3542 (void) __glXFlushRenderBuffer(gc, gc->pc);
3543 }
3544 }
3545
3546 #define X_GLrop_PixelZoom 165
3547 void
3548 __indirect_glPixelZoom(GLfloat xfactor, GLfloat yfactor)
3549 {
3550 __GLXcontext *const gc = __glXGetCurrentContext();
3551 const GLuint cmdlen = 12;
3552 emit_header(gc->pc, X_GLrop_PixelZoom, cmdlen);
3553 (void) memcpy((void *) (gc->pc + 4), (void *) (&xfactor), 4);
3554 (void) memcpy((void *) (gc->pc + 8), (void *) (&yfactor), 4);
3555 gc->pc += cmdlen;
3556 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3557 (void) __glXFlushRenderBuffer(gc, gc->pc);
3558 }
3559 }
3560
3561 #define X_GLrop_PixelTransferf 166
3562 void
3563 __indirect_glPixelTransferf(GLenum pname, GLfloat param)
3564 {
3565 __GLXcontext *const gc = __glXGetCurrentContext();
3566 const GLuint cmdlen = 12;
3567 emit_header(gc->pc, X_GLrop_PixelTransferf, cmdlen);
3568 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
3569 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
3570 gc->pc += cmdlen;
3571 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3572 (void) __glXFlushRenderBuffer(gc, gc->pc);
3573 }
3574 }
3575
3576 #define X_GLrop_PixelTransferi 167
3577 void
3578 __indirect_glPixelTransferi(GLenum pname, GLint param)
3579 {
3580 __GLXcontext *const gc = __glXGetCurrentContext();
3581 const GLuint cmdlen = 12;
3582 emit_header(gc->pc, X_GLrop_PixelTransferi, cmdlen);
3583 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
3584 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
3585 gc->pc += cmdlen;
3586 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3587 (void) __glXFlushRenderBuffer(gc, gc->pc);
3588 }
3589 }
3590
3591 #define X_GLrop_PixelMapfv 168
3592 void
3593 __indirect_glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat * values)
3594 {
3595 __GLXcontext *const gc = __glXGetCurrentContext();
3596 const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
3597 if (mapsize < 0) {
3598 __glXSetError(gc, GL_INVALID_VALUE);
3599 return;
3600 }
3601 if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
3602 if (cmdlen <= gc->maxSmallRenderCommandSize) {
3603 if ((gc->pc + cmdlen) > gc->bufEnd) {
3604 (void) __glXFlushRenderBuffer(gc, gc->pc);
3605 }
3606 emit_header(gc->pc, X_GLrop_PixelMapfv, cmdlen);
3607 (void) memcpy((void *) (gc->pc + 4), (void *) (&map), 4);
3608 (void) memcpy((void *) (gc->pc + 8), (void *) (&mapsize), 4);
3609 (void) memcpy((void *) (gc->pc + 12), (void *) (values),
3610 (mapsize * 4));
3611 gc->pc += cmdlen;
3612 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3613 (void) __glXFlushRenderBuffer(gc, gc->pc);
3614 }
3615 } else {
3616 const GLint op = X_GLrop_PixelMapfv;
3617 const GLuint cmdlenLarge = cmdlen + 4;
3618 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
3619 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
3620 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
3621 (void) memcpy((void *) (pc + 8), (void *) (&map), 4);
3622 (void) memcpy((void *) (pc + 12), (void *) (&mapsize), 4);
3623 __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4));
3624 }
3625 }
3626 }
3627
3628 #define X_GLrop_PixelMapuiv 169
3629 void
3630 __indirect_glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint * values)
3631 {
3632 __GLXcontext *const gc = __glXGetCurrentContext();
3633 const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
3634 if (mapsize < 0) {
3635 __glXSetError(gc, GL_INVALID_VALUE);
3636 return;
3637 }
3638 if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
3639 if (cmdlen <= gc->maxSmallRenderCommandSize) {
3640 if ((gc->pc + cmdlen) > gc->bufEnd) {
3641 (void) __glXFlushRenderBuffer(gc, gc->pc);
3642 }
3643 emit_header(gc->pc, X_GLrop_PixelMapuiv, cmdlen);
3644 (void) memcpy((void *) (gc->pc + 4), (void *) (&map), 4);
3645 (void) memcpy((void *) (gc->pc + 8), (void *) (&mapsize), 4);
3646 (void) memcpy((void *) (gc->pc + 12), (void *) (values),
3647 (mapsize * 4));
3648 gc->pc += cmdlen;
3649 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3650 (void) __glXFlushRenderBuffer(gc, gc->pc);
3651 }
3652 } else {
3653 const GLint op = X_GLrop_PixelMapuiv;
3654 const GLuint cmdlenLarge = cmdlen + 4;
3655 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
3656 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
3657 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
3658 (void) memcpy((void *) (pc + 8), (void *) (&map), 4);
3659 (void) memcpy((void *) (pc + 12), (void *) (&mapsize), 4);
3660 __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4));
3661 }
3662 }
3663 }
3664
3665 #define X_GLrop_PixelMapusv 170
3666 void
3667 __indirect_glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort * values)
3668 {
3669 __GLXcontext *const gc = __glXGetCurrentContext();
3670 const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 2));
3671 if (mapsize < 0) {
3672 __glXSetError(gc, GL_INVALID_VALUE);
3673 return;
3674 }
3675 if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
3676 if (cmdlen <= gc->maxSmallRenderCommandSize) {
3677 if ((gc->pc + cmdlen) > gc->bufEnd) {
3678 (void) __glXFlushRenderBuffer(gc, gc->pc);
3679 }
3680 emit_header(gc->pc, X_GLrop_PixelMapusv, cmdlen);
3681 (void) memcpy((void *) (gc->pc + 4), (void *) (&map), 4);
3682 (void) memcpy((void *) (gc->pc + 8), (void *) (&mapsize), 4);
3683 (void) memcpy((void *) (gc->pc + 12), (void *) (values),
3684 (mapsize * 2));
3685 gc->pc += cmdlen;
3686 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3687 (void) __glXFlushRenderBuffer(gc, gc->pc);
3688 }
3689 } else {
3690 const GLint op = X_GLrop_PixelMapusv;
3691 const GLuint cmdlenLarge = cmdlen + 4;
3692 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
3693 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
3694 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
3695 (void) memcpy((void *) (pc + 8), (void *) (&map), 4);
3696 (void) memcpy((void *) (pc + 12), (void *) (&mapsize), 4);
3697 __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 2));
3698 }
3699 }
3700 }
3701
3702 #define X_GLrop_ReadBuffer 171
3703 void
3704 __indirect_glReadBuffer(GLenum mode)
3705 {
3706 __GLXcontext *const gc = __glXGetCurrentContext();
3707 const GLuint cmdlen = 8;
3708 emit_header(gc->pc, X_GLrop_ReadBuffer, cmdlen);
3709 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
3710 gc->pc += cmdlen;
3711 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3712 (void) __glXFlushRenderBuffer(gc, gc->pc);
3713 }
3714 }
3715
3716 #define X_GLrop_CopyPixels 172
3717 void
3718 __indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height,
3719 GLenum type)
3720 {
3721 __GLXcontext *const gc = __glXGetCurrentContext();
3722 const GLuint cmdlen = 24;
3723 emit_header(gc->pc, X_GLrop_CopyPixels, cmdlen);
3724 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
3725 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
3726 (void) memcpy((void *) (gc->pc + 12), (void *) (&width), 4);
3727 (void) memcpy((void *) (gc->pc + 16), (void *) (&height), 4);
3728 (void) memcpy((void *) (gc->pc + 20), (void *) (&type), 4);
3729 gc->pc += cmdlen;
3730 if (__builtin_expect(gc->pc > gc->limit, 0)) {
3731 (void) __glXFlushRenderBuffer(gc, gc->pc);
3732 }
3733 }
3734
3735 #define X_GLsop_ReadPixels 111
3736 void
3737 __indirect_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
3738 GLenum format, GLenum type, GLvoid * pixels)
3739 {
3740 __GLXcontext *const gc = __glXGetCurrentContext();
3741 const __GLXattribute *const state = gc->client_state_private;
3742 Display *const dpy = gc->currentDpy;
3743 #ifndef USE_XCB
3744 const GLuint cmdlen = 28;
3745 #endif
3746 if (__builtin_expect(dpy != NULL, 1)) {
3747 #ifdef USE_XCB
3748 xcb_connection_t *c = XGetXCBConnection(dpy);
3749 (void) __glXFlushRenderBuffer(gc, gc->pc);
3750 xcb_glx_read_pixels_reply_t *reply =
3751 xcb_glx_read_pixels_reply(c,
3752 xcb_glx_read_pixels(c,
3753 gc->
3754 currentContextTag,
3755 x, y, width, height,
3756 format, type,
3757 state->storePack.
3758 swapEndian, 0),
3759 NULL);
3760 (void) memcpy(pixels, xcb_glx_read_pixels_data(reply),
3761 xcb_glx_read_pixels_data_length(reply) *
3762 sizeof(GLvoid));
3763 free(reply);
3764 #else
3765 GLubyte const *pc =
3766 __glXSetupSingleRequest(gc, X_GLsop_ReadPixels, cmdlen);
3767 (void) memcpy((void *) (pc + 0), (void *) (&x), 4);
3768 (void) memcpy((void *) (pc + 4), (void *) (&y), 4);
3769 (void) memcpy((void *) (pc + 8), (void *) (&width), 4);
3770 (void) memcpy((void *) (pc + 12), (void *) (&height), 4);
3771 (void) memcpy((void *) (pc + 16), (void *) (&format), 4);
3772 (void) memcpy((void *) (pc + 20), (void *) (&type), 4);
3773 *(int32_t *) (pc + 24) = 0;
3774 *(int8_t *) (pc + 24) = state->storePack.swapEndian;
3775 __glXReadPixelReply(dpy, gc, 2, width, height, 1, format, type,
3776 pixels, GL_FALSE);
3777 UnlockDisplay(dpy);
3778 SyncHandle();
3779 #endif /* USE_XCB */
3780 }
3781 return;
3782 }
3783
3784 #define X_GLrop_DrawPixels 173
3785 void
3786 __indirect_glDrawPixels(GLsizei width, GLsizei height, GLenum format,
3787 GLenum type, const GLvoid * pixels)
3788 {
3789 __GLXcontext *const gc = __glXGetCurrentContext();
3790 const GLuint compsize =
3791 (pixels != NULL) ? __glImageSize(width, height, 1, format, type,
3792 0) : 0;
3793 const GLuint cmdlen = 40 + __GLX_PAD(compsize);
3794 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
3795 if (cmdlen <= gc->maxSmallRenderCommandSize) {
3796 if ((gc->pc + cmdlen) > gc->bufEnd) {
3797 (void) __glXFlushRenderBuffer(gc, gc->pc);
3798 }
3799 emit_header(gc->pc, X_GLrop_DrawPixels, cmdlen);
3800 (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4);
3801 (void) memcpy((void *) (gc->pc + 28), (void *) (&height), 4);
3802 (void) memcpy((void *) (gc->pc + 32), (void *) (&format), 4);
3803 (void) memcpy((void *) (gc->pc + 36), (void *) (&type), 4);
3804 if (compsize > 0) {
3805 (*gc->fillImage) (gc, 2, width, height, 1, format, type,
3806 pixels, gc->pc + 40, gc->pc + 4);
3807 } else {
3808 (void) memcpy(gc->pc + 4, default_pixel_store_2D,
3809 default_pixel_store_2D_size);
3810 }
3811 gc->pc += cmdlen;
3812 if (gc->pc > gc->limit) {
3813 (void) __glXFlushRenderBuffer(gc, gc->pc);
3814 }
3815 } else {
3816 const GLint op = X_GLrop_DrawPixels;
3817 const GLuint cmdlenLarge = cmdlen + 4;
3818 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
3819 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
3820 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
3821 (void) memcpy((void *) (pc + 28), (void *) (&width), 4);
3822 (void) memcpy((void *) (pc + 32), (void *) (&height), 4);
3823 (void) memcpy((void *) (pc + 36), (void *) (&format), 4);
3824 (void) memcpy((void *) (pc + 40), (void *) (&type), 4);
3825 __glXSendLargeImage(gc, compsize, 2, width, height, 1, format,
3826 type, pixels, pc + 44, pc + 8);
3827 }
3828 }
3829 }
3830
3831 #define X_GLsop_GetClipPlane 113
3832 void
3833 __indirect_glGetClipPlane(GLenum plane, GLdouble * equation)
3834 {
3835 __GLXcontext *const gc = __glXGetCurrentContext();
3836 Display *const dpy = gc->currentDpy;
3837 #ifndef USE_XCB
3838 const GLuint cmdlen = 4;
3839 #endif
3840 if (__builtin_expect(dpy != NULL, 1)) {
3841 #ifdef USE_XCB
3842 xcb_connection_t *c = XGetXCBConnection(dpy);
3843 (void) __glXFlushRenderBuffer(gc, gc->pc);
3844 xcb_glx_get_clip_plane_reply_t *reply =
3845 xcb_glx_get_clip_plane_reply(c,
3846 xcb_glx_get_clip_plane(c,
3847 gc->
3848 currentContextTag,
3849 plane), NULL);
3850 (void) memcpy(equation, xcb_glx_get_clip_plane_data(reply),
3851 xcb_glx_get_clip_plane_data_length(reply) *
3852 sizeof(GLdouble));
3853 free(reply);
3854 #else
3855 GLubyte const *pc =
3856 __glXSetupSingleRequest(gc, X_GLsop_GetClipPlane, cmdlen);
3857 (void) memcpy((void *) (pc + 0), (void *) (&plane), 4);
3858 (void) __glXReadReply(dpy, 8, equation, GL_TRUE);
3859 UnlockDisplay(dpy);
3860 SyncHandle();
3861 #endif /* USE_XCB */
3862 }
3863 return;
3864 }
3865
3866 #define X_GLsop_GetLightfv 118
3867 void
3868 __indirect_glGetLightfv(GLenum light, GLenum pname, GLfloat * params)
3869 {
3870 __GLXcontext *const gc = __glXGetCurrentContext();
3871 Display *const dpy = gc->currentDpy;
3872 #ifndef USE_XCB
3873 const GLuint cmdlen = 8;
3874 #endif
3875 if (__builtin_expect(dpy != NULL, 1)) {
3876 #ifdef USE_XCB
3877 xcb_connection_t *c = XGetXCBConnection(dpy);
3878 (void) __glXFlushRenderBuffer(gc, gc->pc);
3879 xcb_glx_get_lightfv_reply_t *reply =
3880 xcb_glx_get_lightfv_reply(c,
3881 xcb_glx_get_lightfv(c,
3882 gc->
3883 currentContextTag,
3884 light, pname),
3885 NULL);
3886 if (xcb_glx_get_lightfv_data_length(reply) == 0)
3887 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
3888 else
3889 (void) memcpy(params, xcb_glx_get_lightfv_data(reply),
3890 xcb_glx_get_lightfv_data_length(reply) *
3891 sizeof(GLfloat));
3892 free(reply);
3893 #else
3894 GLubyte const *pc =
3895 __glXSetupSingleRequest(gc, X_GLsop_GetLightfv, cmdlen);
3896 (void) memcpy((void *) (pc + 0), (void *) (&light), 4);
3897 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
3898 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3899 UnlockDisplay(dpy);
3900 SyncHandle();
3901 #endif /* USE_XCB */
3902 }
3903 return;
3904 }
3905
3906 #define X_GLsop_GetLightiv 119
3907 void
3908 __indirect_glGetLightiv(GLenum light, GLenum pname, GLint * params)
3909 {
3910 __GLXcontext *const gc = __glXGetCurrentContext();
3911 Display *const dpy = gc->currentDpy;
3912 #ifndef USE_XCB
3913 const GLuint cmdlen = 8;
3914 #endif
3915 if (__builtin_expect(dpy != NULL, 1)) {
3916 #ifdef USE_XCB
3917 xcb_connection_t *c = XGetXCBConnection(dpy);
3918 (void) __glXFlushRenderBuffer(gc, gc->pc);
3919 xcb_glx_get_lightiv_reply_t *reply =
3920 xcb_glx_get_lightiv_reply(c,
3921 xcb_glx_get_lightiv(c,
3922 gc->
3923 currentContextTag,
3924 light, pname),
3925 NULL);
3926 if (xcb_glx_get_lightiv_data_length(reply) == 0)
3927 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
3928 else
3929 (void) memcpy(params, xcb_glx_get_lightiv_data(reply),
3930 xcb_glx_get_lightiv_data_length(reply) *
3931 sizeof(GLint));
3932 free(reply);
3933 #else
3934 GLubyte const *pc =
3935 __glXSetupSingleRequest(gc, X_GLsop_GetLightiv, cmdlen);
3936 (void) memcpy((void *) (pc + 0), (void *) (&light), 4);
3937 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
3938 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
3939 UnlockDisplay(dpy);
3940 SyncHandle();
3941 #endif /* USE_XCB */
3942 }
3943 return;
3944 }
3945
3946 #define X_GLsop_GetMapdv 120
3947 void
3948 __indirect_glGetMapdv(GLenum target, GLenum query, GLdouble * v)
3949 {
3950 __GLXcontext *const gc = __glXGetCurrentContext();
3951 Display *const dpy = gc->currentDpy;
3952 #ifndef USE_XCB
3953 const GLuint cmdlen = 8;
3954 #endif
3955 if (__builtin_expect(dpy != NULL, 1)) {
3956 #ifdef USE_XCB
3957 xcb_connection_t *c = XGetXCBConnection(dpy);
3958 (void) __glXFlushRenderBuffer(gc, gc->pc);
3959 xcb_glx_get_mapdv_reply_t *reply =
3960 xcb_glx_get_mapdv_reply(c,
3961 xcb_glx_get_mapdv(c,
3962 gc->currentContextTag,
3963 target, query), NULL);
3964 if (xcb_glx_get_mapdv_data_length(reply) == 0)
3965 (void) memcpy(v, &reply->datum, sizeof(reply->datum));
3966 else
3967 (void) memcpy(v, xcb_glx_get_mapdv_data(reply),
3968 xcb_glx_get_mapdv_data_length(reply) *
3969 sizeof(GLdouble));
3970 free(reply);
3971 #else
3972 GLubyte const *pc =
3973 __glXSetupSingleRequest(gc, X_GLsop_GetMapdv, cmdlen);
3974 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
3975 (void) memcpy((void *) (pc + 4), (void *) (&query), 4);
3976 (void) __glXReadReply(dpy, 8, v, GL_FALSE);
3977 UnlockDisplay(dpy);
3978 SyncHandle();
3979 #endif /* USE_XCB */
3980 }
3981 return;
3982 }
3983
3984 #define X_GLsop_GetMapfv 121
3985 void
3986 __indirect_glGetMapfv(GLenum target, GLenum query, GLfloat * v)
3987 {
3988 __GLXcontext *const gc = __glXGetCurrentContext();
3989 Display *const dpy = gc->currentDpy;
3990 #ifndef USE_XCB
3991 const GLuint cmdlen = 8;
3992 #endif
3993 if (__builtin_expect(dpy != NULL, 1)) {
3994 #ifdef USE_XCB
3995 xcb_connection_t *c = XGetXCBConnection(dpy);
3996 (void) __glXFlushRenderBuffer(gc, gc->pc);
3997 xcb_glx_get_mapfv_reply_t *reply =
3998 xcb_glx_get_mapfv_reply(c,
3999 xcb_glx_get_mapfv(c,
4000 gc->currentContextTag,
4001 target, query), NULL);
4002 if (xcb_glx_get_mapfv_data_length(reply) == 0)
4003 (void) memcpy(v, &reply->datum, sizeof(reply->datum));
4004 else
4005 (void) memcpy(v, xcb_glx_get_mapfv_data(reply),
4006 xcb_glx_get_mapfv_data_length(reply) *
4007 sizeof(GLfloat));
4008 free(reply);
4009 #else
4010 GLubyte const *pc =
4011 __glXSetupSingleRequest(gc, X_GLsop_GetMapfv, cmdlen);
4012 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4013 (void) memcpy((void *) (pc + 4), (void *) (&query), 4);
4014 (void) __glXReadReply(dpy, 4, v, GL_FALSE);
4015 UnlockDisplay(dpy);
4016 SyncHandle();
4017 #endif /* USE_XCB */
4018 }
4019 return;
4020 }
4021
4022 #define X_GLsop_GetMapiv 122
4023 void
4024 __indirect_glGetMapiv(GLenum target, GLenum query, GLint * v)
4025 {
4026 __GLXcontext *const gc = __glXGetCurrentContext();
4027 Display *const dpy = gc->currentDpy;
4028 #ifndef USE_XCB
4029 const GLuint cmdlen = 8;
4030 #endif
4031 if (__builtin_expect(dpy != NULL, 1)) {
4032 #ifdef USE_XCB
4033 xcb_connection_t *c = XGetXCBConnection(dpy);
4034 (void) __glXFlushRenderBuffer(gc, gc->pc);
4035 xcb_glx_get_mapiv_reply_t *reply =
4036 xcb_glx_get_mapiv_reply(c,
4037 xcb_glx_get_mapiv(c,
4038 gc->currentContextTag,
4039 target, query), NULL);
4040 if (xcb_glx_get_mapiv_data_length(reply) == 0)
4041 (void) memcpy(v, &reply->datum, sizeof(reply->datum));
4042 else
4043 (void) memcpy(v, xcb_glx_get_mapiv_data(reply),
4044 xcb_glx_get_mapiv_data_length(reply) *
4045 sizeof(GLint));
4046 free(reply);
4047 #else
4048 GLubyte const *pc =
4049 __glXSetupSingleRequest(gc, X_GLsop_GetMapiv, cmdlen);
4050 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4051 (void) memcpy((void *) (pc + 4), (void *) (&query), 4);
4052 (void) __glXReadReply(dpy, 4, v, GL_FALSE);
4053 UnlockDisplay(dpy);
4054 SyncHandle();
4055 #endif /* USE_XCB */
4056 }
4057 return;
4058 }
4059
4060 #define X_GLsop_GetMaterialfv 123
4061 void
4062 __indirect_glGetMaterialfv(GLenum face, GLenum pname, GLfloat * params)
4063 {
4064 __GLXcontext *const gc = __glXGetCurrentContext();
4065 Display *const dpy = gc->currentDpy;
4066 #ifndef USE_XCB
4067 const GLuint cmdlen = 8;
4068 #endif
4069 if (__builtin_expect(dpy != NULL, 1)) {
4070 #ifdef USE_XCB
4071 xcb_connection_t *c = XGetXCBConnection(dpy);
4072 (void) __glXFlushRenderBuffer(gc, gc->pc);
4073 xcb_glx_get_materialfv_reply_t *reply =
4074 xcb_glx_get_materialfv_reply(c,
4075 xcb_glx_get_materialfv(c,
4076 gc->
4077 currentContextTag,
4078 face, pname),
4079 NULL);
4080 if (xcb_glx_get_materialfv_data_length(reply) == 0)
4081 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4082 else
4083 (void) memcpy(params, xcb_glx_get_materialfv_data(reply),
4084 xcb_glx_get_materialfv_data_length(reply) *
4085 sizeof(GLfloat));
4086 free(reply);
4087 #else
4088 GLubyte const *pc =
4089 __glXSetupSingleRequest(gc, X_GLsop_GetMaterialfv, cmdlen);
4090 (void) memcpy((void *) (pc + 0), (void *) (&face), 4);
4091 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4092 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4093 UnlockDisplay(dpy);
4094 SyncHandle();
4095 #endif /* USE_XCB */
4096 }
4097 return;
4098 }
4099
4100 #define X_GLsop_GetMaterialiv 124
4101 void
4102 __indirect_glGetMaterialiv(GLenum face, GLenum pname, GLint * params)
4103 {
4104 __GLXcontext *const gc = __glXGetCurrentContext();
4105 Display *const dpy = gc->currentDpy;
4106 #ifndef USE_XCB
4107 const GLuint cmdlen = 8;
4108 #endif
4109 if (__builtin_expect(dpy != NULL, 1)) {
4110 #ifdef USE_XCB
4111 xcb_connection_t *c = XGetXCBConnection(dpy);
4112 (void) __glXFlushRenderBuffer(gc, gc->pc);
4113 xcb_glx_get_materialiv_reply_t *reply =
4114 xcb_glx_get_materialiv_reply(c,
4115 xcb_glx_get_materialiv(c,
4116 gc->
4117 currentContextTag,
4118 face, pname),
4119 NULL);
4120 if (xcb_glx_get_materialiv_data_length(reply) == 0)
4121 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4122 else
4123 (void) memcpy(params, xcb_glx_get_materialiv_data(reply),
4124 xcb_glx_get_materialiv_data_length(reply) *
4125 sizeof(GLint));
4126 free(reply);
4127 #else
4128 GLubyte const *pc =
4129 __glXSetupSingleRequest(gc, X_GLsop_GetMaterialiv, cmdlen);
4130 (void) memcpy((void *) (pc + 0), (void *) (&face), 4);
4131 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4132 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4133 UnlockDisplay(dpy);
4134 SyncHandle();
4135 #endif /* USE_XCB */
4136 }
4137 return;
4138 }
4139
4140 #define X_GLsop_GetPixelMapfv 125
4141 void
4142 __indirect_glGetPixelMapfv(GLenum map, GLfloat * values)
4143 {
4144 __GLXcontext *const gc = __glXGetCurrentContext();
4145 Display *const dpy = gc->currentDpy;
4146 #ifndef USE_XCB
4147 const GLuint cmdlen = 4;
4148 #endif
4149 if (__builtin_expect(dpy != NULL, 1)) {
4150 #ifdef USE_XCB
4151 xcb_connection_t *c = XGetXCBConnection(dpy);
4152 (void) __glXFlushRenderBuffer(gc, gc->pc);
4153 xcb_glx_get_pixel_mapfv_reply_t *reply =
4154 xcb_glx_get_pixel_mapfv_reply(c,
4155 xcb_glx_get_pixel_mapfv(c,
4156 gc->
4157 currentContextTag,
4158 map), NULL);
4159 if (xcb_glx_get_pixel_mapfv_data_length(reply) == 0)
4160 (void) memcpy(values, &reply->datum, sizeof(reply->datum));
4161 else
4162 (void) memcpy(values, xcb_glx_get_pixel_mapfv_data(reply),
4163 xcb_glx_get_pixel_mapfv_data_length(reply) *
4164 sizeof(GLfloat));
4165 free(reply);
4166 #else
4167 GLubyte const *pc =
4168 __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapfv, cmdlen);
4169 (void) memcpy((void *) (pc + 0), (void *) (&map), 4);
4170 (void) __glXReadReply(dpy, 4, values, GL_FALSE);
4171 UnlockDisplay(dpy);
4172 SyncHandle();
4173 #endif /* USE_XCB */
4174 }
4175 return;
4176 }
4177
4178 #define X_GLsop_GetPixelMapuiv 126
4179 void
4180 __indirect_glGetPixelMapuiv(GLenum map, GLuint * values)
4181 {
4182 __GLXcontext *const gc = __glXGetCurrentContext();
4183 Display *const dpy = gc->currentDpy;
4184 #ifndef USE_XCB
4185 const GLuint cmdlen = 4;
4186 #endif
4187 if (__builtin_expect(dpy != NULL, 1)) {
4188 #ifdef USE_XCB
4189 xcb_connection_t *c = XGetXCBConnection(dpy);
4190 (void) __glXFlushRenderBuffer(gc, gc->pc);
4191 xcb_glx_get_pixel_mapuiv_reply_t *reply =
4192 xcb_glx_get_pixel_mapuiv_reply(c,
4193 xcb_glx_get_pixel_mapuiv(c,
4194 gc->
4195 currentContextTag,
4196 map),
4197 NULL);
4198 if (xcb_glx_get_pixel_mapuiv_data_length(reply) == 0)
4199 (void) memcpy(values, &reply->datum, sizeof(reply->datum));
4200 else
4201 (void) memcpy(values, xcb_glx_get_pixel_mapuiv_data(reply),
4202 xcb_glx_get_pixel_mapuiv_data_length(reply) *
4203 sizeof(GLuint));
4204 free(reply);
4205 #else
4206 GLubyte const *pc =
4207 __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapuiv, cmdlen);
4208 (void) memcpy((void *) (pc + 0), (void *) (&map), 4);
4209 (void) __glXReadReply(dpy, 4, values, GL_FALSE);
4210 UnlockDisplay(dpy);
4211 SyncHandle();
4212 #endif /* USE_XCB */
4213 }
4214 return;
4215 }
4216
4217 #define X_GLsop_GetPixelMapusv 127
4218 void
4219 __indirect_glGetPixelMapusv(GLenum map, GLushort * values)
4220 {
4221 __GLXcontext *const gc = __glXGetCurrentContext();
4222 Display *const dpy = gc->currentDpy;
4223 #ifndef USE_XCB
4224 const GLuint cmdlen = 4;
4225 #endif
4226 if (__builtin_expect(dpy != NULL, 1)) {
4227 #ifdef USE_XCB
4228 xcb_connection_t *c = XGetXCBConnection(dpy);
4229 (void) __glXFlushRenderBuffer(gc, gc->pc);
4230 xcb_glx_get_pixel_mapusv_reply_t *reply =
4231 xcb_glx_get_pixel_mapusv_reply(c,
4232 xcb_glx_get_pixel_mapusv(c,
4233 gc->
4234 currentContextTag,
4235 map),
4236 NULL);
4237 if (xcb_glx_get_pixel_mapusv_data_length(reply) == 0)
4238 (void) memcpy(values, &reply->datum, sizeof(reply->datum));
4239 else
4240 (void) memcpy(values, xcb_glx_get_pixel_mapusv_data(reply),
4241 xcb_glx_get_pixel_mapusv_data_length(reply) *
4242 sizeof(GLushort));
4243 free(reply);
4244 #else
4245 GLubyte const *pc =
4246 __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapusv, cmdlen);
4247 (void) memcpy((void *) (pc + 0), (void *) (&map), 4);
4248 (void) __glXReadReply(dpy, 2, values, GL_FALSE);
4249 UnlockDisplay(dpy);
4250 SyncHandle();
4251 #endif /* USE_XCB */
4252 }
4253 return;
4254 }
4255
4256 #define X_GLsop_GetPolygonStipple 128
4257 void
4258 __indirect_glGetPolygonStipple(GLubyte *mask)
4259 {
4260 __GLXcontext *const gc = __glXGetCurrentContext();
4261 Display *const dpy = gc->currentDpy;
4262 #ifndef USE_XCB
4263 const GLuint cmdlen = 4;
4264 #endif
4265 if (__builtin_expect(dpy != NULL, 1)) {
4266 #ifdef USE_XCB
4267 xcb_connection_t *c = XGetXCBConnection(dpy);
4268 (void) __glXFlushRenderBuffer(gc, gc->pc);
4269 xcb_glx_get_polygon_stipple_reply_t *reply =
4270 xcb_glx_get_polygon_stipple_reply(c,
4271 xcb_glx_get_polygon_stipple(c,
4272 gc->
4273 currentContextTag,
4274 0),
4275 NULL);
4276 (void) memcpy(mask, xcb_glx_get_polygon_stipple_data(reply),
4277 xcb_glx_get_polygon_stipple_data_length(reply) *
4278 sizeof(GLubyte));
4279 free(reply);
4280 #else
4281 GLubyte const *pc =
4282 __glXSetupSingleRequest(gc, X_GLsop_GetPolygonStipple, cmdlen);
4283 *(int32_t *) (pc + 0) = 0;
4284 __glXReadPixelReply(dpy, gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP,
4285 mask, GL_FALSE);
4286 UnlockDisplay(dpy);
4287 SyncHandle();
4288 #endif /* USE_XCB */
4289 }
4290 return;
4291 }
4292
4293 #define X_GLsop_GetTexEnvfv 130
4294 void
4295 __indirect_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat * params)
4296 {
4297 __GLXcontext *const gc = __glXGetCurrentContext();
4298 Display *const dpy = gc->currentDpy;
4299 #ifndef USE_XCB
4300 const GLuint cmdlen = 8;
4301 #endif
4302 if (__builtin_expect(dpy != NULL, 1)) {
4303 #ifdef USE_XCB
4304 xcb_connection_t *c = XGetXCBConnection(dpy);
4305 (void) __glXFlushRenderBuffer(gc, gc->pc);
4306 xcb_glx_get_tex_envfv_reply_t *reply =
4307 xcb_glx_get_tex_envfv_reply(c,
4308 xcb_glx_get_tex_envfv(c,
4309 gc->
4310 currentContextTag,
4311 target, pname),
4312 NULL);
4313 if (xcb_glx_get_tex_envfv_data_length(reply) == 0)
4314 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4315 else
4316 (void) memcpy(params, xcb_glx_get_tex_envfv_data(reply),
4317 xcb_glx_get_tex_envfv_data_length(reply) *
4318 sizeof(GLfloat));
4319 free(reply);
4320 #else
4321 GLubyte const *pc =
4322 __glXSetupSingleRequest(gc, X_GLsop_GetTexEnvfv, cmdlen);
4323 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4324 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4325 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4326 UnlockDisplay(dpy);
4327 SyncHandle();
4328 #endif /* USE_XCB */
4329 }
4330 return;
4331 }
4332
4333 #define X_GLsop_GetTexEnviv 131
4334 void
4335 __indirect_glGetTexEnviv(GLenum target, GLenum pname, GLint * params)
4336 {
4337 __GLXcontext *const gc = __glXGetCurrentContext();
4338 Display *const dpy = gc->currentDpy;
4339 #ifndef USE_XCB
4340 const GLuint cmdlen = 8;
4341 #endif
4342 if (__builtin_expect(dpy != NULL, 1)) {
4343 #ifdef USE_XCB
4344 xcb_connection_t *c = XGetXCBConnection(dpy);
4345 (void) __glXFlushRenderBuffer(gc, gc->pc);
4346 xcb_glx_get_tex_enviv_reply_t *reply =
4347 xcb_glx_get_tex_enviv_reply(c,
4348 xcb_glx_get_tex_enviv(c,
4349 gc->
4350 currentContextTag,
4351 target, pname),
4352 NULL);
4353 if (xcb_glx_get_tex_enviv_data_length(reply) == 0)
4354 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4355 else
4356 (void) memcpy(params, xcb_glx_get_tex_enviv_data(reply),
4357 xcb_glx_get_tex_enviv_data_length(reply) *
4358 sizeof(GLint));
4359 free(reply);
4360 #else
4361 GLubyte const *pc =
4362 __glXSetupSingleRequest(gc, X_GLsop_GetTexEnviv, cmdlen);
4363 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4364 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4365 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4366 UnlockDisplay(dpy);
4367 SyncHandle();
4368 #endif /* USE_XCB */
4369 }
4370 return;
4371 }
4372
4373 #define X_GLsop_GetTexGendv 132
4374 void
4375 __indirect_glGetTexGendv(GLenum coord, GLenum pname, GLdouble * params)
4376 {
4377 __GLXcontext *const gc = __glXGetCurrentContext();
4378 Display *const dpy = gc->currentDpy;
4379 #ifndef USE_XCB
4380 const GLuint cmdlen = 8;
4381 #endif
4382 if (__builtin_expect(dpy != NULL, 1)) {
4383 #ifdef USE_XCB
4384 xcb_connection_t *c = XGetXCBConnection(dpy);
4385 (void) __glXFlushRenderBuffer(gc, gc->pc);
4386 xcb_glx_get_tex_gendv_reply_t *reply =
4387 xcb_glx_get_tex_gendv_reply(c,
4388 xcb_glx_get_tex_gendv(c,
4389 gc->
4390 currentContextTag,
4391 coord, pname),
4392 NULL);
4393 if (xcb_glx_get_tex_gendv_data_length(reply) == 0)
4394 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4395 else
4396 (void) memcpy(params, xcb_glx_get_tex_gendv_data(reply),
4397 xcb_glx_get_tex_gendv_data_length(reply) *
4398 sizeof(GLdouble));
4399 free(reply);
4400 #else
4401 GLubyte const *pc =
4402 __glXSetupSingleRequest(gc, X_GLsop_GetTexGendv, cmdlen);
4403 (void) memcpy((void *) (pc + 0), (void *) (&coord), 4);
4404 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4405 (void) __glXReadReply(dpy, 8, params, GL_FALSE);
4406 UnlockDisplay(dpy);
4407 SyncHandle();
4408 #endif /* USE_XCB */
4409 }
4410 return;
4411 }
4412
4413 #define X_GLsop_GetTexGenfv 133
4414 void
4415 __indirect_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat * params)
4416 {
4417 __GLXcontext *const gc = __glXGetCurrentContext();
4418 Display *const dpy = gc->currentDpy;
4419 #ifndef USE_XCB
4420 const GLuint cmdlen = 8;
4421 #endif
4422 if (__builtin_expect(dpy != NULL, 1)) {
4423 #ifdef USE_XCB
4424 xcb_connection_t *c = XGetXCBConnection(dpy);
4425 (void) __glXFlushRenderBuffer(gc, gc->pc);
4426 xcb_glx_get_tex_genfv_reply_t *reply =
4427 xcb_glx_get_tex_genfv_reply(c,
4428 xcb_glx_get_tex_genfv(c,
4429 gc->
4430 currentContextTag,
4431 coord, pname),
4432 NULL);
4433 if (xcb_glx_get_tex_genfv_data_length(reply) == 0)
4434 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4435 else
4436 (void) memcpy(params, xcb_glx_get_tex_genfv_data(reply),
4437 xcb_glx_get_tex_genfv_data_length(reply) *
4438 sizeof(GLfloat));
4439 free(reply);
4440 #else
4441 GLubyte const *pc =
4442 __glXSetupSingleRequest(gc, X_GLsop_GetTexGenfv, cmdlen);
4443 (void) memcpy((void *) (pc + 0), (void *) (&coord), 4);
4444 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4445 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4446 UnlockDisplay(dpy);
4447 SyncHandle();
4448 #endif /* USE_XCB */
4449 }
4450 return;
4451 }
4452
4453 #define X_GLsop_GetTexGeniv 134
4454 void
4455 __indirect_glGetTexGeniv(GLenum coord, GLenum pname, GLint * params)
4456 {
4457 __GLXcontext *const gc = __glXGetCurrentContext();
4458 Display *const dpy = gc->currentDpy;
4459 #ifndef USE_XCB
4460 const GLuint cmdlen = 8;
4461 #endif
4462 if (__builtin_expect(dpy != NULL, 1)) {
4463 #ifdef USE_XCB
4464 xcb_connection_t *c = XGetXCBConnection(dpy);
4465 (void) __glXFlushRenderBuffer(gc, gc->pc);
4466 xcb_glx_get_tex_geniv_reply_t *reply =
4467 xcb_glx_get_tex_geniv_reply(c,
4468 xcb_glx_get_tex_geniv(c,
4469 gc->
4470 currentContextTag,
4471 coord, pname),
4472 NULL);
4473 if (xcb_glx_get_tex_geniv_data_length(reply) == 0)
4474 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4475 else
4476 (void) memcpy(params, xcb_glx_get_tex_geniv_data(reply),
4477 xcb_glx_get_tex_geniv_data_length(reply) *
4478 sizeof(GLint));
4479 free(reply);
4480 #else
4481 GLubyte const *pc =
4482 __glXSetupSingleRequest(gc, X_GLsop_GetTexGeniv, cmdlen);
4483 (void) memcpy((void *) (pc + 0), (void *) (&coord), 4);
4484 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4485 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4486 UnlockDisplay(dpy);
4487 SyncHandle();
4488 #endif /* USE_XCB */
4489 }
4490 return;
4491 }
4492
4493 #define X_GLsop_GetTexImage 135
4494 void
4495 __indirect_glGetTexImage(GLenum target, GLint level, GLenum format,
4496 GLenum type, GLvoid * pixels)
4497 {
4498 __GLXcontext *const gc = __glXGetCurrentContext();
4499 const __GLXattribute *const state = gc->client_state_private;
4500 Display *const dpy = gc->currentDpy;
4501 #ifndef USE_XCB
4502 const GLuint cmdlen = 20;
4503 #endif
4504 if (__builtin_expect(dpy != NULL, 1)) {
4505 #ifdef USE_XCB
4506 xcb_connection_t *c = XGetXCBConnection(dpy);
4507 (void) __glXFlushRenderBuffer(gc, gc->pc);
4508 xcb_glx_get_tex_image_reply_t *reply =
4509 xcb_glx_get_tex_image_reply(c,
4510 xcb_glx_get_tex_image(c,
4511 gc->
4512 currentContextTag,
4513 target, level,
4514 format, type,
4515 state->
4516 storePack.
4517 swapEndian),
4518 NULL);
4519 (void) memcpy(pixels, xcb_glx_get_tex_image_data(reply),
4520 xcb_glx_get_tex_image_data_length(reply) *
4521 sizeof(GLvoid));
4522 free(reply);
4523 #else
4524 GLubyte const *pc =
4525 __glXSetupSingleRequest(gc, X_GLsop_GetTexImage, cmdlen);
4526 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4527 (void) memcpy((void *) (pc + 4), (void *) (&level), 4);
4528 (void) memcpy((void *) (pc + 8), (void *) (&format), 4);
4529 (void) memcpy((void *) (pc + 12), (void *) (&type), 4);
4530 *(int32_t *) (pc + 16) = 0;
4531 *(int8_t *) (pc + 16) = state->storePack.swapEndian;
4532 __glXReadPixelReply(dpy, gc, 3, 0, 0, 0, format, type, pixels,
4533 GL_TRUE);
4534 UnlockDisplay(dpy);
4535 SyncHandle();
4536 #endif /* USE_XCB */
4537 }
4538 return;
4539 }
4540
4541 #define X_GLsop_GetTexParameterfv 136
4542 void
4543 __indirect_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat * params)
4544 {
4545 __GLXcontext *const gc = __glXGetCurrentContext();
4546 Display *const dpy = gc->currentDpy;
4547 #ifndef USE_XCB
4548 const GLuint cmdlen = 8;
4549 #endif
4550 if (__builtin_expect(dpy != NULL, 1)) {
4551 #ifdef USE_XCB
4552 xcb_connection_t *c = XGetXCBConnection(dpy);
4553 (void) __glXFlushRenderBuffer(gc, gc->pc);
4554 xcb_glx_get_tex_parameterfv_reply_t *reply =
4555 xcb_glx_get_tex_parameterfv_reply(c,
4556 xcb_glx_get_tex_parameterfv(c,
4557 gc->
4558 currentContextTag,
4559 target,
4560 pname),
4561 NULL);
4562 if (xcb_glx_get_tex_parameterfv_data_length(reply) == 0)
4563 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4564 else
4565 (void) memcpy(params, xcb_glx_get_tex_parameterfv_data(reply),
4566 xcb_glx_get_tex_parameterfv_data_length(reply) *
4567 sizeof(GLfloat));
4568 free(reply);
4569 #else
4570 GLubyte const *pc =
4571 __glXSetupSingleRequest(gc, X_GLsop_GetTexParameterfv, cmdlen);
4572 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4573 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4574 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4575 UnlockDisplay(dpy);
4576 SyncHandle();
4577 #endif /* USE_XCB */
4578 }
4579 return;
4580 }
4581
4582 #define X_GLsop_GetTexParameteriv 137
4583 void
4584 __indirect_glGetTexParameteriv(GLenum target, GLenum pname, GLint * params)
4585 {
4586 __GLXcontext *const gc = __glXGetCurrentContext();
4587 Display *const dpy = gc->currentDpy;
4588 #ifndef USE_XCB
4589 const GLuint cmdlen = 8;
4590 #endif
4591 if (__builtin_expect(dpy != NULL, 1)) {
4592 #ifdef USE_XCB
4593 xcb_connection_t *c = XGetXCBConnection(dpy);
4594 (void) __glXFlushRenderBuffer(gc, gc->pc);
4595 xcb_glx_get_tex_parameteriv_reply_t *reply =
4596 xcb_glx_get_tex_parameteriv_reply(c,
4597 xcb_glx_get_tex_parameteriv(c,
4598 gc->
4599 currentContextTag,
4600 target,
4601 pname),
4602 NULL);
4603 if (xcb_glx_get_tex_parameteriv_data_length(reply) == 0)
4604 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4605 else
4606 (void) memcpy(params, xcb_glx_get_tex_parameteriv_data(reply),
4607 xcb_glx_get_tex_parameteriv_data_length(reply) *
4608 sizeof(GLint));
4609 free(reply);
4610 #else
4611 GLubyte const *pc =
4612 __glXSetupSingleRequest(gc, X_GLsop_GetTexParameteriv, cmdlen);
4613 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4614 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
4615 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4616 UnlockDisplay(dpy);
4617 SyncHandle();
4618 #endif /* USE_XCB */
4619 }
4620 return;
4621 }
4622
4623 #define X_GLsop_GetTexLevelParameterfv 138
4624 void
4625 __indirect_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname,
4626 GLfloat * params)
4627 {
4628 __GLXcontext *const gc = __glXGetCurrentContext();
4629 Display *const dpy = gc->currentDpy;
4630 #ifndef USE_XCB
4631 const GLuint cmdlen = 12;
4632 #endif
4633 if (__builtin_expect(dpy != NULL, 1)) {
4634 #ifdef USE_XCB
4635 xcb_connection_t *c = XGetXCBConnection(dpy);
4636 (void) __glXFlushRenderBuffer(gc, gc->pc);
4637 xcb_glx_get_tex_level_parameterfv_reply_t *reply =
4638 xcb_glx_get_tex_level_parameterfv_reply(c,
4639 xcb_glx_get_tex_level_parameterfv
4640 (c, gc->currentContextTag,
4641 target, level, pname),
4642 NULL);
4643 if (xcb_glx_get_tex_level_parameterfv_data_length(reply) == 0)
4644 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4645 else
4646 (void) memcpy(params,
4647 xcb_glx_get_tex_level_parameterfv_data(reply),
4648 xcb_glx_get_tex_level_parameterfv_data_length(reply)
4649 * sizeof(GLfloat));
4650 free(reply);
4651 #else
4652 GLubyte const *pc =
4653 __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelParameterfv,
4654 cmdlen);
4655 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4656 (void) memcpy((void *) (pc + 4), (void *) (&level), 4);
4657 (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
4658 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4659 UnlockDisplay(dpy);
4660 SyncHandle();
4661 #endif /* USE_XCB */
4662 }
4663 return;
4664 }
4665
4666 #define X_GLsop_GetTexLevelParameteriv 139
4667 void
4668 __indirect_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname,
4669 GLint * params)
4670 {
4671 __GLXcontext *const gc = __glXGetCurrentContext();
4672 Display *const dpy = gc->currentDpy;
4673 #ifndef USE_XCB
4674 const GLuint cmdlen = 12;
4675 #endif
4676 if (__builtin_expect(dpy != NULL, 1)) {
4677 #ifdef USE_XCB
4678 xcb_connection_t *c = XGetXCBConnection(dpy);
4679 (void) __glXFlushRenderBuffer(gc, gc->pc);
4680 xcb_glx_get_tex_level_parameteriv_reply_t *reply =
4681 xcb_glx_get_tex_level_parameteriv_reply(c,
4682 xcb_glx_get_tex_level_parameteriv
4683 (c, gc->currentContextTag,
4684 target, level, pname),
4685 NULL);
4686 if (xcb_glx_get_tex_level_parameteriv_data_length(reply) == 0)
4687 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
4688 else
4689 (void) memcpy(params,
4690 xcb_glx_get_tex_level_parameteriv_data(reply),
4691 xcb_glx_get_tex_level_parameteriv_data_length(reply)
4692 * sizeof(GLint));
4693 free(reply);
4694 #else
4695 GLubyte const *pc =
4696 __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelParameteriv,
4697 cmdlen);
4698 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
4699 (void) memcpy((void *) (pc + 4), (void *) (&level), 4);
4700 (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
4701 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
4702 UnlockDisplay(dpy);
4703 SyncHandle();
4704 #endif /* USE_XCB */
4705 }
4706 return;
4707 }
4708
4709 #define X_GLsop_IsList 141
4710 GLboolean
4711 __indirect_glIsList(GLuint list)
4712 {
4713 __GLXcontext *const gc = __glXGetCurrentContext();
4714 Display *const dpy = gc->currentDpy;
4715 GLboolean retval = (GLboolean) 0;
4716 #ifndef USE_XCB
4717 const GLuint cmdlen = 4;
4718 #endif
4719 if (__builtin_expect(dpy != NULL, 1)) {
4720 #ifdef USE_XCB
4721 xcb_connection_t *c = XGetXCBConnection(dpy);
4722 (void) __glXFlushRenderBuffer(gc, gc->pc);
4723 xcb_glx_is_list_reply_t *reply =
4724 xcb_glx_is_list_reply(c,
4725 xcb_glx_is_list(c, gc->currentContextTag,
4726 list), NULL);
4727 retval = reply->ret_val;
4728 free(reply);
4729 #else
4730 GLubyte const *pc =
4731 __glXSetupSingleRequest(gc, X_GLsop_IsList, cmdlen);
4732 (void) memcpy((void *) (pc + 0), (void *) (&list), 4);
4733 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
4734 UnlockDisplay(dpy);
4735 SyncHandle();
4736 #endif /* USE_XCB */
4737 }
4738 return retval;
4739 }
4740
4741 #define X_GLrop_DepthRange 174
4742 void
4743 __indirect_glDepthRange(GLclampd zNear, GLclampd zFar)
4744 {
4745 __GLXcontext *const gc = __glXGetCurrentContext();
4746 const GLuint cmdlen = 20;
4747 emit_header(gc->pc, X_GLrop_DepthRange, cmdlen);
4748 (void) memcpy((void *) (gc->pc + 4), (void *) (&zNear), 8);
4749 (void) memcpy((void *) (gc->pc + 12), (void *) (&zFar), 8);
4750 gc->pc += cmdlen;
4751 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4752 (void) __glXFlushRenderBuffer(gc, gc->pc);
4753 }
4754 }
4755
4756 #define X_GLrop_Frustum 175
4757 void
4758 __indirect_glFrustum(GLdouble left, GLdouble right, GLdouble bottom,
4759 GLdouble top, GLdouble zNear, GLdouble zFar)
4760 {
4761 __GLXcontext *const gc = __glXGetCurrentContext();
4762 const GLuint cmdlen = 52;
4763 emit_header(gc->pc, X_GLrop_Frustum, cmdlen);
4764 (void) memcpy((void *) (gc->pc + 4), (void *) (&left), 8);
4765 (void) memcpy((void *) (gc->pc + 12), (void *) (&right), 8);
4766 (void) memcpy((void *) (gc->pc + 20), (void *) (&bottom), 8);
4767 (void) memcpy((void *) (gc->pc + 28), (void *) (&top), 8);
4768 (void) memcpy((void *) (gc->pc + 36), (void *) (&zNear), 8);
4769 (void) memcpy((void *) (gc->pc + 44), (void *) (&zFar), 8);
4770 gc->pc += cmdlen;
4771 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4772 (void) __glXFlushRenderBuffer(gc, gc->pc);
4773 }
4774 }
4775
4776 #define X_GLrop_LoadIdentity 176
4777 void
4778 __indirect_glLoadIdentity(void)
4779 {
4780 __GLXcontext *const gc = __glXGetCurrentContext();
4781 const GLuint cmdlen = 4;
4782 emit_header(gc->pc, X_GLrop_LoadIdentity, cmdlen);
4783 gc->pc += cmdlen;
4784 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4785 (void) __glXFlushRenderBuffer(gc, gc->pc);
4786 }
4787 }
4788
4789 #define X_GLrop_LoadMatrixf 177
4790 void
4791 __indirect_glLoadMatrixf(const GLfloat * m)
4792 {
4793 __GLXcontext *const gc = __glXGetCurrentContext();
4794 const GLuint cmdlen = 68;
4795 emit_header(gc->pc, X_GLrop_LoadMatrixf, cmdlen);
4796 (void) memcpy((void *) (gc->pc + 4), (void *) (m), 64);
4797 gc->pc += cmdlen;
4798 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4799 (void) __glXFlushRenderBuffer(gc, gc->pc);
4800 }
4801 }
4802
4803 #define X_GLrop_LoadMatrixd 178
4804 void
4805 __indirect_glLoadMatrixd(const GLdouble * m)
4806 {
4807 __GLXcontext *const gc = __glXGetCurrentContext();
4808 const GLuint cmdlen = 132;
4809 emit_header(gc->pc, X_GLrop_LoadMatrixd, cmdlen);
4810 (void) memcpy((void *) (gc->pc + 4), (void *) (m), 128);
4811 gc->pc += cmdlen;
4812 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4813 (void) __glXFlushRenderBuffer(gc, gc->pc);
4814 }
4815 }
4816
4817 #define X_GLrop_MatrixMode 179
4818 void
4819 __indirect_glMatrixMode(GLenum mode)
4820 {
4821 __GLXcontext *const gc = __glXGetCurrentContext();
4822 const GLuint cmdlen = 8;
4823 emit_header(gc->pc, X_GLrop_MatrixMode, cmdlen);
4824 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
4825 gc->pc += cmdlen;
4826 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4827 (void) __glXFlushRenderBuffer(gc, gc->pc);
4828 }
4829 }
4830
4831 #define X_GLrop_MultMatrixf 180
4832 void
4833 __indirect_glMultMatrixf(const GLfloat * m)
4834 {
4835 __GLXcontext *const gc = __glXGetCurrentContext();
4836 const GLuint cmdlen = 68;
4837 emit_header(gc->pc, X_GLrop_MultMatrixf, cmdlen);
4838 (void) memcpy((void *) (gc->pc + 4), (void *) (m), 64);
4839 gc->pc += cmdlen;
4840 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4841 (void) __glXFlushRenderBuffer(gc, gc->pc);
4842 }
4843 }
4844
4845 #define X_GLrop_MultMatrixd 181
4846 void
4847 __indirect_glMultMatrixd(const GLdouble * m)
4848 {
4849 __GLXcontext *const gc = __glXGetCurrentContext();
4850 const GLuint cmdlen = 132;
4851 emit_header(gc->pc, X_GLrop_MultMatrixd, cmdlen);
4852 (void) memcpy((void *) (gc->pc + 4), (void *) (m), 128);
4853 gc->pc += cmdlen;
4854 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4855 (void) __glXFlushRenderBuffer(gc, gc->pc);
4856 }
4857 }
4858
4859 #define X_GLrop_Ortho 182
4860 void
4861 __indirect_glOrtho(GLdouble left, GLdouble right, GLdouble bottom,
4862 GLdouble top, GLdouble zNear, GLdouble zFar)
4863 {
4864 __GLXcontext *const gc = __glXGetCurrentContext();
4865 const GLuint cmdlen = 52;
4866 emit_header(gc->pc, X_GLrop_Ortho, cmdlen);
4867 (void) memcpy((void *) (gc->pc + 4), (void *) (&left), 8);
4868 (void) memcpy((void *) (gc->pc + 12), (void *) (&right), 8);
4869 (void) memcpy((void *) (gc->pc + 20), (void *) (&bottom), 8);
4870 (void) memcpy((void *) (gc->pc + 28), (void *) (&top), 8);
4871 (void) memcpy((void *) (gc->pc + 36), (void *) (&zNear), 8);
4872 (void) memcpy((void *) (gc->pc + 44), (void *) (&zFar), 8);
4873 gc->pc += cmdlen;
4874 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4875 (void) __glXFlushRenderBuffer(gc, gc->pc);
4876 }
4877 }
4878
4879 #define X_GLrop_PopMatrix 183
4880 void
4881 __indirect_glPopMatrix(void)
4882 {
4883 __GLXcontext *const gc = __glXGetCurrentContext();
4884 const GLuint cmdlen = 4;
4885 emit_header(gc->pc, X_GLrop_PopMatrix, cmdlen);
4886 gc->pc += cmdlen;
4887 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4888 (void) __glXFlushRenderBuffer(gc, gc->pc);
4889 }
4890 }
4891
4892 #define X_GLrop_PushMatrix 184
4893 void
4894 __indirect_glPushMatrix(void)
4895 {
4896 __GLXcontext *const gc = __glXGetCurrentContext();
4897 const GLuint cmdlen = 4;
4898 emit_header(gc->pc, X_GLrop_PushMatrix, cmdlen);
4899 gc->pc += cmdlen;
4900 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4901 (void) __glXFlushRenderBuffer(gc, gc->pc);
4902 }
4903 }
4904
4905 #define X_GLrop_Rotated 185
4906 void
4907 __indirect_glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
4908 {
4909 __GLXcontext *const gc = __glXGetCurrentContext();
4910 const GLuint cmdlen = 36;
4911 emit_header(gc->pc, X_GLrop_Rotated, cmdlen);
4912 (void) memcpy((void *) (gc->pc + 4), (void *) (&angle), 8);
4913 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 8);
4914 (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 8);
4915 (void) memcpy((void *) (gc->pc + 28), (void *) (&z), 8);
4916 gc->pc += cmdlen;
4917 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4918 (void) __glXFlushRenderBuffer(gc, gc->pc);
4919 }
4920 }
4921
4922 #define X_GLrop_Rotatef 186
4923 void
4924 __indirect_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
4925 {
4926 __GLXcontext *const gc = __glXGetCurrentContext();
4927 const GLuint cmdlen = 20;
4928 emit_header(gc->pc, X_GLrop_Rotatef, cmdlen);
4929 (void) memcpy((void *) (gc->pc + 4), (void *) (&angle), 4);
4930 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
4931 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
4932 (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4);
4933 gc->pc += cmdlen;
4934 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4935 (void) __glXFlushRenderBuffer(gc, gc->pc);
4936 }
4937 }
4938
4939 #define X_GLrop_Scaled 187
4940 void
4941 __indirect_glScaled(GLdouble x, GLdouble y, GLdouble z)
4942 {
4943 __GLXcontext *const gc = __glXGetCurrentContext();
4944 const GLuint cmdlen = 28;
4945 emit_header(gc->pc, X_GLrop_Scaled, cmdlen);
4946 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
4947 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
4948 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
4949 gc->pc += cmdlen;
4950 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4951 (void) __glXFlushRenderBuffer(gc, gc->pc);
4952 }
4953 }
4954
4955 #define X_GLrop_Scalef 188
4956 void
4957 __indirect_glScalef(GLfloat x, GLfloat y, GLfloat z)
4958 {
4959 __GLXcontext *const gc = __glXGetCurrentContext();
4960 const GLuint cmdlen = 16;
4961 emit_header(gc->pc, X_GLrop_Scalef, cmdlen);
4962 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
4963 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
4964 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
4965 gc->pc += cmdlen;
4966 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4967 (void) __glXFlushRenderBuffer(gc, gc->pc);
4968 }
4969 }
4970
4971 #define X_GLrop_Translated 189
4972 void
4973 __indirect_glTranslated(GLdouble x, GLdouble y, GLdouble z)
4974 {
4975 __GLXcontext *const gc = __glXGetCurrentContext();
4976 const GLuint cmdlen = 28;
4977 emit_header(gc->pc, X_GLrop_Translated, cmdlen);
4978 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
4979 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
4980 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
4981 gc->pc += cmdlen;
4982 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4983 (void) __glXFlushRenderBuffer(gc, gc->pc);
4984 }
4985 }
4986
4987 #define X_GLrop_Translatef 190
4988 void
4989 __indirect_glTranslatef(GLfloat x, GLfloat y, GLfloat z)
4990 {
4991 __GLXcontext *const gc = __glXGetCurrentContext();
4992 const GLuint cmdlen = 16;
4993 emit_header(gc->pc, X_GLrop_Translatef, cmdlen);
4994 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
4995 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
4996 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
4997 gc->pc += cmdlen;
4998 if (__builtin_expect(gc->pc > gc->limit, 0)) {
4999 (void) __glXFlushRenderBuffer(gc, gc->pc);
5000 }
5001 }
5002
5003 #define X_GLrop_Viewport 191
5004 void
5005 __indirect_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
5006 {
5007 __GLXcontext *const gc = __glXGetCurrentContext();
5008 const GLuint cmdlen = 20;
5009 emit_header(gc->pc, X_GLrop_Viewport, cmdlen);
5010 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
5011 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
5012 (void) memcpy((void *) (gc->pc + 12), (void *) (&width), 4);
5013 (void) memcpy((void *) (gc->pc + 16), (void *) (&height), 4);
5014 gc->pc += cmdlen;
5015 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5016 (void) __glXFlushRenderBuffer(gc, gc->pc);
5017 }
5018 }
5019
5020 #define X_GLrop_BindTexture 4117
5021 void
5022 __indirect_glBindTexture(GLenum target, GLuint texture)
5023 {
5024 __GLXcontext *const gc = __glXGetCurrentContext();
5025 const GLuint cmdlen = 12;
5026 emit_header(gc->pc, X_GLrop_BindTexture, cmdlen);
5027 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5028 (void) memcpy((void *) (gc->pc + 8), (void *) (&texture), 4);
5029 gc->pc += cmdlen;
5030 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5031 (void) __glXFlushRenderBuffer(gc, gc->pc);
5032 }
5033 }
5034
5035 #define X_GLrop_Indexubv 194
5036 void
5037 __indirect_glIndexub(GLubyte c)
5038 {
5039 __GLXcontext *const gc = __glXGetCurrentContext();
5040 const GLuint cmdlen = 8;
5041 emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
5042 (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 1);
5043 gc->pc += cmdlen;
5044 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5045 (void) __glXFlushRenderBuffer(gc, gc->pc);
5046 }
5047 }
5048
5049 #define X_GLrop_Indexubv 194
5050 void
5051 __indirect_glIndexubv(const GLubyte *c)
5052 {
5053 __GLXcontext *const gc = __glXGetCurrentContext();
5054 const GLuint cmdlen = 8;
5055 emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
5056 (void) memcpy((void *) (gc->pc + 4), (void *) (c), 1);
5057 gc->pc += cmdlen;
5058 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5059 (void) __glXFlushRenderBuffer(gc, gc->pc);
5060 }
5061 }
5062
5063 #define X_GLrop_PolygonOffset 192
5064 void
5065 __indirect_glPolygonOffset(GLfloat factor, GLfloat units)
5066 {
5067 __GLXcontext *const gc = __glXGetCurrentContext();
5068 const GLuint cmdlen = 12;
5069 emit_header(gc->pc, X_GLrop_PolygonOffset, cmdlen);
5070 (void) memcpy((void *) (gc->pc + 4), (void *) (&factor), 4);
5071 (void) memcpy((void *) (gc->pc + 8), (void *) (&units), 4);
5072 gc->pc += cmdlen;
5073 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5074 (void) __glXFlushRenderBuffer(gc, gc->pc);
5075 }
5076 }
5077
5078 #define X_GLrop_CopyTexImage1D 4119
5079 void
5080 __indirect_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat,
5081 GLint x, GLint y, GLsizei width, GLint border)
5082 {
5083 __GLXcontext *const gc = __glXGetCurrentContext();
5084 const GLuint cmdlen = 32;
5085 emit_header(gc->pc, X_GLrop_CopyTexImage1D, cmdlen);
5086 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5087 (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4);
5088 (void) memcpy((void *) (gc->pc + 12), (void *) (&internalformat), 4);
5089 (void) memcpy((void *) (gc->pc + 16), (void *) (&x), 4);
5090 (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 4);
5091 (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4);
5092 (void) memcpy((void *) (gc->pc + 28), (void *) (&border), 4);
5093 gc->pc += cmdlen;
5094 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5095 (void) __glXFlushRenderBuffer(gc, gc->pc);
5096 }
5097 }
5098
5099 #define X_GLrop_CopyTexImage2D 4120
5100 void
5101 __indirect_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat,
5102 GLint x, GLint y, GLsizei width, GLsizei height,
5103 GLint border)
5104 {
5105 __GLXcontext *const gc = __glXGetCurrentContext();
5106 const GLuint cmdlen = 36;
5107 emit_header(gc->pc, X_GLrop_CopyTexImage2D, cmdlen);
5108 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5109 (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4);
5110 (void) memcpy((void *) (gc->pc + 12), (void *) (&internalformat), 4);
5111 (void) memcpy((void *) (gc->pc + 16), (void *) (&x), 4);
5112 (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 4);
5113 (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4);
5114 (void) memcpy((void *) (gc->pc + 28), (void *) (&height), 4);
5115 (void) memcpy((void *) (gc->pc + 32), (void *) (&border), 4);
5116 gc->pc += cmdlen;
5117 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5118 (void) __glXFlushRenderBuffer(gc, gc->pc);
5119 }
5120 }
5121
5122 #define X_GLrop_CopyTexSubImage1D 4121
5123 void
5124 __indirect_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset,
5125 GLint x, GLint y, GLsizei width)
5126 {
5127 __GLXcontext *const gc = __glXGetCurrentContext();
5128 const GLuint cmdlen = 28;
5129 emit_header(gc->pc, X_GLrop_CopyTexSubImage1D, cmdlen);
5130 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5131 (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4);
5132 (void) memcpy((void *) (gc->pc + 12), (void *) (&xoffset), 4);
5133 (void) memcpy((void *) (gc->pc + 16), (void *) (&x), 4);
5134 (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 4);
5135 (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4);
5136 gc->pc += cmdlen;
5137 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5138 (void) __glXFlushRenderBuffer(gc, gc->pc);
5139 }
5140 }
5141
5142 #define X_GLrop_CopyTexSubImage2D 4122
5143 void
5144 __indirect_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset,
5145 GLint yoffset, GLint x, GLint y, GLsizei width,
5146 GLsizei height)
5147 {
5148 __GLXcontext *const gc = __glXGetCurrentContext();
5149 const GLuint cmdlen = 36;
5150 emit_header(gc->pc, X_GLrop_CopyTexSubImage2D, cmdlen);
5151 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5152 (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4);
5153 (void) memcpy((void *) (gc->pc + 12), (void *) (&xoffset), 4);
5154 (void) memcpy((void *) (gc->pc + 16), (void *) (&yoffset), 4);
5155 (void) memcpy((void *) (gc->pc + 20), (void *) (&x), 4);
5156 (void) memcpy((void *) (gc->pc + 24), (void *) (&y), 4);
5157 (void) memcpy((void *) (gc->pc + 28), (void *) (&width), 4);
5158 (void) memcpy((void *) (gc->pc + 32), (void *) (&height), 4);
5159 gc->pc += cmdlen;
5160 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5161 (void) __glXFlushRenderBuffer(gc, gc->pc);
5162 }
5163 }
5164
5165 #define X_GLsop_DeleteTextures 144
5166 void
5167 __indirect_glDeleteTextures(GLsizei n, const GLuint * textures)
5168 {
5169 __GLXcontext *const gc = __glXGetCurrentContext();
5170 Display *const dpy = gc->currentDpy;
5171 #ifndef USE_XCB
5172 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
5173 #endif
5174 if (n < 0) {
5175 __glXSetError(gc, GL_INVALID_VALUE);
5176 return;
5177 }
5178 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5179 #ifdef USE_XCB
5180 xcb_connection_t *c = XGetXCBConnection(dpy);
5181 (void) __glXFlushRenderBuffer(gc, gc->pc);
5182 xcb_glx_delete_textures(c, gc->currentContextTag, n, textures);
5183 #else
5184 GLubyte const *pc =
5185 __glXSetupSingleRequest(gc, X_GLsop_DeleteTextures, cmdlen);
5186 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
5187 (void) memcpy((void *) (pc + 4), (void *) (textures), (n * 4));
5188 UnlockDisplay(dpy);
5189 SyncHandle();
5190 #endif /* USE_XCB */
5191 }
5192 return;
5193 }
5194
5195 #define X_GLvop_DeleteTexturesEXT 12
5196 void
5197 glDeleteTexturesEXT(GLsizei n, const GLuint * textures)
5198 {
5199 __GLXcontext *const gc = __glXGetCurrentContext();
5200
5201 if (gc->driContext) {
5202 CALL_DeleteTextures(GET_DISPATCH(), (n, textures));
5203 } else {
5204 __GLXcontext *const gc = __glXGetCurrentContext();
5205 Display *const dpy = gc->currentDpy;
5206 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
5207 if (n < 0) {
5208 __glXSetError(gc, GL_INVALID_VALUE);
5209 return;
5210 }
5211 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5212 GLubyte const *pc =
5213 __glXSetupVendorRequest(gc, X_GLXVendorPrivate,
5214 X_GLvop_DeleteTexturesEXT, cmdlen);
5215 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
5216 (void) memcpy((void *) (pc + 4), (void *) (textures), (n * 4));
5217 UnlockDisplay(dpy);
5218 SyncHandle();
5219 }
5220 return;
5221 }
5222 }
5223
5224 #define X_GLsop_GenTextures 145
5225 void
5226 __indirect_glGenTextures(GLsizei n, GLuint * textures)
5227 {
5228 __GLXcontext *const gc = __glXGetCurrentContext();
5229 Display *const dpy = gc->currentDpy;
5230 #ifndef USE_XCB
5231 const GLuint cmdlen = 4;
5232 #endif
5233 if (n < 0) {
5234 __glXSetError(gc, GL_INVALID_VALUE);
5235 return;
5236 }
5237 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5238 #ifdef USE_XCB
5239 xcb_connection_t *c = XGetXCBConnection(dpy);
5240 (void) __glXFlushRenderBuffer(gc, gc->pc);
5241 xcb_glx_gen_textures_reply_t *reply =
5242 xcb_glx_gen_textures_reply(c,
5243 xcb_glx_gen_textures(c,
5244 gc->
5245 currentContextTag,
5246 n), NULL);
5247 (void) memcpy(textures, xcb_glx_gen_textures_data(reply),
5248 xcb_glx_gen_textures_data_length(reply) *
5249 sizeof(GLuint));
5250 free(reply);
5251 #else
5252 GLubyte const *pc =
5253 __glXSetupSingleRequest(gc, X_GLsop_GenTextures, cmdlen);
5254 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
5255 (void) __glXReadReply(dpy, 4, textures, GL_TRUE);
5256 UnlockDisplay(dpy);
5257 SyncHandle();
5258 #endif /* USE_XCB */
5259 }
5260 return;
5261 }
5262
5263 #define X_GLvop_GenTexturesEXT 13
5264 void
5265 glGenTexturesEXT(GLsizei n, GLuint * textures)
5266 {
5267 __GLXcontext *const gc = __glXGetCurrentContext();
5268
5269 if (gc->driContext) {
5270 CALL_GenTextures(GET_DISPATCH(), (n, textures));
5271 } else {
5272 __GLXcontext *const gc = __glXGetCurrentContext();
5273 Display *const dpy = gc->currentDpy;
5274 const GLuint cmdlen = 4;
5275 if (n < 0) {
5276 __glXSetError(gc, GL_INVALID_VALUE);
5277 return;
5278 }
5279 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
5280 GLubyte const *pc =
5281 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
5282 X_GLvop_GenTexturesEXT, cmdlen);
5283 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
5284 (void) __glXReadReply(dpy, 4, textures, GL_TRUE);
5285 UnlockDisplay(dpy);
5286 SyncHandle();
5287 }
5288 return;
5289 }
5290 }
5291
5292 #define X_GLsop_IsTexture 146
5293 GLboolean
5294 __indirect_glIsTexture(GLuint texture)
5295 {
5296 __GLXcontext *const gc = __glXGetCurrentContext();
5297 Display *const dpy = gc->currentDpy;
5298 GLboolean retval = (GLboolean) 0;
5299 #ifndef USE_XCB
5300 const GLuint cmdlen = 4;
5301 #endif
5302 if (__builtin_expect(dpy != NULL, 1)) {
5303 #ifdef USE_XCB
5304 xcb_connection_t *c = XGetXCBConnection(dpy);
5305 (void) __glXFlushRenderBuffer(gc, gc->pc);
5306 xcb_glx_is_texture_reply_t *reply =
5307 xcb_glx_is_texture_reply(c,
5308 xcb_glx_is_texture(c,
5309 gc->currentContextTag,
5310 texture), NULL);
5311 retval = reply->ret_val;
5312 free(reply);
5313 #else
5314 GLubyte const *pc =
5315 __glXSetupSingleRequest(gc, X_GLsop_IsTexture, cmdlen);
5316 (void) memcpy((void *) (pc + 0), (void *) (&texture), 4);
5317 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
5318 UnlockDisplay(dpy);
5319 SyncHandle();
5320 #endif /* USE_XCB */
5321 }
5322 return retval;
5323 }
5324
5325 #define X_GLvop_IsTextureEXT 14
5326 GLboolean
5327 glIsTextureEXT(GLuint texture)
5328 {
5329 __GLXcontext *const gc = __glXGetCurrentContext();
5330
5331 if (gc->driContext) {
5332 return CALL_IsTexture(GET_DISPATCH(), (texture));
5333 } else {
5334 __GLXcontext *const gc = __glXGetCurrentContext();
5335 Display *const dpy = gc->currentDpy;
5336 GLboolean retval = (GLboolean) 0;
5337 const GLuint cmdlen = 4;
5338 if (__builtin_expect(dpy != NULL, 1)) {
5339 GLubyte const *pc =
5340 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
5341 X_GLvop_IsTextureEXT, cmdlen);
5342 (void) memcpy((void *) (pc + 0), (void *) (&texture), 4);
5343 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
5344 UnlockDisplay(dpy);
5345 SyncHandle();
5346 }
5347 return retval;
5348 }
5349 }
5350
5351 #define X_GLrop_PrioritizeTextures 4118
5352 void
5353 __indirect_glPrioritizeTextures(GLsizei n, const GLuint * textures,
5354 const GLclampf * priorities)
5355 {
5356 __GLXcontext *const gc = __glXGetCurrentContext();
5357 const GLuint cmdlen = 8 + __GLX_PAD((n * 4)) + __GLX_PAD((n * 4));
5358 if (n < 0) {
5359 __glXSetError(gc, GL_INVALID_VALUE);
5360 return;
5361 }
5362 if (__builtin_expect(n >= 0, 1)) {
5363 emit_header(gc->pc, X_GLrop_PrioritizeTextures, cmdlen);
5364 (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
5365 (void) memcpy((void *) (gc->pc + 8), (void *) (textures), (n * 4));
5366 (void) memcpy((void *) (gc->pc + 8 + (n * 4)), (void *) (priorities),
5367 (n * 4));
5368 gc->pc += cmdlen;
5369 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5370 (void) __glXFlushRenderBuffer(gc, gc->pc);
5371 }
5372 }
5373 }
5374
5375 static void
5376 __glx_TexSubImage_1D2D(unsigned opcode, unsigned dim, GLenum target,
5377 GLint level, GLint xoffset, GLint yoffset,
5378 GLsizei width, GLsizei height, GLenum format,
5379 GLenum type, const GLvoid * pixels)
5380 {
5381 __GLXcontext *const gc = __glXGetCurrentContext();
5382 const GLuint compsize =
5383 (pixels != NULL) ? __glImageSize(width, height, 1, format, type,
5384 target) : 0;
5385 const GLuint cmdlen = 60 + __GLX_PAD(compsize);
5386 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
5387 if (cmdlen <= gc->maxSmallRenderCommandSize) {
5388 if ((gc->pc + cmdlen) > gc->bufEnd) {
5389 (void) __glXFlushRenderBuffer(gc, gc->pc);
5390 }
5391 emit_header(gc->pc, opcode, cmdlen);
5392 (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4);
5393 (void) memcpy((void *) (gc->pc + 28), (void *) (&level), 4);
5394 (void) memcpy((void *) (gc->pc + 32), (void *) (&xoffset), 4);
5395 (void) memcpy((void *) (gc->pc + 36), (void *) (&yoffset), 4);
5396 (void) memcpy((void *) (gc->pc + 40), (void *) (&width), 4);
5397 (void) memcpy((void *) (gc->pc + 44), (void *) (&height), 4);
5398 (void) memcpy((void *) (gc->pc + 48), (void *) (&format), 4);
5399 (void) memcpy((void *) (gc->pc + 52), (void *) (&type), 4);
5400 (void) memset((void *) (gc->pc + 56), 0, 4);
5401 if (compsize > 0) {
5402 (*gc->fillImage) (gc, dim, width, height, 1, format, type,
5403 pixels, gc->pc + 60, gc->pc + 4);
5404 } else {
5405 (void) memcpy(gc->pc + 4, default_pixel_store_2D,
5406 default_pixel_store_2D_size);
5407 }
5408 gc->pc += cmdlen;
5409 if (gc->pc > gc->limit) {
5410 (void) __glXFlushRenderBuffer(gc, gc->pc);
5411 }
5412 } else {
5413 const GLint op = opcode;
5414 const GLuint cmdlenLarge = cmdlen + 4;
5415 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
5416 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
5417 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
5418 (void) memcpy((void *) (pc + 28), (void *) (&target), 4);
5419 (void) memcpy((void *) (pc + 32), (void *) (&level), 4);
5420 (void) memcpy((void *) (pc + 36), (void *) (&xoffset), 4);
5421 (void) memcpy((void *) (pc + 40), (void *) (&yoffset), 4);
5422 (void) memcpy((void *) (pc + 44), (void *) (&width), 4);
5423 (void) memcpy((void *) (pc + 48), (void *) (&height), 4);
5424 (void) memcpy((void *) (pc + 52), (void *) (&format), 4);
5425 (void) memcpy((void *) (pc + 56), (void *) (&type), 4);
5426 (void) memset((void *) (pc + 60), 0, 4);
5427 __glXSendLargeImage(gc, compsize, dim, width, height, 1, format,
5428 type, pixels, pc + 64, pc + 8);
5429 }
5430 }
5431 }
5432
5433 #define X_GLrop_TexSubImage1D 4099
5434 void
5435 __indirect_glTexSubImage1D(GLenum target, GLint level, GLint xoffset,
5436 GLsizei width, GLenum format, GLenum type,
5437 const GLvoid * pixels)
5438 {
5439 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage1D, 1, target, level, xoffset,
5440 1, width, 1, format, type, pixels);
5441 }
5442
5443 #define X_GLrop_TexSubImage2D 4100
5444 void
5445 __indirect_glTexSubImage2D(GLenum target, GLint level, GLint xoffset,
5446 GLint yoffset, GLsizei width, GLsizei height,
5447 GLenum format, GLenum type, const GLvoid * pixels)
5448 {
5449 __glx_TexSubImage_1D2D(X_GLrop_TexSubImage2D, 2, target, level, xoffset,
5450 yoffset, width, height, format, type, pixels);
5451 }
5452
5453 #define X_GLrop_BlendColor 4096
5454 void
5455 __indirect_glBlendColor(GLclampf red, GLclampf green, GLclampf blue,
5456 GLclampf alpha)
5457 {
5458 __GLXcontext *const gc = __glXGetCurrentContext();
5459 const GLuint cmdlen = 20;
5460 emit_header(gc->pc, X_GLrop_BlendColor, cmdlen);
5461 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
5462 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
5463 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
5464 (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
5465 gc->pc += cmdlen;
5466 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5467 (void) __glXFlushRenderBuffer(gc, gc->pc);
5468 }
5469 }
5470
5471 #define X_GLrop_BlendEquation 4097
5472 void
5473 __indirect_glBlendEquation(GLenum mode)
5474 {
5475 __GLXcontext *const gc = __glXGetCurrentContext();
5476 const GLuint cmdlen = 8;
5477 emit_header(gc->pc, X_GLrop_BlendEquation, cmdlen);
5478 (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
5479 gc->pc += cmdlen;
5480 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5481 (void) __glXFlushRenderBuffer(gc, gc->pc);
5482 }
5483 }
5484
5485 #define X_GLrop_ColorTable 2053
5486 void
5487 __indirect_glColorTable(GLenum target, GLenum internalformat, GLsizei width,
5488 GLenum format, GLenum type, const GLvoid * table)
5489 {
5490 __GLXcontext *const gc = __glXGetCurrentContext();
5491 const GLuint compsize =
5492 (table != NULL) ? __glImageSize(width, 1, 1, format, type,
5493 target) : 0;
5494 const GLuint cmdlen = 44 + __GLX_PAD(compsize);
5495 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
5496 if (cmdlen <= gc->maxSmallRenderCommandSize) {
5497 if ((gc->pc + cmdlen) > gc->bufEnd) {
5498 (void) __glXFlushRenderBuffer(gc, gc->pc);
5499 }
5500 emit_header(gc->pc, X_GLrop_ColorTable, cmdlen);
5501 (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4);
5502 (void) memcpy((void *) (gc->pc + 28), (void *) (&internalformat),
5503 4);
5504 (void) memcpy((void *) (gc->pc + 32), (void *) (&width), 4);
5505 (void) memcpy((void *) (gc->pc + 36), (void *) (&format), 4);
5506 (void) memcpy((void *) (gc->pc + 40), (void *) (&type), 4);
5507 if (compsize > 0) {
5508 (*gc->fillImage) (gc, 1, width, 1, 1, format, type, table,
5509 gc->pc + 44, gc->pc + 4);
5510 } else {
5511 (void) memcpy(gc->pc + 4, default_pixel_store_1D,
5512 default_pixel_store_1D_size);
5513 }
5514 gc->pc += cmdlen;
5515 if (gc->pc > gc->limit) {
5516 (void) __glXFlushRenderBuffer(gc, gc->pc);
5517 }
5518 } else {
5519 const GLint op = X_GLrop_ColorTable;
5520 const GLuint cmdlenLarge = cmdlen + 4;
5521 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
5522 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
5523 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
5524 (void) memcpy((void *) (pc + 28), (void *) (&target), 4);
5525 (void) memcpy((void *) (pc + 32), (void *) (&internalformat), 4);
5526 (void) memcpy((void *) (pc + 36), (void *) (&width), 4);
5527 (void) memcpy((void *) (pc + 40), (void *) (&format), 4);
5528 (void) memcpy((void *) (pc + 44), (void *) (&type), 4);
5529 __glXSendLargeImage(gc, compsize, 1, width, 1, 1, format, type,
5530 table, pc + 48, pc + 8);
5531 }
5532 }
5533 }
5534
5535 #define X_GLrop_ColorTableParameterfv 2054
5536 void
5537 __indirect_glColorTableParameterfv(GLenum target, GLenum pname,
5538 const GLfloat * params)
5539 {
5540 __GLXcontext *const gc = __glXGetCurrentContext();
5541 const GLuint compsize = __glColorTableParameterfv_size(pname);
5542 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
5543 emit_header(gc->pc, X_GLrop_ColorTableParameterfv, cmdlen);
5544 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5545 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
5546 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
5547 gc->pc += cmdlen;
5548 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5549 (void) __glXFlushRenderBuffer(gc, gc->pc);
5550 }
5551 }
5552
5553 #define X_GLrop_ColorTableParameteriv 2055
5554 void
5555 __indirect_glColorTableParameteriv(GLenum target, GLenum pname,
5556 const GLint * params)
5557 {
5558 __GLXcontext *const gc = __glXGetCurrentContext();
5559 const GLuint compsize = __glColorTableParameteriv_size(pname);
5560 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
5561 emit_header(gc->pc, X_GLrop_ColorTableParameteriv, cmdlen);
5562 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5563 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
5564 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
5565 gc->pc += cmdlen;
5566 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5567 (void) __glXFlushRenderBuffer(gc, gc->pc);
5568 }
5569 }
5570
5571 #define X_GLrop_CopyColorTable 2056
5572 void
5573 __indirect_glCopyColorTable(GLenum target, GLenum internalformat, GLint x,
5574 GLint y, GLsizei width)
5575 {
5576 __GLXcontext *const gc = __glXGetCurrentContext();
5577 const GLuint cmdlen = 24;
5578 emit_header(gc->pc, X_GLrop_CopyColorTable, cmdlen);
5579 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5580 (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4);
5581 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
5582 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
5583 (void) memcpy((void *) (gc->pc + 20), (void *) (&width), 4);
5584 gc->pc += cmdlen;
5585 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5586 (void) __glXFlushRenderBuffer(gc, gc->pc);
5587 }
5588 }
5589
5590 #define X_GLsop_GetColorTable 147
5591 void
5592 __indirect_glGetColorTable(GLenum target, GLenum format, GLenum type,
5593 GLvoid * table)
5594 {
5595 __GLXcontext *const gc = __glXGetCurrentContext();
5596 const __GLXattribute *const state = gc->client_state_private;
5597 Display *const dpy = gc->currentDpy;
5598 #ifndef USE_XCB
5599 const GLuint cmdlen = 16;
5600 #endif
5601 if (__builtin_expect(dpy != NULL, 1)) {
5602 #ifdef USE_XCB
5603 xcb_connection_t *c = XGetXCBConnection(dpy);
5604 (void) __glXFlushRenderBuffer(gc, gc->pc);
5605 xcb_glx_get_color_table_reply_t *reply =
5606 xcb_glx_get_color_table_reply(c,
5607 xcb_glx_get_color_table(c,
5608 gc->
5609 currentContextTag,
5610 target,
5611 format,
5612 type,
5613 state->
5614 storePack.
5615 swapEndian),
5616 NULL);
5617 (void) memcpy(table, xcb_glx_get_color_table_data(reply),
5618 xcb_glx_get_color_table_data_length(reply) *
5619 sizeof(GLvoid));
5620 free(reply);
5621 #else
5622 GLubyte const *pc =
5623 __glXSetupSingleRequest(gc, X_GLsop_GetColorTable, cmdlen);
5624 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
5625 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
5626 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
5627 *(int32_t *) (pc + 12) = 0;
5628 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
5629 __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, table,
5630 GL_TRUE);
5631 UnlockDisplay(dpy);
5632 SyncHandle();
5633 #endif /* USE_XCB */
5634 }
5635 return;
5636 }
5637
5638 #define X_GLvop_GetColorTableSGI 4098
5639 void
5640 glGetColorTableEXT(GLenum target, GLenum format, GLenum type, GLvoid * table)
5641 {
5642 __GLXcontext *const gc = __glXGetCurrentContext();
5643
5644 if (gc->driContext) {
5645 CALL_GetColorTable(GET_DISPATCH(), (target, format, type, table));
5646 } else {
5647 __GLXcontext *const gc = __glXGetCurrentContext();
5648 const __GLXattribute *const state = gc->client_state_private;
5649 Display *const dpy = gc->currentDpy;
5650 const GLuint cmdlen = 16;
5651 if (__builtin_expect(dpy != NULL, 1)) {
5652 GLubyte const *pc =
5653 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
5654 X_GLvop_GetColorTableSGI, cmdlen);
5655 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
5656 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
5657 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
5658 *(int32_t *) (pc + 12) = 0;
5659 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
5660 __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, table,
5661 GL_TRUE);
5662 UnlockDisplay(dpy);
5663 SyncHandle();
5664 }
5665 return;
5666 }
5667 }
5668
5669 #define X_GLsop_GetColorTableParameterfv 148
5670 void
5671 __indirect_glGetColorTableParameterfv(GLenum target, GLenum pname,
5672 GLfloat * params)
5673 {
5674 __GLXcontext *const gc = __glXGetCurrentContext();
5675 Display *const dpy = gc->currentDpy;
5676 #ifndef USE_XCB
5677 const GLuint cmdlen = 8;
5678 #endif
5679 if (__builtin_expect(dpy != NULL, 1)) {
5680 #ifdef USE_XCB
5681 xcb_connection_t *c = XGetXCBConnection(dpy);
5682 (void) __glXFlushRenderBuffer(gc, gc->pc);
5683 xcb_glx_get_color_table_parameterfv_reply_t *reply =
5684 xcb_glx_get_color_table_parameterfv_reply(c,
5685 xcb_glx_get_color_table_parameterfv
5686 (c,
5687 gc->currentContextTag,
5688 target, pname), NULL);
5689 if (xcb_glx_get_color_table_parameterfv_data_length(reply) == 0)
5690 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
5691 else
5692 (void) memcpy(params,
5693 xcb_glx_get_color_table_parameterfv_data(reply),
5694 xcb_glx_get_color_table_parameterfv_data_length
5695 (reply) * sizeof(GLfloat));
5696 free(reply);
5697 #else
5698 GLubyte const *pc =
5699 __glXSetupSingleRequest(gc, X_GLsop_GetColorTableParameterfv,
5700 cmdlen);
5701 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
5702 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
5703 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5704 UnlockDisplay(dpy);
5705 SyncHandle();
5706 #endif /* USE_XCB */
5707 }
5708 return;
5709 }
5710
5711 #define X_GLvop_GetColorTableParameterfvSGI 4099
5712 void
5713 glGetColorTableParameterfvEXT(GLenum target, GLenum pname, GLfloat * params)
5714 {
5715 __GLXcontext *const gc = __glXGetCurrentContext();
5716
5717 if (gc->driContext) {
5718 CALL_GetColorTableParameterfv(GET_DISPATCH(),
5719 (target, pname, params));
5720 } else {
5721 __GLXcontext *const gc = __glXGetCurrentContext();
5722 Display *const dpy = gc->currentDpy;
5723 const GLuint cmdlen = 8;
5724 if (__builtin_expect(dpy != NULL, 1)) {
5725 GLubyte const *pc =
5726 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
5727 X_GLvop_GetColorTableParameterfvSGI,
5728 cmdlen);
5729 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
5730 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
5731 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5732 UnlockDisplay(dpy);
5733 SyncHandle();
5734 }
5735 return;
5736 }
5737 }
5738
5739 #define X_GLsop_GetColorTableParameteriv 149
5740 void
5741 __indirect_glGetColorTableParameteriv(GLenum target, GLenum pname,
5742 GLint * params)
5743 {
5744 __GLXcontext *const gc = __glXGetCurrentContext();
5745 Display *const dpy = gc->currentDpy;
5746 #ifndef USE_XCB
5747 const GLuint cmdlen = 8;
5748 #endif
5749 if (__builtin_expect(dpy != NULL, 1)) {
5750 #ifdef USE_XCB
5751 xcb_connection_t *c = XGetXCBConnection(dpy);
5752 (void) __glXFlushRenderBuffer(gc, gc->pc);
5753 xcb_glx_get_color_table_parameteriv_reply_t *reply =
5754 xcb_glx_get_color_table_parameteriv_reply(c,
5755 xcb_glx_get_color_table_parameteriv
5756 (c,
5757 gc->currentContextTag,
5758 target, pname), NULL);
5759 if (xcb_glx_get_color_table_parameteriv_data_length(reply) == 0)
5760 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
5761 else
5762 (void) memcpy(params,
5763 xcb_glx_get_color_table_parameteriv_data(reply),
5764 xcb_glx_get_color_table_parameteriv_data_length
5765 (reply) * sizeof(GLint));
5766 free(reply);
5767 #else
5768 GLubyte const *pc =
5769 __glXSetupSingleRequest(gc, X_GLsop_GetColorTableParameteriv,
5770 cmdlen);
5771 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
5772 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
5773 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5774 UnlockDisplay(dpy);
5775 SyncHandle();
5776 #endif /* USE_XCB */
5777 }
5778 return;
5779 }
5780
5781 #define X_GLvop_GetColorTableParameterivSGI 4100
5782 void
5783 glGetColorTableParameterivEXT(GLenum target, GLenum pname, GLint * params)
5784 {
5785 __GLXcontext *const gc = __glXGetCurrentContext();
5786
5787 if (gc->driContext) {
5788 CALL_GetColorTableParameteriv(GET_DISPATCH(),
5789 (target, pname, params));
5790 } else {
5791 __GLXcontext *const gc = __glXGetCurrentContext();
5792 Display *const dpy = gc->currentDpy;
5793 const GLuint cmdlen = 8;
5794 if (__builtin_expect(dpy != NULL, 1)) {
5795 GLubyte const *pc =
5796 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
5797 X_GLvop_GetColorTableParameterivSGI,
5798 cmdlen);
5799 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
5800 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
5801 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
5802 UnlockDisplay(dpy);
5803 SyncHandle();
5804 }
5805 return;
5806 }
5807 }
5808
5809 #define X_GLrop_ColorSubTable 195
5810 void
5811 __indirect_glColorSubTable(GLenum target, GLsizei start, GLsizei count,
5812 GLenum format, GLenum type, const GLvoid * data)
5813 {
5814 __GLXcontext *const gc = __glXGetCurrentContext();
5815 const GLuint compsize =
5816 (data != NULL) ? __glImageSize(count, 1, 1, format, type, target) : 0;
5817 const GLuint cmdlen = 44 + __GLX_PAD(compsize);
5818 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
5819 if (cmdlen <= gc->maxSmallRenderCommandSize) {
5820 if ((gc->pc + cmdlen) > gc->bufEnd) {
5821 (void) __glXFlushRenderBuffer(gc, gc->pc);
5822 }
5823 emit_header(gc->pc, X_GLrop_ColorSubTable, cmdlen);
5824 (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4);
5825 (void) memcpy((void *) (gc->pc + 28), (void *) (&start), 4);
5826 (void) memcpy((void *) (gc->pc + 32), (void *) (&count), 4);
5827 (void) memcpy((void *) (gc->pc + 36), (void *) (&format), 4);
5828 (void) memcpy((void *) (gc->pc + 40), (void *) (&type), 4);
5829 if (compsize > 0) {
5830 (*gc->fillImage) (gc, 1, count, 1, 1, format, type, data,
5831 gc->pc + 44, gc->pc + 4);
5832 } else {
5833 (void) memcpy(gc->pc + 4, default_pixel_store_1D,
5834 default_pixel_store_1D_size);
5835 }
5836 gc->pc += cmdlen;
5837 if (gc->pc > gc->limit) {
5838 (void) __glXFlushRenderBuffer(gc, gc->pc);
5839 }
5840 } else {
5841 const GLint op = X_GLrop_ColorSubTable;
5842 const GLuint cmdlenLarge = cmdlen + 4;
5843 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
5844 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
5845 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
5846 (void) memcpy((void *) (pc + 28), (void *) (&target), 4);
5847 (void) memcpy((void *) (pc + 32), (void *) (&start), 4);
5848 (void) memcpy((void *) (pc + 36), (void *) (&count), 4);
5849 (void) memcpy((void *) (pc + 40), (void *) (&format), 4);
5850 (void) memcpy((void *) (pc + 44), (void *) (&type), 4);
5851 __glXSendLargeImage(gc, compsize, 1, count, 1, 1, format, type,
5852 data, pc + 48, pc + 8);
5853 }
5854 }
5855 }
5856
5857 #define X_GLrop_CopyColorSubTable 196
5858 void
5859 __indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y,
5860 GLsizei width)
5861 {
5862 __GLXcontext *const gc = __glXGetCurrentContext();
5863 const GLuint cmdlen = 24;
5864 emit_header(gc->pc, X_GLrop_CopyColorSubTable, cmdlen);
5865 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5866 (void) memcpy((void *) (gc->pc + 8), (void *) (&start), 4);
5867 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
5868 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
5869 (void) memcpy((void *) (gc->pc + 20), (void *) (&width), 4);
5870 gc->pc += cmdlen;
5871 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5872 (void) __glXFlushRenderBuffer(gc, gc->pc);
5873 }
5874 }
5875
5876 static void
5877 __glx_ConvolutionFilter_1D2D(unsigned opcode, unsigned dim, GLenum target,
5878 GLenum internalformat, GLsizei width,
5879 GLsizei height, GLenum format, GLenum type,
5880 const GLvoid * image)
5881 {
5882 __GLXcontext *const gc = __glXGetCurrentContext();
5883 const GLuint compsize =
5884 (image != NULL) ? __glImageSize(width, height, 1, format, type,
5885 target) : 0;
5886 const GLuint cmdlen = 48 + __GLX_PAD(compsize);
5887 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
5888 if (cmdlen <= gc->maxSmallRenderCommandSize) {
5889 if ((gc->pc + cmdlen) > gc->bufEnd) {
5890 (void) __glXFlushRenderBuffer(gc, gc->pc);
5891 }
5892 emit_header(gc->pc, opcode, cmdlen);
5893 (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4);
5894 (void) memcpy((void *) (gc->pc + 28), (void *) (&internalformat),
5895 4);
5896 (void) memcpy((void *) (gc->pc + 32), (void *) (&width), 4);
5897 (void) memcpy((void *) (gc->pc + 36), (void *) (&height), 4);
5898 (void) memcpy((void *) (gc->pc + 40), (void *) (&format), 4);
5899 (void) memcpy((void *) (gc->pc + 44), (void *) (&type), 4);
5900 if (compsize > 0) {
5901 (*gc->fillImage) (gc, dim, width, height, 1, format, type,
5902 image, gc->pc + 48, gc->pc + 4);
5903 } else {
5904 (void) memcpy(gc->pc + 4, default_pixel_store_2D,
5905 default_pixel_store_2D_size);
5906 }
5907 gc->pc += cmdlen;
5908 if (gc->pc > gc->limit) {
5909 (void) __glXFlushRenderBuffer(gc, gc->pc);
5910 }
5911 } else {
5912 const GLint op = opcode;
5913 const GLuint cmdlenLarge = cmdlen + 4;
5914 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
5915 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
5916 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
5917 (void) memcpy((void *) (pc + 28), (void *) (&target), 4);
5918 (void) memcpy((void *) (pc + 32), (void *) (&internalformat), 4);
5919 (void) memcpy((void *) (pc + 36), (void *) (&width), 4);
5920 (void) memcpy((void *) (pc + 40), (void *) (&height), 4);
5921 (void) memcpy((void *) (pc + 44), (void *) (&format), 4);
5922 (void) memcpy((void *) (pc + 48), (void *) (&type), 4);
5923 __glXSendLargeImage(gc, compsize, dim, width, height, 1, format,
5924 type, image, pc + 52, pc + 8);
5925 }
5926 }
5927 }
5928
5929 #define X_GLrop_ConvolutionFilter1D 4101
5930 void
5931 __indirect_glConvolutionFilter1D(GLenum target, GLenum internalformat,
5932 GLsizei width, GLenum format, GLenum type,
5933 const GLvoid * image)
5934 {
5935 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter1D, 1, target,
5936 internalformat, width, 1, format, type,
5937 image);
5938 }
5939
5940 #define X_GLrop_ConvolutionFilter2D 4102
5941 void
5942 __indirect_glConvolutionFilter2D(GLenum target, GLenum internalformat,
5943 GLsizei width, GLsizei height, GLenum format,
5944 GLenum type, const GLvoid * image)
5945 {
5946 __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter2D, 2, target,
5947 internalformat, width, height, format, type,
5948 image);
5949 }
5950
5951 #define X_GLrop_ConvolutionParameterf 4103
5952 void
5953 __indirect_glConvolutionParameterf(GLenum target, GLenum pname,
5954 GLfloat params)
5955 {
5956 __GLXcontext *const gc = __glXGetCurrentContext();
5957 const GLuint cmdlen = 16;
5958 emit_header(gc->pc, X_GLrop_ConvolutionParameterf, cmdlen);
5959 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5960 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
5961 (void) memcpy((void *) (gc->pc + 12), (void *) (&params), 4);
5962 gc->pc += cmdlen;
5963 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5964 (void) __glXFlushRenderBuffer(gc, gc->pc);
5965 }
5966 }
5967
5968 #define X_GLrop_ConvolutionParameterfv 4104
5969 void
5970 __indirect_glConvolutionParameterfv(GLenum target, GLenum pname,
5971 const GLfloat * params)
5972 {
5973 __GLXcontext *const gc = __glXGetCurrentContext();
5974 const GLuint compsize = __glConvolutionParameterfv_size(pname);
5975 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
5976 emit_header(gc->pc, X_GLrop_ConvolutionParameterfv, cmdlen);
5977 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5978 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
5979 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
5980 gc->pc += cmdlen;
5981 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5982 (void) __glXFlushRenderBuffer(gc, gc->pc);
5983 }
5984 }
5985
5986 #define X_GLrop_ConvolutionParameteri 4105
5987 void
5988 __indirect_glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
5989 {
5990 __GLXcontext *const gc = __glXGetCurrentContext();
5991 const GLuint cmdlen = 16;
5992 emit_header(gc->pc, X_GLrop_ConvolutionParameteri, cmdlen);
5993 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
5994 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
5995 (void) memcpy((void *) (gc->pc + 12), (void *) (&params), 4);
5996 gc->pc += cmdlen;
5997 if (__builtin_expect(gc->pc > gc->limit, 0)) {
5998 (void) __glXFlushRenderBuffer(gc, gc->pc);
5999 }
6000 }
6001
6002 #define X_GLrop_ConvolutionParameteriv 4106
6003 void
6004 __indirect_glConvolutionParameteriv(GLenum target, GLenum pname,
6005 const GLint * params)
6006 {
6007 __GLXcontext *const gc = __glXGetCurrentContext();
6008 const GLuint compsize = __glConvolutionParameteriv_size(pname);
6009 const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
6010 emit_header(gc->pc, X_GLrop_ConvolutionParameteriv, cmdlen);
6011 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6012 (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
6013 (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
6014 gc->pc += cmdlen;
6015 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6016 (void) __glXFlushRenderBuffer(gc, gc->pc);
6017 }
6018 }
6019
6020 #define X_GLrop_CopyConvolutionFilter1D 4107
6021 void
6022 __indirect_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat,
6023 GLint x, GLint y, GLsizei width)
6024 {
6025 __GLXcontext *const gc = __glXGetCurrentContext();
6026 const GLuint cmdlen = 24;
6027 emit_header(gc->pc, X_GLrop_CopyConvolutionFilter1D, cmdlen);
6028 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6029 (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4);
6030 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
6031 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
6032 (void) memcpy((void *) (gc->pc + 20), (void *) (&width), 4);
6033 gc->pc += cmdlen;
6034 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6035 (void) __glXFlushRenderBuffer(gc, gc->pc);
6036 }
6037 }
6038
6039 #define X_GLrop_CopyConvolutionFilter2D 4108
6040 void
6041 __indirect_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat,
6042 GLint x, GLint y, GLsizei width,
6043 GLsizei height)
6044 {
6045 __GLXcontext *const gc = __glXGetCurrentContext();
6046 const GLuint cmdlen = 28;
6047 emit_header(gc->pc, X_GLrop_CopyConvolutionFilter2D, cmdlen);
6048 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6049 (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4);
6050 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
6051 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
6052 (void) memcpy((void *) (gc->pc + 20), (void *) (&width), 4);
6053 (void) memcpy((void *) (gc->pc + 24), (void *) (&height), 4);
6054 gc->pc += cmdlen;
6055 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6056 (void) __glXFlushRenderBuffer(gc, gc->pc);
6057 }
6058 }
6059
6060 #define X_GLsop_GetConvolutionFilter 150
6061 void
6062 __indirect_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type,
6063 GLvoid * image)
6064 {
6065 __GLXcontext *const gc = __glXGetCurrentContext();
6066 const __GLXattribute *const state = gc->client_state_private;
6067 Display *const dpy = gc->currentDpy;
6068 #ifndef USE_XCB
6069 const GLuint cmdlen = 16;
6070 #endif
6071 if (__builtin_expect(dpy != NULL, 1)) {
6072 #ifdef USE_XCB
6073 xcb_connection_t *c = XGetXCBConnection(dpy);
6074 (void) __glXFlushRenderBuffer(gc, gc->pc);
6075 xcb_glx_get_convolution_filter_reply_t *reply =
6076 xcb_glx_get_convolution_filter_reply(c,
6077 xcb_glx_get_convolution_filter
6078 (c, gc->currentContextTag,
6079 target, format, type,
6080 state->storePack.
6081 swapEndian), NULL);
6082 (void) memcpy(image, xcb_glx_get_convolution_filter_data(reply),
6083 xcb_glx_get_convolution_filter_data_length(reply) *
6084 sizeof(GLvoid));
6085 free(reply);
6086 #else
6087 GLubyte const *pc =
6088 __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionFilter, cmdlen);
6089 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6090 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
6091 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
6092 *(int32_t *) (pc + 12) = 0;
6093 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
6094 __glXReadPixelReply(dpy, gc, 2, 0, 0, 0, format, type, image,
6095 GL_TRUE);
6096 UnlockDisplay(dpy);
6097 SyncHandle();
6098 #endif /* USE_XCB */
6099 }
6100 return;
6101 }
6102
6103 #define X_GLvop_GetConvolutionFilterEXT 1
6104 void
6105 gl_dispatch_stub_356(GLenum target, GLenum format, GLenum type,
6106 GLvoid * image)
6107 {
6108 __GLXcontext *const gc = __glXGetCurrentContext();
6109
6110 if (gc->driContext) {
6111 CALL_GetConvolutionFilter(GET_DISPATCH(),
6112 (target, format, type, image));
6113 } else {
6114 __GLXcontext *const gc = __glXGetCurrentContext();
6115 const __GLXattribute *const state = gc->client_state_private;
6116 Display *const dpy = gc->currentDpy;
6117 const GLuint cmdlen = 16;
6118 if (__builtin_expect(dpy != NULL, 1)) {
6119 GLubyte const *pc =
6120 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6121 X_GLvop_GetConvolutionFilterEXT,
6122 cmdlen);
6123 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6124 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
6125 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
6126 *(int32_t *) (pc + 12) = 0;
6127 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
6128 __glXReadPixelReply(dpy, gc, 2, 0, 0, 0, format, type, image,
6129 GL_TRUE);
6130 UnlockDisplay(dpy);
6131 SyncHandle();
6132 }
6133 return;
6134 }
6135 }
6136
6137 #define X_GLsop_GetConvolutionParameterfv 151
6138 void
6139 __indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname,
6140 GLfloat * params)
6141 {
6142 __GLXcontext *const gc = __glXGetCurrentContext();
6143 Display *const dpy = gc->currentDpy;
6144 #ifndef USE_XCB
6145 const GLuint cmdlen = 8;
6146 #endif
6147 if (__builtin_expect(dpy != NULL, 1)) {
6148 #ifdef USE_XCB
6149 xcb_connection_t *c = XGetXCBConnection(dpy);
6150 (void) __glXFlushRenderBuffer(gc, gc->pc);
6151 xcb_glx_get_convolution_parameterfv_reply_t *reply =
6152 xcb_glx_get_convolution_parameterfv_reply(c,
6153 xcb_glx_get_convolution_parameterfv
6154 (c,
6155 gc->currentContextTag,
6156 target, pname), NULL);
6157 if (xcb_glx_get_convolution_parameterfv_data_length(reply) == 0)
6158 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
6159 else
6160 (void) memcpy(params,
6161 xcb_glx_get_convolution_parameterfv_data(reply),
6162 xcb_glx_get_convolution_parameterfv_data_length
6163 (reply) * sizeof(GLfloat));
6164 free(reply);
6165 #else
6166 GLubyte const *pc =
6167 __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionParameterfv,
6168 cmdlen);
6169 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6170 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6171 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6172 UnlockDisplay(dpy);
6173 SyncHandle();
6174 #endif /* USE_XCB */
6175 }
6176 return;
6177 }
6178
6179 #define X_GLvop_GetConvolutionParameterfvEXT 2
6180 void
6181 gl_dispatch_stub_357(GLenum target, GLenum pname, GLfloat * params)
6182 {
6183 __GLXcontext *const gc = __glXGetCurrentContext();
6184
6185 if (gc->driContext) {
6186 CALL_GetConvolutionParameterfv(GET_DISPATCH(),
6187 (target, pname, params));
6188 } else {
6189 __GLXcontext *const gc = __glXGetCurrentContext();
6190 Display *const dpy = gc->currentDpy;
6191 const GLuint cmdlen = 8;
6192 if (__builtin_expect(dpy != NULL, 1)) {
6193 GLubyte const *pc =
6194 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6195 X_GLvop_GetConvolutionParameterfvEXT,
6196 cmdlen);
6197 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6198 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6199 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6200 UnlockDisplay(dpy);
6201 SyncHandle();
6202 }
6203 return;
6204 }
6205 }
6206
6207 #define X_GLsop_GetConvolutionParameteriv 152
6208 void
6209 __indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname,
6210 GLint * params)
6211 {
6212 __GLXcontext *const gc = __glXGetCurrentContext();
6213 Display *const dpy = gc->currentDpy;
6214 #ifndef USE_XCB
6215 const GLuint cmdlen = 8;
6216 #endif
6217 if (__builtin_expect(dpy != NULL, 1)) {
6218 #ifdef USE_XCB
6219 xcb_connection_t *c = XGetXCBConnection(dpy);
6220 (void) __glXFlushRenderBuffer(gc, gc->pc);
6221 xcb_glx_get_convolution_parameteriv_reply_t *reply =
6222 xcb_glx_get_convolution_parameteriv_reply(c,
6223 xcb_glx_get_convolution_parameteriv
6224 (c,
6225 gc->currentContextTag,
6226 target, pname), NULL);
6227 if (xcb_glx_get_convolution_parameteriv_data_length(reply) == 0)
6228 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
6229 else
6230 (void) memcpy(params,
6231 xcb_glx_get_convolution_parameteriv_data(reply),
6232 xcb_glx_get_convolution_parameteriv_data_length
6233 (reply) * sizeof(GLint));
6234 free(reply);
6235 #else
6236 GLubyte const *pc =
6237 __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionParameteriv,
6238 cmdlen);
6239 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6240 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6241 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6242 UnlockDisplay(dpy);
6243 SyncHandle();
6244 #endif /* USE_XCB */
6245 }
6246 return;
6247 }
6248
6249 #define X_GLvop_GetConvolutionParameterivEXT 3
6250 void
6251 gl_dispatch_stub_358(GLenum target, GLenum pname, GLint * params)
6252 {
6253 __GLXcontext *const gc = __glXGetCurrentContext();
6254
6255 if (gc->driContext) {
6256 CALL_GetConvolutionParameteriv(GET_DISPATCH(),
6257 (target, pname, params));
6258 } else {
6259 __GLXcontext *const gc = __glXGetCurrentContext();
6260 Display *const dpy = gc->currentDpy;
6261 const GLuint cmdlen = 8;
6262 if (__builtin_expect(dpy != NULL, 1)) {
6263 GLubyte const *pc =
6264 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6265 X_GLvop_GetConvolutionParameterivEXT,
6266 cmdlen);
6267 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6268 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6269 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6270 UnlockDisplay(dpy);
6271 SyncHandle();
6272 }
6273 return;
6274 }
6275 }
6276
6277 #define X_GLsop_GetHistogram 154
6278 void
6279 __indirect_glGetHistogram(GLenum target, GLboolean reset, GLenum format,
6280 GLenum type, GLvoid * values)
6281 {
6282 __GLXcontext *const gc = __glXGetCurrentContext();
6283 const __GLXattribute *const state = gc->client_state_private;
6284 Display *const dpy = gc->currentDpy;
6285 #ifndef USE_XCB
6286 const GLuint cmdlen = 16;
6287 #endif
6288 if (__builtin_expect(dpy != NULL, 1)) {
6289 #ifdef USE_XCB
6290 xcb_connection_t *c = XGetXCBConnection(dpy);
6291 (void) __glXFlushRenderBuffer(gc, gc->pc);
6292 xcb_glx_get_histogram_reply_t *reply =
6293 xcb_glx_get_histogram_reply(c,
6294 xcb_glx_get_histogram(c,
6295 gc->
6296 currentContextTag,
6297 target, reset,
6298 format, type,
6299 state->
6300 storePack.
6301 swapEndian),
6302 NULL);
6303 (void) memcpy(values, xcb_glx_get_histogram_data(reply),
6304 xcb_glx_get_histogram_data_length(reply) *
6305 sizeof(GLvoid));
6306 free(reply);
6307 #else
6308 GLubyte const *pc =
6309 __glXSetupSingleRequest(gc, X_GLsop_GetHistogram, cmdlen);
6310 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6311 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
6312 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
6313 *(int32_t *) (pc + 12) = 0;
6314 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
6315 *(int8_t *) (pc + 13) = reset;
6316 __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, values,
6317 GL_TRUE);
6318 UnlockDisplay(dpy);
6319 SyncHandle();
6320 #endif /* USE_XCB */
6321 }
6322 return;
6323 }
6324
6325 #define X_GLvop_GetHistogramEXT 5
6326 void
6327 gl_dispatch_stub_361(GLenum target, GLboolean reset, GLenum format,
6328 GLenum type, GLvoid * values)
6329 {
6330 __GLXcontext *const gc = __glXGetCurrentContext();
6331
6332 if (gc->driContext) {
6333 CALL_GetHistogram(GET_DISPATCH(),
6334 (target, reset, format, type, values));
6335 } else {
6336 __GLXcontext *const gc = __glXGetCurrentContext();
6337 const __GLXattribute *const state = gc->client_state_private;
6338 Display *const dpy = gc->currentDpy;
6339 const GLuint cmdlen = 16;
6340 if (__builtin_expect(dpy != NULL, 1)) {
6341 GLubyte const *pc =
6342 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6343 X_GLvop_GetHistogramEXT, cmdlen);
6344 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6345 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
6346 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
6347 *(int32_t *) (pc + 12) = 0;
6348 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
6349 *(int8_t *) (pc + 13) = reset;
6350 __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, values,
6351 GL_TRUE);
6352 UnlockDisplay(dpy);
6353 SyncHandle();
6354 }
6355 return;
6356 }
6357 }
6358
6359 #define X_GLsop_GetHistogramParameterfv 155
6360 void
6361 __indirect_glGetHistogramParameterfv(GLenum target, GLenum pname,
6362 GLfloat * params)
6363 {
6364 __GLXcontext *const gc = __glXGetCurrentContext();
6365 Display *const dpy = gc->currentDpy;
6366 #ifndef USE_XCB
6367 const GLuint cmdlen = 8;
6368 #endif
6369 if (__builtin_expect(dpy != NULL, 1)) {
6370 #ifdef USE_XCB
6371 xcb_connection_t *c = XGetXCBConnection(dpy);
6372 (void) __glXFlushRenderBuffer(gc, gc->pc);
6373 xcb_glx_get_histogram_parameterfv_reply_t *reply =
6374 xcb_glx_get_histogram_parameterfv_reply(c,
6375 xcb_glx_get_histogram_parameterfv
6376 (c, gc->currentContextTag,
6377 target, pname), NULL);
6378 if (xcb_glx_get_histogram_parameterfv_data_length(reply) == 0)
6379 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
6380 else
6381 (void) memcpy(params,
6382 xcb_glx_get_histogram_parameterfv_data(reply),
6383 xcb_glx_get_histogram_parameterfv_data_length(reply)
6384 * sizeof(GLfloat));
6385 free(reply);
6386 #else
6387 GLubyte const *pc =
6388 __glXSetupSingleRequest(gc, X_GLsop_GetHistogramParameterfv,
6389 cmdlen);
6390 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6391 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6392 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6393 UnlockDisplay(dpy);
6394 SyncHandle();
6395 #endif /* USE_XCB */
6396 }
6397 return;
6398 }
6399
6400 #define X_GLvop_GetHistogramParameterfvEXT 6
6401 void
6402 gl_dispatch_stub_362(GLenum target, GLenum pname, GLfloat * params)
6403 {
6404 __GLXcontext *const gc = __glXGetCurrentContext();
6405
6406 if (gc->driContext) {
6407 CALL_GetHistogramParameterfv(GET_DISPATCH(), (target, pname, params));
6408 } else {
6409 __GLXcontext *const gc = __glXGetCurrentContext();
6410 Display *const dpy = gc->currentDpy;
6411 const GLuint cmdlen = 8;
6412 if (__builtin_expect(dpy != NULL, 1)) {
6413 GLubyte const *pc =
6414 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6415 X_GLvop_GetHistogramParameterfvEXT,
6416 cmdlen);
6417 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6418 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6419 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6420 UnlockDisplay(dpy);
6421 SyncHandle();
6422 }
6423 return;
6424 }
6425 }
6426
6427 #define X_GLsop_GetHistogramParameteriv 156
6428 void
6429 __indirect_glGetHistogramParameteriv(GLenum target, GLenum pname,
6430 GLint * params)
6431 {
6432 __GLXcontext *const gc = __glXGetCurrentContext();
6433 Display *const dpy = gc->currentDpy;
6434 #ifndef USE_XCB
6435 const GLuint cmdlen = 8;
6436 #endif
6437 if (__builtin_expect(dpy != NULL, 1)) {
6438 #ifdef USE_XCB
6439 xcb_connection_t *c = XGetXCBConnection(dpy);
6440 (void) __glXFlushRenderBuffer(gc, gc->pc);
6441 xcb_glx_get_histogram_parameteriv_reply_t *reply =
6442 xcb_glx_get_histogram_parameteriv_reply(c,
6443 xcb_glx_get_histogram_parameteriv
6444 (c, gc->currentContextTag,
6445 target, pname), NULL);
6446 if (xcb_glx_get_histogram_parameteriv_data_length(reply) == 0)
6447 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
6448 else
6449 (void) memcpy(params,
6450 xcb_glx_get_histogram_parameteriv_data(reply),
6451 xcb_glx_get_histogram_parameteriv_data_length(reply)
6452 * sizeof(GLint));
6453 free(reply);
6454 #else
6455 GLubyte const *pc =
6456 __glXSetupSingleRequest(gc, X_GLsop_GetHistogramParameteriv,
6457 cmdlen);
6458 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6459 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6460 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6461 UnlockDisplay(dpy);
6462 SyncHandle();
6463 #endif /* USE_XCB */
6464 }
6465 return;
6466 }
6467
6468 #define X_GLvop_GetHistogramParameterivEXT 7
6469 void
6470 gl_dispatch_stub_363(GLenum target, GLenum pname, GLint * params)
6471 {
6472 __GLXcontext *const gc = __glXGetCurrentContext();
6473
6474 if (gc->driContext) {
6475 CALL_GetHistogramParameteriv(GET_DISPATCH(), (target, pname, params));
6476 } else {
6477 __GLXcontext *const gc = __glXGetCurrentContext();
6478 Display *const dpy = gc->currentDpy;
6479 const GLuint cmdlen = 8;
6480 if (__builtin_expect(dpy != NULL, 1)) {
6481 GLubyte const *pc =
6482 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6483 X_GLvop_GetHistogramParameterivEXT,
6484 cmdlen);
6485 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6486 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6487 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6488 UnlockDisplay(dpy);
6489 SyncHandle();
6490 }
6491 return;
6492 }
6493 }
6494
6495 #define X_GLsop_GetMinmax 157
6496 void
6497 __indirect_glGetMinmax(GLenum target, GLboolean reset, GLenum format,
6498 GLenum type, GLvoid * values)
6499 {
6500 __GLXcontext *const gc = __glXGetCurrentContext();
6501 const __GLXattribute *const state = gc->client_state_private;
6502 Display *const dpy = gc->currentDpy;
6503 #ifndef USE_XCB
6504 const GLuint cmdlen = 16;
6505 #endif
6506 if (__builtin_expect(dpy != NULL, 1)) {
6507 #ifdef USE_XCB
6508 xcb_connection_t *c = XGetXCBConnection(dpy);
6509 (void) __glXFlushRenderBuffer(gc, gc->pc);
6510 xcb_glx_get_minmax_reply_t *reply =
6511 xcb_glx_get_minmax_reply(c,
6512 xcb_glx_get_minmax(c,
6513 gc->currentContextTag,
6514 target, reset, format,
6515 type,
6516 state->storePack.
6517 swapEndian), NULL);
6518 (void) memcpy(values, xcb_glx_get_minmax_data(reply),
6519 xcb_glx_get_minmax_data_length(reply) * sizeof(GLvoid));
6520 free(reply);
6521 #else
6522 GLubyte const *pc =
6523 __glXSetupSingleRequest(gc, X_GLsop_GetMinmax, cmdlen);
6524 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6525 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
6526 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
6527 *(int32_t *) (pc + 12) = 0;
6528 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
6529 *(int8_t *) (pc + 13) = reset;
6530 __glXReadPixelReply(dpy, gc, 1, 2, 1, 1, format, type, values,
6531 GL_FALSE);
6532 UnlockDisplay(dpy);
6533 SyncHandle();
6534 #endif /* USE_XCB */
6535 }
6536 return;
6537 }
6538
6539 #define X_GLvop_GetMinmaxEXT 8
6540 void
6541 gl_dispatch_stub_364(GLenum target, GLboolean reset, GLenum format,
6542 GLenum type, GLvoid * values)
6543 {
6544 __GLXcontext *const gc = __glXGetCurrentContext();
6545
6546 if (gc->driContext) {
6547 CALL_GetMinmax(GET_DISPATCH(), (target, reset, format, type, values));
6548 } else {
6549 __GLXcontext *const gc = __glXGetCurrentContext();
6550 const __GLXattribute *const state = gc->client_state_private;
6551 Display *const dpy = gc->currentDpy;
6552 const GLuint cmdlen = 16;
6553 if (__builtin_expect(dpy != NULL, 1)) {
6554 GLubyte const *pc =
6555 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6556 X_GLvop_GetMinmaxEXT, cmdlen);
6557 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6558 (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
6559 (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
6560 *(int32_t *) (pc + 12) = 0;
6561 *(int8_t *) (pc + 12) = state->storePack.swapEndian;
6562 *(int8_t *) (pc + 13) = reset;
6563 __glXReadPixelReply(dpy, gc, 1, 2, 1, 1, format, type, values,
6564 GL_FALSE);
6565 UnlockDisplay(dpy);
6566 SyncHandle();
6567 }
6568 return;
6569 }
6570 }
6571
6572 #define X_GLsop_GetMinmaxParameterfv 158
6573 void
6574 __indirect_glGetMinmaxParameterfv(GLenum target, GLenum pname,
6575 GLfloat * params)
6576 {
6577 __GLXcontext *const gc = __glXGetCurrentContext();
6578 Display *const dpy = gc->currentDpy;
6579 #ifndef USE_XCB
6580 const GLuint cmdlen = 8;
6581 #endif
6582 if (__builtin_expect(dpy != NULL, 1)) {
6583 #ifdef USE_XCB
6584 xcb_connection_t *c = XGetXCBConnection(dpy);
6585 (void) __glXFlushRenderBuffer(gc, gc->pc);
6586 xcb_glx_get_minmax_parameterfv_reply_t *reply =
6587 xcb_glx_get_minmax_parameterfv_reply(c,
6588 xcb_glx_get_minmax_parameterfv
6589 (c, gc->currentContextTag,
6590 target, pname), NULL);
6591 if (xcb_glx_get_minmax_parameterfv_data_length(reply) == 0)
6592 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
6593 else
6594 (void) memcpy(params, xcb_glx_get_minmax_parameterfv_data(reply),
6595 xcb_glx_get_minmax_parameterfv_data_length(reply) *
6596 sizeof(GLfloat));
6597 free(reply);
6598 #else
6599 GLubyte const *pc =
6600 __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParameterfv, cmdlen);
6601 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6602 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6603 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6604 UnlockDisplay(dpy);
6605 SyncHandle();
6606 #endif /* USE_XCB */
6607 }
6608 return;
6609 }
6610
6611 #define X_GLvop_GetMinmaxParameterfvEXT 9
6612 void
6613 gl_dispatch_stub_365(GLenum target, GLenum pname, GLfloat * params)
6614 {
6615 __GLXcontext *const gc = __glXGetCurrentContext();
6616
6617 if (gc->driContext) {
6618 CALL_GetMinmaxParameterfv(GET_DISPATCH(), (target, pname, params));
6619 } else {
6620 __GLXcontext *const gc = __glXGetCurrentContext();
6621 Display *const dpy = gc->currentDpy;
6622 const GLuint cmdlen = 8;
6623 if (__builtin_expect(dpy != NULL, 1)) {
6624 GLubyte const *pc =
6625 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6626 X_GLvop_GetMinmaxParameterfvEXT,
6627 cmdlen);
6628 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6629 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6630 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6631 UnlockDisplay(dpy);
6632 SyncHandle();
6633 }
6634 return;
6635 }
6636 }
6637
6638 #define X_GLsop_GetMinmaxParameteriv 159
6639 void
6640 __indirect_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint * params)
6641 {
6642 __GLXcontext *const gc = __glXGetCurrentContext();
6643 Display *const dpy = gc->currentDpy;
6644 #ifndef USE_XCB
6645 const GLuint cmdlen = 8;
6646 #endif
6647 if (__builtin_expect(dpy != NULL, 1)) {
6648 #ifdef USE_XCB
6649 xcb_connection_t *c = XGetXCBConnection(dpy);
6650 (void) __glXFlushRenderBuffer(gc, gc->pc);
6651 xcb_glx_get_minmax_parameteriv_reply_t *reply =
6652 xcb_glx_get_minmax_parameteriv_reply(c,
6653 xcb_glx_get_minmax_parameteriv
6654 (c, gc->currentContextTag,
6655 target, pname), NULL);
6656 if (xcb_glx_get_minmax_parameteriv_data_length(reply) == 0)
6657 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
6658 else
6659 (void) memcpy(params, xcb_glx_get_minmax_parameteriv_data(reply),
6660 xcb_glx_get_minmax_parameteriv_data_length(reply) *
6661 sizeof(GLint));
6662 free(reply);
6663 #else
6664 GLubyte const *pc =
6665 __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParameteriv, cmdlen);
6666 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6667 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6668 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6669 UnlockDisplay(dpy);
6670 SyncHandle();
6671 #endif /* USE_XCB */
6672 }
6673 return;
6674 }
6675
6676 #define X_GLvop_GetMinmaxParameterivEXT 10
6677 void
6678 gl_dispatch_stub_366(GLenum target, GLenum pname, GLint * params)
6679 {
6680 __GLXcontext *const gc = __glXGetCurrentContext();
6681
6682 if (gc->driContext) {
6683 CALL_GetMinmaxParameteriv(GET_DISPATCH(), (target, pname, params));
6684 } else {
6685 __GLXcontext *const gc = __glXGetCurrentContext();
6686 Display *const dpy = gc->currentDpy;
6687 const GLuint cmdlen = 8;
6688 if (__builtin_expect(dpy != NULL, 1)) {
6689 GLubyte const *pc =
6690 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
6691 X_GLvop_GetMinmaxParameterivEXT,
6692 cmdlen);
6693 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
6694 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
6695 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
6696 UnlockDisplay(dpy);
6697 SyncHandle();
6698 }
6699 return;
6700 }
6701 }
6702
6703 #define X_GLrop_Histogram 4110
6704 void
6705 __indirect_glHistogram(GLenum target, GLsizei width, GLenum internalformat,
6706 GLboolean sink)
6707 {
6708 __GLXcontext *const gc = __glXGetCurrentContext();
6709 const GLuint cmdlen = 20;
6710 emit_header(gc->pc, X_GLrop_Histogram, cmdlen);
6711 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6712 (void) memcpy((void *) (gc->pc + 8), (void *) (&width), 4);
6713 (void) memcpy((void *) (gc->pc + 12), (void *) (&internalformat), 4);
6714 (void) memcpy((void *) (gc->pc + 16), (void *) (&sink), 1);
6715 gc->pc += cmdlen;
6716 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6717 (void) __glXFlushRenderBuffer(gc, gc->pc);
6718 }
6719 }
6720
6721 #define X_GLrop_Minmax 4111
6722 void
6723 __indirect_glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
6724 {
6725 __GLXcontext *const gc = __glXGetCurrentContext();
6726 const GLuint cmdlen = 16;
6727 emit_header(gc->pc, X_GLrop_Minmax, cmdlen);
6728 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6729 (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4);
6730 (void) memcpy((void *) (gc->pc + 12), (void *) (&sink), 1);
6731 gc->pc += cmdlen;
6732 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6733 (void) __glXFlushRenderBuffer(gc, gc->pc);
6734 }
6735 }
6736
6737 #define X_GLrop_ResetHistogram 4112
6738 void
6739 __indirect_glResetHistogram(GLenum target)
6740 {
6741 __GLXcontext *const gc = __glXGetCurrentContext();
6742 const GLuint cmdlen = 8;
6743 emit_header(gc->pc, X_GLrop_ResetHistogram, cmdlen);
6744 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6745 gc->pc += cmdlen;
6746 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6747 (void) __glXFlushRenderBuffer(gc, gc->pc);
6748 }
6749 }
6750
6751 #define X_GLrop_ResetMinmax 4113
6752 void
6753 __indirect_glResetMinmax(GLenum target)
6754 {
6755 __GLXcontext *const gc = __glXGetCurrentContext();
6756 const GLuint cmdlen = 8;
6757 emit_header(gc->pc, X_GLrop_ResetMinmax, cmdlen);
6758 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6759 gc->pc += cmdlen;
6760 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6761 (void) __glXFlushRenderBuffer(gc, gc->pc);
6762 }
6763 }
6764
6765 static void
6766 __glx_TexImage_3D4D(unsigned opcode, unsigned dim, GLenum target, GLint level,
6767 GLint internalformat, GLsizei width, GLsizei height,
6768 GLsizei depth, GLsizei extent, GLint border,
6769 GLenum format, GLenum type, const GLvoid * pixels)
6770 {
6771 __GLXcontext *const gc = __glXGetCurrentContext();
6772 const GLuint compsize =
6773 (pixels != NULL) ? __glImageSize(width, height, depth, format, type,
6774 target) : 0;
6775 const GLuint cmdlen = 84 + __GLX_PAD(compsize);
6776 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
6777 if (cmdlen <= gc->maxSmallRenderCommandSize) {
6778 if ((gc->pc + cmdlen) > gc->bufEnd) {
6779 (void) __glXFlushRenderBuffer(gc, gc->pc);
6780 }
6781 emit_header(gc->pc, opcode, cmdlen);
6782 (void) memcpy((void *) (gc->pc + 40), (void *) (&target), 4);
6783 (void) memcpy((void *) (gc->pc + 44), (void *) (&level), 4);
6784 (void) memcpy((void *) (gc->pc + 48), (void *) (&internalformat),
6785 4);
6786 (void) memcpy((void *) (gc->pc + 52), (void *) (&width), 4);
6787 (void) memcpy((void *) (gc->pc + 56), (void *) (&height), 4);
6788 (void) memcpy((void *) (gc->pc + 60), (void *) (&depth), 4);
6789 (void) memcpy((void *) (gc->pc + 64), (void *) (&extent), 4);
6790 (void) memcpy((void *) (gc->pc + 68), (void *) (&border), 4);
6791 (void) memcpy((void *) (gc->pc + 72), (void *) (&format), 4);
6792 (void) memcpy((void *) (gc->pc + 76), (void *) (&type), 4);
6793 (void) memcpy((void *) (gc->pc + 80),
6794 (void *) ((pixels == NULL) ? one : zero), 4);
6795 if (compsize > 0) {
6796 (*gc->fillImage) (gc, dim, width, height, depth, format, type,
6797 pixels, gc->pc + 84, gc->pc + 4);
6798 } else {
6799 (void) memcpy(gc->pc + 4, default_pixel_store_4D,
6800 default_pixel_store_4D_size);
6801 }
6802 gc->pc += cmdlen;
6803 if (gc->pc > gc->limit) {
6804 (void) __glXFlushRenderBuffer(gc, gc->pc);
6805 }
6806 } else {
6807 const GLint op = opcode;
6808 const GLuint cmdlenLarge = cmdlen + 4;
6809 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
6810 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
6811 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
6812 (void) memcpy((void *) (pc + 44), (void *) (&target), 4);
6813 (void) memcpy((void *) (pc + 48), (void *) (&level), 4);
6814 (void) memcpy((void *) (pc + 52), (void *) (&internalformat), 4);
6815 (void) memcpy((void *) (pc + 56), (void *) (&width), 4);
6816 (void) memcpy((void *) (pc + 60), (void *) (&height), 4);
6817 (void) memcpy((void *) (pc + 64), (void *) (&depth), 4);
6818 (void) memcpy((void *) (pc + 68), (void *) (&extent), 4);
6819 (void) memcpy((void *) (pc + 72), (void *) (&border), 4);
6820 (void) memcpy((void *) (pc + 76), (void *) (&format), 4);
6821 (void) memcpy((void *) (pc + 80), (void *) (&type), 4);
6822 (void) memcpy((void *) (pc + 84), zero, 4);
6823 __glXSendLargeImage(gc, compsize, dim, width, height, depth,
6824 format, type, pixels, pc + 88, pc + 8);
6825 }
6826 }
6827 }
6828
6829 #define X_GLrop_TexImage3D 4114
6830 void
6831 __indirect_glTexImage3D(GLenum target, GLint level, GLint internalformat,
6832 GLsizei width, GLsizei height, GLsizei depth,
6833 GLint border, GLenum format, GLenum type,
6834 const GLvoid * pixels)
6835 {
6836 __glx_TexImage_3D4D(X_GLrop_TexImage3D, 3, target, level, internalformat,
6837 width, height, depth, 1, border, format, type,
6838 pixels);
6839 }
6840
6841 static void
6842 __glx_TexSubImage_3D4D(unsigned opcode, unsigned dim, GLenum target,
6843 GLint level, GLint xoffset, GLint yoffset,
6844 GLint zoffset, GLint woffset, GLsizei width,
6845 GLsizei height, GLsizei depth, GLsizei extent,
6846 GLenum format, GLenum type, const GLvoid * pixels)
6847 {
6848 __GLXcontext *const gc = __glXGetCurrentContext();
6849 const GLuint compsize =
6850 (pixels != NULL) ? __glImageSize(width, height, depth, format, type,
6851 target) : 0;
6852 const GLuint cmdlen = 92 + __GLX_PAD(compsize);
6853 if (__builtin_expect(gc->currentDpy != NULL, 1)) {
6854 if (cmdlen <= gc->maxSmallRenderCommandSize) {
6855 if ((gc->pc + cmdlen) > gc->bufEnd) {
6856 (void) __glXFlushRenderBuffer(gc, gc->pc);
6857 }
6858 emit_header(gc->pc, opcode, cmdlen);
6859 (void) memcpy((void *) (gc->pc + 40), (void *) (&target), 4);
6860 (void) memcpy((void *) (gc->pc + 44), (void *) (&level), 4);
6861 (void) memcpy((void *) (gc->pc + 48), (void *) (&xoffset), 4);
6862 (void) memcpy((void *) (gc->pc + 52), (void *) (&yoffset), 4);
6863 (void) memcpy((void *) (gc->pc + 56), (void *) (&zoffset), 4);
6864 (void) memcpy((void *) (gc->pc + 60), (void *) (&woffset), 4);
6865 (void) memcpy((void *) (gc->pc + 64), (void *) (&width), 4);
6866 (void) memcpy((void *) (gc->pc + 68), (void *) (&height), 4);
6867 (void) memcpy((void *) (gc->pc + 72), (void *) (&depth), 4);
6868 (void) memcpy((void *) (gc->pc + 76), (void *) (&extent), 4);
6869 (void) memcpy((void *) (gc->pc + 80), (void *) (&format), 4);
6870 (void) memcpy((void *) (gc->pc + 84), (void *) (&type), 4);
6871 (void) memset((void *) (gc->pc + 88), 0, 4);
6872 if (compsize > 0) {
6873 (*gc->fillImage) (gc, dim, width, height, depth, format, type,
6874 pixels, gc->pc + 92, gc->pc + 4);
6875 } else {
6876 (void) memcpy(gc->pc + 4, default_pixel_store_4D,
6877 default_pixel_store_4D_size);
6878 }
6879 gc->pc += cmdlen;
6880 if (gc->pc > gc->limit) {
6881 (void) __glXFlushRenderBuffer(gc, gc->pc);
6882 }
6883 } else {
6884 const GLint op = opcode;
6885 const GLuint cmdlenLarge = cmdlen + 4;
6886 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
6887 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
6888 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
6889 (void) memcpy((void *) (pc + 44), (void *) (&target), 4);
6890 (void) memcpy((void *) (pc + 48), (void *) (&level), 4);
6891 (void) memcpy((void *) (pc + 52), (void *) (&xoffset), 4);
6892 (void) memcpy((void *) (pc + 56), (void *) (&yoffset), 4);
6893 (void) memcpy((void *) (pc + 60), (void *) (&zoffset), 4);
6894 (void) memcpy((void *) (pc + 64), (void *) (&woffset), 4);
6895 (void) memcpy((void *) (pc + 68), (void *) (&width), 4);
6896 (void) memcpy((void *) (pc + 72), (void *) (&height), 4);
6897 (void) memcpy((void *) (pc + 76), (void *) (&depth), 4);
6898 (void) memcpy((void *) (pc + 80), (void *) (&extent), 4);
6899 (void) memcpy((void *) (pc + 84), (void *) (&format), 4);
6900 (void) memcpy((void *) (pc + 88), (void *) (&type), 4);
6901 (void) memset((void *) (pc + 92), 0, 4);
6902 __glXSendLargeImage(gc, compsize, dim, width, height, depth,
6903 format, type, pixels, pc + 96, pc + 8);
6904 }
6905 }
6906 }
6907
6908 #define X_GLrop_TexSubImage3D 4115
6909 void
6910 __indirect_glTexSubImage3D(GLenum target, GLint level, GLint xoffset,
6911 GLint yoffset, GLint zoffset, GLsizei width,
6912 GLsizei height, GLsizei depth, GLenum format,
6913 GLenum type, const GLvoid * pixels)
6914 {
6915 __glx_TexSubImage_3D4D(X_GLrop_TexSubImage3D, 3, target, level, xoffset,
6916 yoffset, zoffset, 1, width, height, depth, 1,
6917 format, type, pixels);
6918 }
6919
6920 #define X_GLrop_CopyTexSubImage3D 4123
6921 void
6922 __indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset,
6923 GLint yoffset, GLint zoffset, GLint x, GLint y,
6924 GLsizei width, GLsizei height)
6925 {
6926 __GLXcontext *const gc = __glXGetCurrentContext();
6927 const GLuint cmdlen = 40;
6928 emit_header(gc->pc, X_GLrop_CopyTexSubImage3D, cmdlen);
6929 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6930 (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4);
6931 (void) memcpy((void *) (gc->pc + 12), (void *) (&xoffset), 4);
6932 (void) memcpy((void *) (gc->pc + 16), (void *) (&yoffset), 4);
6933 (void) memcpy((void *) (gc->pc + 20), (void *) (&zoffset), 4);
6934 (void) memcpy((void *) (gc->pc + 24), (void *) (&x), 4);
6935 (void) memcpy((void *) (gc->pc + 28), (void *) (&y), 4);
6936 (void) memcpy((void *) (gc->pc + 32), (void *) (&width), 4);
6937 (void) memcpy((void *) (gc->pc + 36), (void *) (&height), 4);
6938 gc->pc += cmdlen;
6939 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6940 (void) __glXFlushRenderBuffer(gc, gc->pc);
6941 }
6942 }
6943
6944 #define X_GLrop_ActiveTextureARB 197
6945 void
6946 __indirect_glActiveTextureARB(GLenum texture)
6947 {
6948 __GLXcontext *const gc = __glXGetCurrentContext();
6949 const GLuint cmdlen = 8;
6950 emit_header(gc->pc, X_GLrop_ActiveTextureARB, cmdlen);
6951 (void) memcpy((void *) (gc->pc + 4), (void *) (&texture), 4);
6952 gc->pc += cmdlen;
6953 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6954 (void) __glXFlushRenderBuffer(gc, gc->pc);
6955 }
6956 }
6957
6958 #define X_GLrop_MultiTexCoord1dvARB 198
6959 void
6960 __indirect_glMultiTexCoord1dARB(GLenum target, GLdouble s)
6961 {
6962 __GLXcontext *const gc = __glXGetCurrentContext();
6963 const GLuint cmdlen = 16;
6964 emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
6965 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
6966 (void) memcpy((void *) (gc->pc + 12), (void *) (&target), 4);
6967 gc->pc += cmdlen;
6968 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6969 (void) __glXFlushRenderBuffer(gc, gc->pc);
6970 }
6971 }
6972
6973 #define X_GLrop_MultiTexCoord1dvARB 198
6974 void
6975 __indirect_glMultiTexCoord1dvARB(GLenum target, const GLdouble * v)
6976 {
6977 __GLXcontext *const gc = __glXGetCurrentContext();
6978 const GLuint cmdlen = 16;
6979 emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
6980 (void) memcpy((void *) (gc->pc + 4), (void *) (v), 8);
6981 (void) memcpy((void *) (gc->pc + 12), (void *) (&target), 4);
6982 gc->pc += cmdlen;
6983 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6984 (void) __glXFlushRenderBuffer(gc, gc->pc);
6985 }
6986 }
6987
6988 #define X_GLrop_MultiTexCoord1fvARB 199
6989 void
6990 __indirect_glMultiTexCoord1fARB(GLenum target, GLfloat s)
6991 {
6992 __GLXcontext *const gc = __glXGetCurrentContext();
6993 const GLuint cmdlen = 12;
6994 emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
6995 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
6996 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
6997 gc->pc += cmdlen;
6998 if (__builtin_expect(gc->pc > gc->limit, 0)) {
6999 (void) __glXFlushRenderBuffer(gc, gc->pc);
7000 }
7001 }
7002
7003 #define X_GLrop_MultiTexCoord1fvARB 199
7004 void
7005 __indirect_glMultiTexCoord1fvARB(GLenum target, const GLfloat * v)
7006 {
7007 __GLXcontext *const gc = __glXGetCurrentContext();
7008 const GLuint cmdlen = 12;
7009 emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
7010 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7011 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
7012 gc->pc += cmdlen;
7013 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7014 (void) __glXFlushRenderBuffer(gc, gc->pc);
7015 }
7016 }
7017
7018 #define X_GLrop_MultiTexCoord1ivARB 200
7019 void
7020 __indirect_glMultiTexCoord1iARB(GLenum target, GLint s)
7021 {
7022 __GLXcontext *const gc = __glXGetCurrentContext();
7023 const GLuint cmdlen = 12;
7024 emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
7025 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7026 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7027 gc->pc += cmdlen;
7028 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7029 (void) __glXFlushRenderBuffer(gc, gc->pc);
7030 }
7031 }
7032
7033 #define X_GLrop_MultiTexCoord1ivARB 200
7034 void
7035 __indirect_glMultiTexCoord1ivARB(GLenum target, const GLint * v)
7036 {
7037 __GLXcontext *const gc = __glXGetCurrentContext();
7038 const GLuint cmdlen = 12;
7039 emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
7040 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7041 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
7042 gc->pc += cmdlen;
7043 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7044 (void) __glXFlushRenderBuffer(gc, gc->pc);
7045 }
7046 }
7047
7048 #define X_GLrop_MultiTexCoord1svARB 201
7049 void
7050 __indirect_glMultiTexCoord1sARB(GLenum target, GLshort s)
7051 {
7052 __GLXcontext *const gc = __glXGetCurrentContext();
7053 const GLuint cmdlen = 12;
7054 emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
7055 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7056 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 2);
7057 gc->pc += cmdlen;
7058 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7059 (void) __glXFlushRenderBuffer(gc, gc->pc);
7060 }
7061 }
7062
7063 #define X_GLrop_MultiTexCoord1svARB 201
7064 void
7065 __indirect_glMultiTexCoord1svARB(GLenum target, const GLshort * v)
7066 {
7067 __GLXcontext *const gc = __glXGetCurrentContext();
7068 const GLuint cmdlen = 12;
7069 emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
7070 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7071 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 2);
7072 gc->pc += cmdlen;
7073 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7074 (void) __glXFlushRenderBuffer(gc, gc->pc);
7075 }
7076 }
7077
7078 #define X_GLrop_MultiTexCoord2dvARB 202
7079 void
7080 __indirect_glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t)
7081 {
7082 __GLXcontext *const gc = __glXGetCurrentContext();
7083 const GLuint cmdlen = 24;
7084 emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
7085 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
7086 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
7087 (void) memcpy((void *) (gc->pc + 20), (void *) (&target), 4);
7088 gc->pc += cmdlen;
7089 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7090 (void) __glXFlushRenderBuffer(gc, gc->pc);
7091 }
7092 }
7093
7094 #define X_GLrop_MultiTexCoord2dvARB 202
7095 void
7096 __indirect_glMultiTexCoord2dvARB(GLenum target, const GLdouble * v)
7097 {
7098 __GLXcontext *const gc = __glXGetCurrentContext();
7099 const GLuint cmdlen = 24;
7100 emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
7101 (void) memcpy((void *) (gc->pc + 4), (void *) (v), 16);
7102 (void) memcpy((void *) (gc->pc + 20), (void *) (&target), 4);
7103 gc->pc += cmdlen;
7104 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7105 (void) __glXFlushRenderBuffer(gc, gc->pc);
7106 }
7107 }
7108
7109 #define X_GLrop_MultiTexCoord2fvARB 203
7110 void
7111 __indirect_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
7112 {
7113 __GLXcontext *const gc = __glXGetCurrentContext();
7114 const GLuint cmdlen = 16;
7115 emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
7116 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7117 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7118 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
7119 gc->pc += cmdlen;
7120 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7121 (void) __glXFlushRenderBuffer(gc, gc->pc);
7122 }
7123 }
7124
7125 #define X_GLrop_MultiTexCoord2fvARB 203
7126 void
7127 __indirect_glMultiTexCoord2fvARB(GLenum target, const GLfloat * v)
7128 {
7129 __GLXcontext *const gc = __glXGetCurrentContext();
7130 const GLuint cmdlen = 16;
7131 emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
7132 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7133 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
7134 gc->pc += cmdlen;
7135 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7136 (void) __glXFlushRenderBuffer(gc, gc->pc);
7137 }
7138 }
7139
7140 #define X_GLrop_MultiTexCoord2ivARB 204
7141 void
7142 __indirect_glMultiTexCoord2iARB(GLenum target, GLint s, GLint t)
7143 {
7144 __GLXcontext *const gc = __glXGetCurrentContext();
7145 const GLuint cmdlen = 16;
7146 emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen);
7147 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7148 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7149 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
7150 gc->pc += cmdlen;
7151 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7152 (void) __glXFlushRenderBuffer(gc, gc->pc);
7153 }
7154 }
7155
7156 #define X_GLrop_MultiTexCoord2ivARB 204
7157 void
7158 __indirect_glMultiTexCoord2ivARB(GLenum target, const GLint * v)
7159 {
7160 __GLXcontext *const gc = __glXGetCurrentContext();
7161 const GLuint cmdlen = 16;
7162 emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen);
7163 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7164 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
7165 gc->pc += cmdlen;
7166 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7167 (void) __glXFlushRenderBuffer(gc, gc->pc);
7168 }
7169 }
7170
7171 #define X_GLrop_MultiTexCoord2svARB 205
7172 void
7173 __indirect_glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t)
7174 {
7175 __GLXcontext *const gc = __glXGetCurrentContext();
7176 const GLuint cmdlen = 12;
7177 emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
7178 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7179 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 2);
7180 (void) memcpy((void *) (gc->pc + 10), (void *) (&t), 2);
7181 gc->pc += cmdlen;
7182 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7183 (void) __glXFlushRenderBuffer(gc, gc->pc);
7184 }
7185 }
7186
7187 #define X_GLrop_MultiTexCoord2svARB 205
7188 void
7189 __indirect_glMultiTexCoord2svARB(GLenum target, const GLshort * v)
7190 {
7191 __GLXcontext *const gc = __glXGetCurrentContext();
7192 const GLuint cmdlen = 12;
7193 emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
7194 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7195 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
7196 gc->pc += cmdlen;
7197 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7198 (void) __glXFlushRenderBuffer(gc, gc->pc);
7199 }
7200 }
7201
7202 #define X_GLrop_MultiTexCoord3dvARB 206
7203 void
7204 __indirect_glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t,
7205 GLdouble r)
7206 {
7207 __GLXcontext *const gc = __glXGetCurrentContext();
7208 const GLuint cmdlen = 32;
7209 emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
7210 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
7211 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
7212 (void) memcpy((void *) (gc->pc + 20), (void *) (&r), 8);
7213 (void) memcpy((void *) (gc->pc + 28), (void *) (&target), 4);
7214 gc->pc += cmdlen;
7215 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7216 (void) __glXFlushRenderBuffer(gc, gc->pc);
7217 }
7218 }
7219
7220 #define X_GLrop_MultiTexCoord3dvARB 206
7221 void
7222 __indirect_glMultiTexCoord3dvARB(GLenum target, const GLdouble * v)
7223 {
7224 __GLXcontext *const gc = __glXGetCurrentContext();
7225 const GLuint cmdlen = 32;
7226 emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
7227 (void) memcpy((void *) (gc->pc + 4), (void *) (v), 24);
7228 (void) memcpy((void *) (gc->pc + 28), (void *) (&target), 4);
7229 gc->pc += cmdlen;
7230 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7231 (void) __glXFlushRenderBuffer(gc, gc->pc);
7232 }
7233 }
7234
7235 #define X_GLrop_MultiTexCoord3fvARB 207
7236 void
7237 __indirect_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t,
7238 GLfloat r)
7239 {
7240 __GLXcontext *const gc = __glXGetCurrentContext();
7241 const GLuint cmdlen = 20;
7242 emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
7243 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7244 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7245 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
7246 (void) memcpy((void *) (gc->pc + 16), (void *) (&r), 4);
7247 gc->pc += cmdlen;
7248 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7249 (void) __glXFlushRenderBuffer(gc, gc->pc);
7250 }
7251 }
7252
7253 #define X_GLrop_MultiTexCoord3fvARB 207
7254 void
7255 __indirect_glMultiTexCoord3fvARB(GLenum target, const GLfloat * v)
7256 {
7257 __GLXcontext *const gc = __glXGetCurrentContext();
7258 const GLuint cmdlen = 20;
7259 emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
7260 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7261 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 12);
7262 gc->pc += cmdlen;
7263 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7264 (void) __glXFlushRenderBuffer(gc, gc->pc);
7265 }
7266 }
7267
7268 #define X_GLrop_MultiTexCoord3ivARB 208
7269 void
7270 __indirect_glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r)
7271 {
7272 __GLXcontext *const gc = __glXGetCurrentContext();
7273 const GLuint cmdlen = 20;
7274 emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
7275 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7276 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7277 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
7278 (void) memcpy((void *) (gc->pc + 16), (void *) (&r), 4);
7279 gc->pc += cmdlen;
7280 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7281 (void) __glXFlushRenderBuffer(gc, gc->pc);
7282 }
7283 }
7284
7285 #define X_GLrop_MultiTexCoord3ivARB 208
7286 void
7287 __indirect_glMultiTexCoord3ivARB(GLenum target, const GLint * v)
7288 {
7289 __GLXcontext *const gc = __glXGetCurrentContext();
7290 const GLuint cmdlen = 20;
7291 emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
7292 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7293 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 12);
7294 gc->pc += cmdlen;
7295 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7296 (void) __glXFlushRenderBuffer(gc, gc->pc);
7297 }
7298 }
7299
7300 #define X_GLrop_MultiTexCoord3svARB 209
7301 void
7302 __indirect_glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t,
7303 GLshort r)
7304 {
7305 __GLXcontext *const gc = __glXGetCurrentContext();
7306 const GLuint cmdlen = 16;
7307 emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
7308 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7309 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 2);
7310 (void) memcpy((void *) (gc->pc + 10), (void *) (&t), 2);
7311 (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 2);
7312 gc->pc += cmdlen;
7313 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7314 (void) __glXFlushRenderBuffer(gc, gc->pc);
7315 }
7316 }
7317
7318 #define X_GLrop_MultiTexCoord3svARB 209
7319 void
7320 __indirect_glMultiTexCoord3svARB(GLenum target, const GLshort * v)
7321 {
7322 __GLXcontext *const gc = __glXGetCurrentContext();
7323 const GLuint cmdlen = 16;
7324 emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
7325 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7326 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 6);
7327 gc->pc += cmdlen;
7328 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7329 (void) __glXFlushRenderBuffer(gc, gc->pc);
7330 }
7331 }
7332
7333 #define X_GLrop_MultiTexCoord4dvARB 210
7334 void
7335 __indirect_glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t,
7336 GLdouble r, GLdouble q)
7337 {
7338 __GLXcontext *const gc = __glXGetCurrentContext();
7339 const GLuint cmdlen = 40;
7340 emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
7341 (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
7342 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
7343 (void) memcpy((void *) (gc->pc + 20), (void *) (&r), 8);
7344 (void) memcpy((void *) (gc->pc + 28), (void *) (&q), 8);
7345 (void) memcpy((void *) (gc->pc + 36), (void *) (&target), 4);
7346 gc->pc += cmdlen;
7347 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7348 (void) __glXFlushRenderBuffer(gc, gc->pc);
7349 }
7350 }
7351
7352 #define X_GLrop_MultiTexCoord4dvARB 210
7353 void
7354 __indirect_glMultiTexCoord4dvARB(GLenum target, const GLdouble * v)
7355 {
7356 __GLXcontext *const gc = __glXGetCurrentContext();
7357 const GLuint cmdlen = 40;
7358 emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
7359 (void) memcpy((void *) (gc->pc + 4), (void *) (v), 32);
7360 (void) memcpy((void *) (gc->pc + 36), (void *) (&target), 4);
7361 gc->pc += cmdlen;
7362 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7363 (void) __glXFlushRenderBuffer(gc, gc->pc);
7364 }
7365 }
7366
7367 #define X_GLrop_MultiTexCoord4fvARB 211
7368 void
7369 __indirect_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t,
7370 GLfloat r, GLfloat q)
7371 {
7372 __GLXcontext *const gc = __glXGetCurrentContext();
7373 const GLuint cmdlen = 24;
7374 emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
7375 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7376 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7377 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
7378 (void) memcpy((void *) (gc->pc + 16), (void *) (&r), 4);
7379 (void) memcpy((void *) (gc->pc + 20), (void *) (&q), 4);
7380 gc->pc += cmdlen;
7381 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7382 (void) __glXFlushRenderBuffer(gc, gc->pc);
7383 }
7384 }
7385
7386 #define X_GLrop_MultiTexCoord4fvARB 211
7387 void
7388 __indirect_glMultiTexCoord4fvARB(GLenum target, const GLfloat * v)
7389 {
7390 __GLXcontext *const gc = __glXGetCurrentContext();
7391 const GLuint cmdlen = 24;
7392 emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
7393 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7394 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
7395 gc->pc += cmdlen;
7396 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7397 (void) __glXFlushRenderBuffer(gc, gc->pc);
7398 }
7399 }
7400
7401 #define X_GLrop_MultiTexCoord4ivARB 212
7402 void
7403 __indirect_glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r,
7404 GLint q)
7405 {
7406 __GLXcontext *const gc = __glXGetCurrentContext();
7407 const GLuint cmdlen = 24;
7408 emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
7409 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7410 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
7411 (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
7412 (void) memcpy((void *) (gc->pc + 16), (void *) (&r), 4);
7413 (void) memcpy((void *) (gc->pc + 20), (void *) (&q), 4);
7414 gc->pc += cmdlen;
7415 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7416 (void) __glXFlushRenderBuffer(gc, gc->pc);
7417 }
7418 }
7419
7420 #define X_GLrop_MultiTexCoord4ivARB 212
7421 void
7422 __indirect_glMultiTexCoord4ivARB(GLenum target, const GLint * v)
7423 {
7424 __GLXcontext *const gc = __glXGetCurrentContext();
7425 const GLuint cmdlen = 24;
7426 emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
7427 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7428 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
7429 gc->pc += cmdlen;
7430 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7431 (void) __glXFlushRenderBuffer(gc, gc->pc);
7432 }
7433 }
7434
7435 #define X_GLrop_MultiTexCoord4svARB 213
7436 void
7437 __indirect_glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t,
7438 GLshort r, GLshort q)
7439 {
7440 __GLXcontext *const gc = __glXGetCurrentContext();
7441 const GLuint cmdlen = 16;
7442 emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
7443 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7444 (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 2);
7445 (void) memcpy((void *) (gc->pc + 10), (void *) (&t), 2);
7446 (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 2);
7447 (void) memcpy((void *) (gc->pc + 14), (void *) (&q), 2);
7448 gc->pc += cmdlen;
7449 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7450 (void) __glXFlushRenderBuffer(gc, gc->pc);
7451 }
7452 }
7453
7454 #define X_GLrop_MultiTexCoord4svARB 213
7455 void
7456 __indirect_glMultiTexCoord4svARB(GLenum target, const GLshort * v)
7457 {
7458 __GLXcontext *const gc = __glXGetCurrentContext();
7459 const GLuint cmdlen = 16;
7460 emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
7461 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7462 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
7463 gc->pc += cmdlen;
7464 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7465 (void) __glXFlushRenderBuffer(gc, gc->pc);
7466 }
7467 }
7468
7469 #define X_GLrop_SampleCoverageARB 229
7470 void
7471 __indirect_glSampleCoverageARB(GLclampf value, GLboolean invert)
7472 {
7473 __GLXcontext *const gc = __glXGetCurrentContext();
7474 const GLuint cmdlen = 12;
7475 emit_header(gc->pc, X_GLrop_SampleCoverageARB, cmdlen);
7476 (void) memcpy((void *) (gc->pc + 4), (void *) (&value), 4);
7477 (void) memcpy((void *) (gc->pc + 8), (void *) (&invert), 1);
7478 gc->pc += cmdlen;
7479 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7480 (void) __glXFlushRenderBuffer(gc, gc->pc);
7481 }
7482 }
7483
7484 #define X_GLvop_GetProgramStringARB 1308
7485 void
7486 __indirect_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid * string)
7487 {
7488 __GLXcontext *const gc = __glXGetCurrentContext();
7489 Display *const dpy = gc->currentDpy;
7490 const GLuint cmdlen = 8;
7491 if (__builtin_expect(dpy != NULL, 1)) {
7492 GLubyte const *pc =
7493 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
7494 X_GLvop_GetProgramStringARB, cmdlen);
7495 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
7496 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
7497 (void) __glXReadReply(dpy, 1, string, GL_TRUE);
7498 UnlockDisplay(dpy);
7499 SyncHandle();
7500 }
7501 return;
7502 }
7503
7504 #define X_GLvop_GetProgramivARB 1307
7505 void
7506 __indirect_glGetProgramivARB(GLenum target, GLenum pname, GLint * params)
7507 {
7508 __GLXcontext *const gc = __glXGetCurrentContext();
7509 Display *const dpy = gc->currentDpy;
7510 const GLuint cmdlen = 8;
7511 if (__builtin_expect(dpy != NULL, 1)) {
7512 GLubyte const *pc =
7513 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
7514 X_GLvop_GetProgramivARB, cmdlen);
7515 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
7516 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
7517 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
7518 UnlockDisplay(dpy);
7519 SyncHandle();
7520 }
7521 return;
7522 }
7523
7524 #define X_GLrop_ProgramEnvParameter4dvARB 4185
7525 void
7526 __indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index,
7527 const GLdouble * params)
7528 {
7529 __GLXcontext *const gc = __glXGetCurrentContext();
7530 const GLuint cmdlen = 44;
7531 emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen);
7532 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7533 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
7534 (void) memcpy((void *) (gc->pc + 12), (void *) (params), 32);
7535 gc->pc += cmdlen;
7536 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7537 (void) __glXFlushRenderBuffer(gc, gc->pc);
7538 }
7539 }
7540
7541 #define X_GLrop_ProgramEnvParameter4fvARB 4184
7542 void
7543 __indirect_glProgramEnvParameter4fvARB(GLenum target, GLuint index,
7544 const GLfloat * params)
7545 {
7546 __GLXcontext *const gc = __glXGetCurrentContext();
7547 const GLuint cmdlen = 28;
7548 emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen);
7549 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7550 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
7551 (void) memcpy((void *) (gc->pc + 12), (void *) (params), 16);
7552 gc->pc += cmdlen;
7553 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7554 (void) __glXFlushRenderBuffer(gc, gc->pc);
7555 }
7556 }
7557
7558 #define X_GLrop_ProgramLocalParameter4dvARB 4216
7559 void
7560 __indirect_glProgramLocalParameter4dARB(GLenum target, GLuint index,
7561 GLdouble x, GLdouble y, GLdouble z,
7562 GLdouble w)
7563 {
7564 __GLXcontext *const gc = __glXGetCurrentContext();
7565 const GLuint cmdlen = 44;
7566 emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
7567 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7568 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
7569 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 8);
7570 (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 8);
7571 (void) memcpy((void *) (gc->pc + 28), (void *) (&z), 8);
7572 (void) memcpy((void *) (gc->pc + 36), (void *) (&w), 8);
7573 gc->pc += cmdlen;
7574 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7575 (void) __glXFlushRenderBuffer(gc, gc->pc);
7576 }
7577 }
7578
7579 #define X_GLrop_ProgramLocalParameter4dvARB 4216
7580 void
7581 __indirect_glProgramLocalParameter4dvARB(GLenum target, GLuint index,
7582 const GLdouble * params)
7583 {
7584 __GLXcontext *const gc = __glXGetCurrentContext();
7585 const GLuint cmdlen = 44;
7586 emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
7587 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7588 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
7589 (void) memcpy((void *) (gc->pc + 12), (void *) (params), 32);
7590 gc->pc += cmdlen;
7591 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7592 (void) __glXFlushRenderBuffer(gc, gc->pc);
7593 }
7594 }
7595
7596 #define X_GLrop_ProgramLocalParameter4fvARB 4215
7597 void
7598 __indirect_glProgramLocalParameter4fARB(GLenum target, GLuint index,
7599 GLfloat x, GLfloat y, GLfloat z,
7600 GLfloat w)
7601 {
7602 __GLXcontext *const gc = __glXGetCurrentContext();
7603 const GLuint cmdlen = 28;
7604 emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
7605 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7606 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
7607 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
7608 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
7609 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 4);
7610 (void) memcpy((void *) (gc->pc + 24), (void *) (&w), 4);
7611 gc->pc += cmdlen;
7612 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7613 (void) __glXFlushRenderBuffer(gc, gc->pc);
7614 }
7615 }
7616
7617 #define X_GLrop_ProgramLocalParameter4fvARB 4215
7618 void
7619 __indirect_glProgramLocalParameter4fvARB(GLenum target, GLuint index,
7620 const GLfloat * params)
7621 {
7622 __GLXcontext *const gc = __glXGetCurrentContext();
7623 const GLuint cmdlen = 28;
7624 emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
7625 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7626 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
7627 (void) memcpy((void *) (gc->pc + 12), (void *) (params), 16);
7628 gc->pc += cmdlen;
7629 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7630 (void) __glXFlushRenderBuffer(gc, gc->pc);
7631 }
7632 }
7633
7634 #define X_GLrop_ProgramStringARB 4217
7635 void
7636 __indirect_glProgramStringARB(GLenum target, GLenum format, GLsizei len,
7637 const GLvoid * string)
7638 {
7639 __GLXcontext *const gc = __glXGetCurrentContext();
7640 const GLuint cmdlen = 16 + __GLX_PAD(len);
7641 if (len < 0) {
7642 __glXSetError(gc, GL_INVALID_VALUE);
7643 return;
7644 }
7645 if (__builtin_expect((len >= 0) && (gc->currentDpy != NULL), 1)) {
7646 if (cmdlen <= gc->maxSmallRenderCommandSize) {
7647 if ((gc->pc + cmdlen) > gc->bufEnd) {
7648 (void) __glXFlushRenderBuffer(gc, gc->pc);
7649 }
7650 emit_header(gc->pc, X_GLrop_ProgramStringARB, cmdlen);
7651 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
7652 (void) memcpy((void *) (gc->pc + 8), (void *) (&format), 4);
7653 (void) memcpy((void *) (gc->pc + 12), (void *) (&len), 4);
7654 (void) memcpy((void *) (gc->pc + 16), (void *) (string), len);
7655 gc->pc += cmdlen;
7656 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7657 (void) __glXFlushRenderBuffer(gc, gc->pc);
7658 }
7659 } else {
7660 const GLint op = X_GLrop_ProgramStringARB;
7661 const GLuint cmdlenLarge = cmdlen + 4;
7662 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
7663 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
7664 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
7665 (void) memcpy((void *) (pc + 8), (void *) (&target), 4);
7666 (void) memcpy((void *) (pc + 12), (void *) (&format), 4);
7667 (void) memcpy((void *) (pc + 16), (void *) (&len), 4);
7668 __glXSendLargeCommand(gc, pc, 20, string, len);
7669 }
7670 }
7671 }
7672
7673 #define X_GLrop_VertexAttrib1dvARB 4197
7674 void
7675 __indirect_glVertexAttrib1dARB(GLuint index, GLdouble x)
7676 {
7677 __GLXcontext *const gc = __glXGetCurrentContext();
7678 const GLuint cmdlen = 16;
7679 emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
7680 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7681 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
7682 gc->pc += cmdlen;
7683 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7684 (void) __glXFlushRenderBuffer(gc, gc->pc);
7685 }
7686 }
7687
7688 #define X_GLrop_VertexAttrib1dvARB 4197
7689 void
7690 __indirect_glVertexAttrib1dvARB(GLuint index, const GLdouble * v)
7691 {
7692 __GLXcontext *const gc = __glXGetCurrentContext();
7693 const GLuint cmdlen = 16;
7694 emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
7695 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7696 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
7697 gc->pc += cmdlen;
7698 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7699 (void) __glXFlushRenderBuffer(gc, gc->pc);
7700 }
7701 }
7702
7703 #define X_GLrop_VertexAttrib1fvARB 4193
7704 void
7705 __indirect_glVertexAttrib1fARB(GLuint index, GLfloat x)
7706 {
7707 __GLXcontext *const gc = __glXGetCurrentContext();
7708 const GLuint cmdlen = 12;
7709 emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
7710 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7711 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
7712 gc->pc += cmdlen;
7713 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7714 (void) __glXFlushRenderBuffer(gc, gc->pc);
7715 }
7716 }
7717
7718 #define X_GLrop_VertexAttrib1fvARB 4193
7719 void
7720 __indirect_glVertexAttrib1fvARB(GLuint index, const GLfloat * v)
7721 {
7722 __GLXcontext *const gc = __glXGetCurrentContext();
7723 const GLuint cmdlen = 12;
7724 emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
7725 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7726 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
7727 gc->pc += cmdlen;
7728 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7729 (void) __glXFlushRenderBuffer(gc, gc->pc);
7730 }
7731 }
7732
7733 #define X_GLrop_VertexAttrib1svARB 4189
7734 void
7735 __indirect_glVertexAttrib1sARB(GLuint index, GLshort x)
7736 {
7737 __GLXcontext *const gc = __glXGetCurrentContext();
7738 const GLuint cmdlen = 12;
7739 emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
7740 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7741 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
7742 gc->pc += cmdlen;
7743 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7744 (void) __glXFlushRenderBuffer(gc, gc->pc);
7745 }
7746 }
7747
7748 #define X_GLrop_VertexAttrib1svARB 4189
7749 void
7750 __indirect_glVertexAttrib1svARB(GLuint index, const GLshort * v)
7751 {
7752 __GLXcontext *const gc = __glXGetCurrentContext();
7753 const GLuint cmdlen = 12;
7754 emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
7755 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7756 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 2);
7757 gc->pc += cmdlen;
7758 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7759 (void) __glXFlushRenderBuffer(gc, gc->pc);
7760 }
7761 }
7762
7763 #define X_GLrop_VertexAttrib2dvARB 4198
7764 void
7765 __indirect_glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y)
7766 {
7767 __GLXcontext *const gc = __glXGetCurrentContext();
7768 const GLuint cmdlen = 24;
7769 emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
7770 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7771 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
7772 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
7773 gc->pc += cmdlen;
7774 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7775 (void) __glXFlushRenderBuffer(gc, gc->pc);
7776 }
7777 }
7778
7779 #define X_GLrop_VertexAttrib2dvARB 4198
7780 void
7781 __indirect_glVertexAttrib2dvARB(GLuint index, const GLdouble * v)
7782 {
7783 __GLXcontext *const gc = __glXGetCurrentContext();
7784 const GLuint cmdlen = 24;
7785 emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
7786 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7787 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
7788 gc->pc += cmdlen;
7789 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7790 (void) __glXFlushRenderBuffer(gc, gc->pc);
7791 }
7792 }
7793
7794 #define X_GLrop_VertexAttrib2fvARB 4194
7795 void
7796 __indirect_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
7797 {
7798 __GLXcontext *const gc = __glXGetCurrentContext();
7799 const GLuint cmdlen = 16;
7800 emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
7801 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7802 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
7803 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
7804 gc->pc += cmdlen;
7805 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7806 (void) __glXFlushRenderBuffer(gc, gc->pc);
7807 }
7808 }
7809
7810 #define X_GLrop_VertexAttrib2fvARB 4194
7811 void
7812 __indirect_glVertexAttrib2fvARB(GLuint index, const GLfloat * v)
7813 {
7814 __GLXcontext *const gc = __glXGetCurrentContext();
7815 const GLuint cmdlen = 16;
7816 emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
7817 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7818 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
7819 gc->pc += cmdlen;
7820 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7821 (void) __glXFlushRenderBuffer(gc, gc->pc);
7822 }
7823 }
7824
7825 #define X_GLrop_VertexAttrib2svARB 4190
7826 void
7827 __indirect_glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y)
7828 {
7829 __GLXcontext *const gc = __glXGetCurrentContext();
7830 const GLuint cmdlen = 12;
7831 emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
7832 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7833 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
7834 (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
7835 gc->pc += cmdlen;
7836 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7837 (void) __glXFlushRenderBuffer(gc, gc->pc);
7838 }
7839 }
7840
7841 #define X_GLrop_VertexAttrib2svARB 4190
7842 void
7843 __indirect_glVertexAttrib2svARB(GLuint index, const GLshort * v)
7844 {
7845 __GLXcontext *const gc = __glXGetCurrentContext();
7846 const GLuint cmdlen = 12;
7847 emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
7848 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7849 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
7850 gc->pc += cmdlen;
7851 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7852 (void) __glXFlushRenderBuffer(gc, gc->pc);
7853 }
7854 }
7855
7856 #define X_GLrop_VertexAttrib3dvARB 4199
7857 void
7858 __indirect_glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y,
7859 GLdouble z)
7860 {
7861 __GLXcontext *const gc = __glXGetCurrentContext();
7862 const GLuint cmdlen = 32;
7863 emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
7864 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7865 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
7866 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
7867 (void) memcpy((void *) (gc->pc + 24), (void *) (&z), 8);
7868 gc->pc += cmdlen;
7869 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7870 (void) __glXFlushRenderBuffer(gc, gc->pc);
7871 }
7872 }
7873
7874 #define X_GLrop_VertexAttrib3dvARB 4199
7875 void
7876 __indirect_glVertexAttrib3dvARB(GLuint index, const GLdouble * v)
7877 {
7878 __GLXcontext *const gc = __glXGetCurrentContext();
7879 const GLuint cmdlen = 32;
7880 emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
7881 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7882 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 24);
7883 gc->pc += cmdlen;
7884 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7885 (void) __glXFlushRenderBuffer(gc, gc->pc);
7886 }
7887 }
7888
7889 #define X_GLrop_VertexAttrib3fvARB 4195
7890 void
7891 __indirect_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
7892 {
7893 __GLXcontext *const gc = __glXGetCurrentContext();
7894 const GLuint cmdlen = 20;
7895 emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
7896 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7897 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
7898 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
7899 (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4);
7900 gc->pc += cmdlen;
7901 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7902 (void) __glXFlushRenderBuffer(gc, gc->pc);
7903 }
7904 }
7905
7906 #define X_GLrop_VertexAttrib3fvARB 4195
7907 void
7908 __indirect_glVertexAttrib3fvARB(GLuint index, const GLfloat * v)
7909 {
7910 __GLXcontext *const gc = __glXGetCurrentContext();
7911 const GLuint cmdlen = 20;
7912 emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
7913 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7914 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 12);
7915 gc->pc += cmdlen;
7916 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7917 (void) __glXFlushRenderBuffer(gc, gc->pc);
7918 }
7919 }
7920
7921 #define X_GLrop_VertexAttrib3svARB 4191
7922 void
7923 __indirect_glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z)
7924 {
7925 __GLXcontext *const gc = __glXGetCurrentContext();
7926 const GLuint cmdlen = 16;
7927 emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
7928 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7929 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
7930 (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
7931 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 2);
7932 gc->pc += cmdlen;
7933 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7934 (void) __glXFlushRenderBuffer(gc, gc->pc);
7935 }
7936 }
7937
7938 #define X_GLrop_VertexAttrib3svARB 4191
7939 void
7940 __indirect_glVertexAttrib3svARB(GLuint index, const GLshort * v)
7941 {
7942 __GLXcontext *const gc = __glXGetCurrentContext();
7943 const GLuint cmdlen = 16;
7944 emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
7945 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7946 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 6);
7947 gc->pc += cmdlen;
7948 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7949 (void) __glXFlushRenderBuffer(gc, gc->pc);
7950 }
7951 }
7952
7953 #define X_GLrop_VertexAttrib4NbvARB 4235
7954 void
7955 __indirect_glVertexAttrib4NbvARB(GLuint index, const GLbyte *v)
7956 {
7957 __GLXcontext *const gc = __glXGetCurrentContext();
7958 const GLuint cmdlen = 12;
7959 emit_header(gc->pc, X_GLrop_VertexAttrib4NbvARB, cmdlen);
7960 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7961 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
7962 gc->pc += cmdlen;
7963 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7964 (void) __glXFlushRenderBuffer(gc, gc->pc);
7965 }
7966 }
7967
7968 #define X_GLrop_VertexAttrib4NivARB 4237
7969 void
7970 __indirect_glVertexAttrib4NivARB(GLuint index, const GLint * v)
7971 {
7972 __GLXcontext *const gc = __glXGetCurrentContext();
7973 const GLuint cmdlen = 24;
7974 emit_header(gc->pc, X_GLrop_VertexAttrib4NivARB, cmdlen);
7975 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7976 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
7977 gc->pc += cmdlen;
7978 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7979 (void) __glXFlushRenderBuffer(gc, gc->pc);
7980 }
7981 }
7982
7983 #define X_GLrop_VertexAttrib4NsvARB 4236
7984 void
7985 __indirect_glVertexAttrib4NsvARB(GLuint index, const GLshort * v)
7986 {
7987 __GLXcontext *const gc = __glXGetCurrentContext();
7988 const GLuint cmdlen = 16;
7989 emit_header(gc->pc, X_GLrop_VertexAttrib4NsvARB, cmdlen);
7990 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
7991 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
7992 gc->pc += cmdlen;
7993 if (__builtin_expect(gc->pc > gc->limit, 0)) {
7994 (void) __glXFlushRenderBuffer(gc, gc->pc);
7995 }
7996 }
7997
7998 #define X_GLrop_VertexAttrib4NubvARB 4201
7999 void
8000 __indirect_glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y,
8001 GLubyte z, GLubyte w)
8002 {
8003 __GLXcontext *const gc = __glXGetCurrentContext();
8004 const GLuint cmdlen = 12;
8005 emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
8006 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8007 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 1);
8008 (void) memcpy((void *) (gc->pc + 9), (void *) (&y), 1);
8009 (void) memcpy((void *) (gc->pc + 10), (void *) (&z), 1);
8010 (void) memcpy((void *) (gc->pc + 11), (void *) (&w), 1);
8011 gc->pc += cmdlen;
8012 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8013 (void) __glXFlushRenderBuffer(gc, gc->pc);
8014 }
8015 }
8016
8017 #define X_GLrop_VertexAttrib4NubvARB 4201
8018 void
8019 __indirect_glVertexAttrib4NubvARB(GLuint index, const GLubyte *v)
8020 {
8021 __GLXcontext *const gc = __glXGetCurrentContext();
8022 const GLuint cmdlen = 12;
8023 emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
8024 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8025 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
8026 gc->pc += cmdlen;
8027 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8028 (void) __glXFlushRenderBuffer(gc, gc->pc);
8029 }
8030 }
8031
8032 #define X_GLrop_VertexAttrib4NuivARB 4239
8033 void
8034 __indirect_glVertexAttrib4NuivARB(GLuint index, const GLuint * v)
8035 {
8036 __GLXcontext *const gc = __glXGetCurrentContext();
8037 const GLuint cmdlen = 24;
8038 emit_header(gc->pc, X_GLrop_VertexAttrib4NuivARB, cmdlen);
8039 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8040 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
8041 gc->pc += cmdlen;
8042 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8043 (void) __glXFlushRenderBuffer(gc, gc->pc);
8044 }
8045 }
8046
8047 #define X_GLrop_VertexAttrib4NusvARB 4238
8048 void
8049 __indirect_glVertexAttrib4NusvARB(GLuint index, const GLushort * v)
8050 {
8051 __GLXcontext *const gc = __glXGetCurrentContext();
8052 const GLuint cmdlen = 16;
8053 emit_header(gc->pc, X_GLrop_VertexAttrib4NusvARB, cmdlen);
8054 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8055 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
8056 gc->pc += cmdlen;
8057 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8058 (void) __glXFlushRenderBuffer(gc, gc->pc);
8059 }
8060 }
8061
8062 #define X_GLrop_VertexAttrib4bvARB 4230
8063 void
8064 __indirect_glVertexAttrib4bvARB(GLuint index, const GLbyte *v)
8065 {
8066 __GLXcontext *const gc = __glXGetCurrentContext();
8067 const GLuint cmdlen = 12;
8068 emit_header(gc->pc, X_GLrop_VertexAttrib4bvARB, cmdlen);
8069 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8070 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
8071 gc->pc += cmdlen;
8072 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8073 (void) __glXFlushRenderBuffer(gc, gc->pc);
8074 }
8075 }
8076
8077 #define X_GLrop_VertexAttrib4dvARB 4200
8078 void
8079 __indirect_glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y,
8080 GLdouble z, GLdouble w)
8081 {
8082 __GLXcontext *const gc = __glXGetCurrentContext();
8083 const GLuint cmdlen = 40;
8084 emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
8085 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8086 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
8087 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
8088 (void) memcpy((void *) (gc->pc + 24), (void *) (&z), 8);
8089 (void) memcpy((void *) (gc->pc + 32), (void *) (&w), 8);
8090 gc->pc += cmdlen;
8091 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8092 (void) __glXFlushRenderBuffer(gc, gc->pc);
8093 }
8094 }
8095
8096 #define X_GLrop_VertexAttrib4dvARB 4200
8097 void
8098 __indirect_glVertexAttrib4dvARB(GLuint index, const GLdouble * v)
8099 {
8100 __GLXcontext *const gc = __glXGetCurrentContext();
8101 const GLuint cmdlen = 40;
8102 emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
8103 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8104 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 32);
8105 gc->pc += cmdlen;
8106 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8107 (void) __glXFlushRenderBuffer(gc, gc->pc);
8108 }
8109 }
8110
8111 #define X_GLrop_VertexAttrib4fvARB 4196
8112 void
8113 __indirect_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z,
8114 GLfloat w)
8115 {
8116 __GLXcontext *const gc = __glXGetCurrentContext();
8117 const GLuint cmdlen = 24;
8118 emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
8119 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8120 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
8121 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
8122 (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4);
8123 (void) memcpy((void *) (gc->pc + 20), (void *) (&w), 4);
8124 gc->pc += cmdlen;
8125 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8126 (void) __glXFlushRenderBuffer(gc, gc->pc);
8127 }
8128 }
8129
8130 #define X_GLrop_VertexAttrib4fvARB 4196
8131 void
8132 __indirect_glVertexAttrib4fvARB(GLuint index, const GLfloat * v)
8133 {
8134 __GLXcontext *const gc = __glXGetCurrentContext();
8135 const GLuint cmdlen = 24;
8136 emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
8137 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8138 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
8139 gc->pc += cmdlen;
8140 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8141 (void) __glXFlushRenderBuffer(gc, gc->pc);
8142 }
8143 }
8144
8145 #define X_GLrop_VertexAttrib4ivARB 4231
8146 void
8147 __indirect_glVertexAttrib4ivARB(GLuint index, const GLint * v)
8148 {
8149 __GLXcontext *const gc = __glXGetCurrentContext();
8150 const GLuint cmdlen = 24;
8151 emit_header(gc->pc, X_GLrop_VertexAttrib4ivARB, cmdlen);
8152 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8153 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
8154 gc->pc += cmdlen;
8155 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8156 (void) __glXFlushRenderBuffer(gc, gc->pc);
8157 }
8158 }
8159
8160 #define X_GLrop_VertexAttrib4svARB 4192
8161 void
8162 __indirect_glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z,
8163 GLshort w)
8164 {
8165 __GLXcontext *const gc = __glXGetCurrentContext();
8166 const GLuint cmdlen = 16;
8167 emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
8168 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8169 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
8170 (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
8171 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 2);
8172 (void) memcpy((void *) (gc->pc + 14), (void *) (&w), 2);
8173 gc->pc += cmdlen;
8174 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8175 (void) __glXFlushRenderBuffer(gc, gc->pc);
8176 }
8177 }
8178
8179 #define X_GLrop_VertexAttrib4svARB 4192
8180 void
8181 __indirect_glVertexAttrib4svARB(GLuint index, const GLshort * v)
8182 {
8183 __GLXcontext *const gc = __glXGetCurrentContext();
8184 const GLuint cmdlen = 16;
8185 emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
8186 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8187 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
8188 gc->pc += cmdlen;
8189 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8190 (void) __glXFlushRenderBuffer(gc, gc->pc);
8191 }
8192 }
8193
8194 #define X_GLrop_VertexAttrib4ubvARB 4232
8195 void
8196 __indirect_glVertexAttrib4ubvARB(GLuint index, const GLubyte *v)
8197 {
8198 __GLXcontext *const gc = __glXGetCurrentContext();
8199 const GLuint cmdlen = 12;
8200 emit_header(gc->pc, X_GLrop_VertexAttrib4ubvARB, cmdlen);
8201 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8202 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
8203 gc->pc += cmdlen;
8204 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8205 (void) __glXFlushRenderBuffer(gc, gc->pc);
8206 }
8207 }
8208
8209 #define X_GLrop_VertexAttrib4uivARB 4234
8210 void
8211 __indirect_glVertexAttrib4uivARB(GLuint index, const GLuint * v)
8212 {
8213 __GLXcontext *const gc = __glXGetCurrentContext();
8214 const GLuint cmdlen = 24;
8215 emit_header(gc->pc, X_GLrop_VertexAttrib4uivARB, cmdlen);
8216 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8217 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
8218 gc->pc += cmdlen;
8219 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8220 (void) __glXFlushRenderBuffer(gc, gc->pc);
8221 }
8222 }
8223
8224 #define X_GLrop_VertexAttrib4usvARB 4233
8225 void
8226 __indirect_glVertexAttrib4usvARB(GLuint index, const GLushort * v)
8227 {
8228 __GLXcontext *const gc = __glXGetCurrentContext();
8229 const GLuint cmdlen = 16;
8230 emit_header(gc->pc, X_GLrop_VertexAttrib4usvARB, cmdlen);
8231 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
8232 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
8233 gc->pc += cmdlen;
8234 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8235 (void) __glXFlushRenderBuffer(gc, gc->pc);
8236 }
8237 }
8238
8239 #define X_GLrop_BeginQueryARB 231
8240 void
8241 __indirect_glBeginQueryARB(GLenum target, GLuint id)
8242 {
8243 __GLXcontext *const gc = __glXGetCurrentContext();
8244 const GLuint cmdlen = 12;
8245 emit_header(gc->pc, X_GLrop_BeginQueryARB, cmdlen);
8246 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
8247 (void) memcpy((void *) (gc->pc + 8), (void *) (&id), 4);
8248 gc->pc += cmdlen;
8249 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8250 (void) __glXFlushRenderBuffer(gc, gc->pc);
8251 }
8252 }
8253
8254 #define X_GLsop_DeleteQueriesARB 161
8255 void
8256 __indirect_glDeleteQueriesARB(GLsizei n, const GLuint * ids)
8257 {
8258 __GLXcontext *const gc = __glXGetCurrentContext();
8259 Display *const dpy = gc->currentDpy;
8260 #ifndef USE_XCB
8261 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
8262 #endif
8263 if (n < 0) {
8264 __glXSetError(gc, GL_INVALID_VALUE);
8265 return;
8266 }
8267 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
8268 #ifdef USE_XCB
8269 xcb_connection_t *c = XGetXCBConnection(dpy);
8270 (void) __glXFlushRenderBuffer(gc, gc->pc);
8271 xcb_glx_delete_queries_arb(c, gc->currentContextTag, n, ids);
8272 #else
8273 GLubyte const *pc =
8274 __glXSetupSingleRequest(gc, X_GLsop_DeleteQueriesARB, cmdlen);
8275 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
8276 (void) memcpy((void *) (pc + 4), (void *) (ids), (n * 4));
8277 UnlockDisplay(dpy);
8278 SyncHandle();
8279 #endif /* USE_XCB */
8280 }
8281 return;
8282 }
8283
8284 #define X_GLrop_EndQueryARB 232
8285 void
8286 __indirect_glEndQueryARB(GLenum target)
8287 {
8288 __GLXcontext *const gc = __glXGetCurrentContext();
8289 const GLuint cmdlen = 8;
8290 emit_header(gc->pc, X_GLrop_EndQueryARB, cmdlen);
8291 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
8292 gc->pc += cmdlen;
8293 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8294 (void) __glXFlushRenderBuffer(gc, gc->pc);
8295 }
8296 }
8297
8298 #define X_GLsop_GenQueriesARB 162
8299 void
8300 __indirect_glGenQueriesARB(GLsizei n, GLuint * ids)
8301 {
8302 __GLXcontext *const gc = __glXGetCurrentContext();
8303 Display *const dpy = gc->currentDpy;
8304 #ifndef USE_XCB
8305 const GLuint cmdlen = 4;
8306 #endif
8307 if (n < 0) {
8308 __glXSetError(gc, GL_INVALID_VALUE);
8309 return;
8310 }
8311 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
8312 #ifdef USE_XCB
8313 xcb_connection_t *c = XGetXCBConnection(dpy);
8314 (void) __glXFlushRenderBuffer(gc, gc->pc);
8315 xcb_glx_gen_queries_arb_reply_t *reply =
8316 xcb_glx_gen_queries_arb_reply(c,
8317 xcb_glx_gen_queries_arb(c,
8318 gc->
8319 currentContextTag,
8320 n), NULL);
8321 (void) memcpy(ids, xcb_glx_gen_queries_arb_data(reply),
8322 xcb_glx_gen_queries_arb_data_length(reply) *
8323 sizeof(GLuint));
8324 free(reply);
8325 #else
8326 GLubyte const *pc =
8327 __glXSetupSingleRequest(gc, X_GLsop_GenQueriesARB, cmdlen);
8328 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
8329 (void) __glXReadReply(dpy, 4, ids, GL_TRUE);
8330 UnlockDisplay(dpy);
8331 SyncHandle();
8332 #endif /* USE_XCB */
8333 }
8334 return;
8335 }
8336
8337 #define X_GLsop_GetQueryObjectivARB 165
8338 void
8339 __indirect_glGetQueryObjectivARB(GLuint id, GLenum pname, GLint * params)
8340 {
8341 __GLXcontext *const gc = __glXGetCurrentContext();
8342 Display *const dpy = gc->currentDpy;
8343 #ifndef USE_XCB
8344 const GLuint cmdlen = 8;
8345 #endif
8346 if (__builtin_expect(dpy != NULL, 1)) {
8347 #ifdef USE_XCB
8348 xcb_connection_t *c = XGetXCBConnection(dpy);
8349 (void) __glXFlushRenderBuffer(gc, gc->pc);
8350 xcb_glx_get_query_objectiv_arb_reply_t *reply =
8351 xcb_glx_get_query_objectiv_arb_reply(c,
8352 xcb_glx_get_query_objectiv_arb
8353 (c, gc->currentContextTag,
8354 id, pname), NULL);
8355 if (xcb_glx_get_query_objectiv_arb_data_length(reply) == 0)
8356 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
8357 else
8358 (void) memcpy(params, xcb_glx_get_query_objectiv_arb_data(reply),
8359 xcb_glx_get_query_objectiv_arb_data_length(reply) *
8360 sizeof(GLint));
8361 free(reply);
8362 #else
8363 GLubyte const *pc =
8364 __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectivARB, cmdlen);
8365 (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
8366 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
8367 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
8368 UnlockDisplay(dpy);
8369 SyncHandle();
8370 #endif /* USE_XCB */
8371 }
8372 return;
8373 }
8374
8375 #define X_GLsop_GetQueryObjectuivARB 166
8376 void
8377 __indirect_glGetQueryObjectuivARB(GLuint id, GLenum pname, GLuint * params)
8378 {
8379 __GLXcontext *const gc = __glXGetCurrentContext();
8380 Display *const dpy = gc->currentDpy;
8381 #ifndef USE_XCB
8382 const GLuint cmdlen = 8;
8383 #endif
8384 if (__builtin_expect(dpy != NULL, 1)) {
8385 #ifdef USE_XCB
8386 xcb_connection_t *c = XGetXCBConnection(dpy);
8387 (void) __glXFlushRenderBuffer(gc, gc->pc);
8388 xcb_glx_get_query_objectuiv_arb_reply_t *reply =
8389 xcb_glx_get_query_objectuiv_arb_reply(c,
8390 xcb_glx_get_query_objectuiv_arb
8391 (c, gc->currentContextTag,
8392 id, pname), NULL);
8393 if (xcb_glx_get_query_objectuiv_arb_data_length(reply) == 0)
8394 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
8395 else
8396 (void) memcpy(params, xcb_glx_get_query_objectuiv_arb_data(reply),
8397 xcb_glx_get_query_objectuiv_arb_data_length(reply) *
8398 sizeof(GLuint));
8399 free(reply);
8400 #else
8401 GLubyte const *pc =
8402 __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectuivARB, cmdlen);
8403 (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
8404 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
8405 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
8406 UnlockDisplay(dpy);
8407 SyncHandle();
8408 #endif /* USE_XCB */
8409 }
8410 return;
8411 }
8412
8413 #define X_GLsop_GetQueryivARB 164
8414 void
8415 __indirect_glGetQueryivARB(GLenum target, GLenum pname, GLint * params)
8416 {
8417 __GLXcontext *const gc = __glXGetCurrentContext();
8418 Display *const dpy = gc->currentDpy;
8419 #ifndef USE_XCB
8420 const GLuint cmdlen = 8;
8421 #endif
8422 if (__builtin_expect(dpy != NULL, 1)) {
8423 #ifdef USE_XCB
8424 xcb_connection_t *c = XGetXCBConnection(dpy);
8425 (void) __glXFlushRenderBuffer(gc, gc->pc);
8426 xcb_glx_get_queryiv_arb_reply_t *reply =
8427 xcb_glx_get_queryiv_arb_reply(c,
8428 xcb_glx_get_queryiv_arb(c,
8429 gc->
8430 currentContextTag,
8431 target,
8432 pname),
8433 NULL);
8434 if (xcb_glx_get_queryiv_arb_data_length(reply) == 0)
8435 (void) memcpy(params, &reply->datum, sizeof(reply->datum));
8436 else
8437 (void) memcpy(params, xcb_glx_get_queryiv_arb_data(reply),
8438 xcb_glx_get_queryiv_arb_data_length(reply) *
8439 sizeof(GLint));
8440 free(reply);
8441 #else
8442 GLubyte const *pc =
8443 __glXSetupSingleRequest(gc, X_GLsop_GetQueryivARB, cmdlen);
8444 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
8445 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
8446 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
8447 UnlockDisplay(dpy);
8448 SyncHandle();
8449 #endif /* USE_XCB */
8450 }
8451 return;
8452 }
8453
8454 #define X_GLsop_IsQueryARB 163
8455 GLboolean
8456 __indirect_glIsQueryARB(GLuint id)
8457 {
8458 __GLXcontext *const gc = __glXGetCurrentContext();
8459 Display *const dpy = gc->currentDpy;
8460 GLboolean retval = (GLboolean) 0;
8461 #ifndef USE_XCB
8462 const GLuint cmdlen = 4;
8463 #endif
8464 if (__builtin_expect(dpy != NULL, 1)) {
8465 #ifdef USE_XCB
8466 xcb_connection_t *c = XGetXCBConnection(dpy);
8467 (void) __glXFlushRenderBuffer(gc, gc->pc);
8468 xcb_glx_is_query_arb_reply_t *reply =
8469 xcb_glx_is_query_arb_reply(c,
8470 xcb_glx_is_query_arb(c,
8471 gc->
8472 currentContextTag,
8473 id), NULL);
8474 retval = reply->ret_val;
8475 free(reply);
8476 #else
8477 GLubyte const *pc =
8478 __glXSetupSingleRequest(gc, X_GLsop_IsQueryARB, cmdlen);
8479 (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
8480 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
8481 UnlockDisplay(dpy);
8482 SyncHandle();
8483 #endif /* USE_XCB */
8484 }
8485 return retval;
8486 }
8487
8488 #define X_GLrop_DrawBuffersARB 233
8489 void
8490 __indirect_glDrawBuffersARB(GLsizei n, const GLenum * bufs)
8491 {
8492 __GLXcontext *const gc = __glXGetCurrentContext();
8493 const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
8494 if (n < 0) {
8495 __glXSetError(gc, GL_INVALID_VALUE);
8496 return;
8497 }
8498 if (__builtin_expect((n >= 0) && (gc->currentDpy != NULL), 1)) {
8499 if (cmdlen <= gc->maxSmallRenderCommandSize) {
8500 if ((gc->pc + cmdlen) > gc->bufEnd) {
8501 (void) __glXFlushRenderBuffer(gc, gc->pc);
8502 }
8503 emit_header(gc->pc, X_GLrop_DrawBuffersARB, cmdlen);
8504 (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
8505 (void) memcpy((void *) (gc->pc + 8), (void *) (bufs), (n * 4));
8506 gc->pc += cmdlen;
8507 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8508 (void) __glXFlushRenderBuffer(gc, gc->pc);
8509 }
8510 } else {
8511 const GLint op = X_GLrop_DrawBuffersARB;
8512 const GLuint cmdlenLarge = cmdlen + 4;
8513 GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
8514 (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
8515 (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
8516 (void) memcpy((void *) (pc + 8), (void *) (&n), 4);
8517 __glXSendLargeCommand(gc, pc, 12, bufs, (n * 4));
8518 }
8519 }
8520 }
8521
8522 #define X_GLrop_SampleMaskSGIS 2048
8523 void
8524 __indirect_glSampleMaskSGIS(GLclampf value, GLboolean invert)
8525 {
8526 __GLXcontext *const gc = __glXGetCurrentContext();
8527 const GLuint cmdlen = 12;
8528 emit_header(gc->pc, X_GLrop_SampleMaskSGIS, cmdlen);
8529 (void) memcpy((void *) (gc->pc + 4), (void *) (&value), 4);
8530 (void) memcpy((void *) (gc->pc + 8), (void *) (&invert), 1);
8531 gc->pc += cmdlen;
8532 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8533 (void) __glXFlushRenderBuffer(gc, gc->pc);
8534 }
8535 }
8536
8537 #define X_GLrop_SamplePatternSGIS 2049
8538 void
8539 __indirect_glSamplePatternSGIS(GLenum pattern)
8540 {
8541 __GLXcontext *const gc = __glXGetCurrentContext();
8542 const GLuint cmdlen = 8;
8543 emit_header(gc->pc, X_GLrop_SamplePatternSGIS, cmdlen);
8544 (void) memcpy((void *) (gc->pc + 4), (void *) (&pattern), 4);
8545 gc->pc += cmdlen;
8546 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8547 (void) __glXFlushRenderBuffer(gc, gc->pc);
8548 }
8549 }
8550
8551 #define X_GLrop_PointParameterfEXT 2065
8552 void
8553 __indirect_glPointParameterfEXT(GLenum pname, GLfloat param)
8554 {
8555 __GLXcontext *const gc = __glXGetCurrentContext();
8556 const GLuint cmdlen = 12;
8557 emit_header(gc->pc, X_GLrop_PointParameterfEXT, cmdlen);
8558 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
8559 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
8560 gc->pc += cmdlen;
8561 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8562 (void) __glXFlushRenderBuffer(gc, gc->pc);
8563 }
8564 }
8565
8566 #define X_GLrop_PointParameterfvEXT 2066
8567 void
8568 __indirect_glPointParameterfvEXT(GLenum pname, const GLfloat * params)
8569 {
8570 __GLXcontext *const gc = __glXGetCurrentContext();
8571 const GLuint compsize = __glPointParameterfvEXT_size(pname);
8572 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
8573 emit_header(gc->pc, X_GLrop_PointParameterfvEXT, cmdlen);
8574 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
8575 (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
8576 gc->pc += cmdlen;
8577 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8578 (void) __glXFlushRenderBuffer(gc, gc->pc);
8579 }
8580 }
8581
8582 #define X_GLrop_SecondaryColor3bvEXT 4126
8583 void
8584 __indirect_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue)
8585 {
8586 __GLXcontext *const gc = __glXGetCurrentContext();
8587 const GLuint cmdlen = 8;
8588 emit_header(gc->pc, X_GLrop_SecondaryColor3bvEXT, cmdlen);
8589 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
8590 (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
8591 (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
8592 gc->pc += cmdlen;
8593 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8594 (void) __glXFlushRenderBuffer(gc, gc->pc);
8595 }
8596 }
8597
8598 #define X_GLrop_SecondaryColor3bvEXT 4126
8599 void
8600 __indirect_glSecondaryColor3bvEXT(const GLbyte *v)
8601 {
8602 generic_3_byte(X_GLrop_SecondaryColor3bvEXT, v);
8603 }
8604
8605 #define X_GLrop_SecondaryColor3dvEXT 4130
8606 void
8607 __indirect_glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue)
8608 {
8609 __GLXcontext *const gc = __glXGetCurrentContext();
8610 const GLuint cmdlen = 28;
8611 emit_header(gc->pc, X_GLrop_SecondaryColor3dvEXT, cmdlen);
8612 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 8);
8613 (void) memcpy((void *) (gc->pc + 12), (void *) (&green), 8);
8614 (void) memcpy((void *) (gc->pc + 20), (void *) (&blue), 8);
8615 gc->pc += cmdlen;
8616 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8617 (void) __glXFlushRenderBuffer(gc, gc->pc);
8618 }
8619 }
8620
8621 #define X_GLrop_SecondaryColor3dvEXT 4130
8622 void
8623 __indirect_glSecondaryColor3dvEXT(const GLdouble * v)
8624 {
8625 generic_24_byte(X_GLrop_SecondaryColor3dvEXT, v);
8626 }
8627
8628 #define X_GLrop_SecondaryColor3fvEXT 4129
8629 void
8630 __indirect_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue)
8631 {
8632 __GLXcontext *const gc = __glXGetCurrentContext();
8633 const GLuint cmdlen = 16;
8634 emit_header(gc->pc, X_GLrop_SecondaryColor3fvEXT, cmdlen);
8635 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
8636 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
8637 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
8638 gc->pc += cmdlen;
8639 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8640 (void) __glXFlushRenderBuffer(gc, gc->pc);
8641 }
8642 }
8643
8644 #define X_GLrop_SecondaryColor3fvEXT 4129
8645 void
8646 __indirect_glSecondaryColor3fvEXT(const GLfloat * v)
8647 {
8648 generic_12_byte(X_GLrop_SecondaryColor3fvEXT, v);
8649 }
8650
8651 #define X_GLrop_SecondaryColor3ivEXT 4128
8652 void
8653 __indirect_glSecondaryColor3iEXT(GLint red, GLint green, GLint blue)
8654 {
8655 __GLXcontext *const gc = __glXGetCurrentContext();
8656 const GLuint cmdlen = 16;
8657 emit_header(gc->pc, X_GLrop_SecondaryColor3ivEXT, cmdlen);
8658 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
8659 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
8660 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
8661 gc->pc += cmdlen;
8662 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8663 (void) __glXFlushRenderBuffer(gc, gc->pc);
8664 }
8665 }
8666
8667 #define X_GLrop_SecondaryColor3ivEXT 4128
8668 void
8669 __indirect_glSecondaryColor3ivEXT(const GLint * v)
8670 {
8671 generic_12_byte(X_GLrop_SecondaryColor3ivEXT, v);
8672 }
8673
8674 #define X_GLrop_SecondaryColor3svEXT 4127
8675 void
8676 __indirect_glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue)
8677 {
8678 __GLXcontext *const gc = __glXGetCurrentContext();
8679 const GLuint cmdlen = 12;
8680 emit_header(gc->pc, X_GLrop_SecondaryColor3svEXT, cmdlen);
8681 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
8682 (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
8683 (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
8684 gc->pc += cmdlen;
8685 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8686 (void) __glXFlushRenderBuffer(gc, gc->pc);
8687 }
8688 }
8689
8690 #define X_GLrop_SecondaryColor3svEXT 4127
8691 void
8692 __indirect_glSecondaryColor3svEXT(const GLshort * v)
8693 {
8694 generic_6_byte(X_GLrop_SecondaryColor3svEXT, v);
8695 }
8696
8697 #define X_GLrop_SecondaryColor3ubvEXT 4131
8698 void
8699 __indirect_glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue)
8700 {
8701 __GLXcontext *const gc = __glXGetCurrentContext();
8702 const GLuint cmdlen = 8;
8703 emit_header(gc->pc, X_GLrop_SecondaryColor3ubvEXT, cmdlen);
8704 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
8705 (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
8706 (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
8707 gc->pc += cmdlen;
8708 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8709 (void) __glXFlushRenderBuffer(gc, gc->pc);
8710 }
8711 }
8712
8713 #define X_GLrop_SecondaryColor3ubvEXT 4131
8714 void
8715 __indirect_glSecondaryColor3ubvEXT(const GLubyte *v)
8716 {
8717 generic_3_byte(X_GLrop_SecondaryColor3ubvEXT, v);
8718 }
8719
8720 #define X_GLrop_SecondaryColor3uivEXT 4133
8721 void
8722 __indirect_glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue)
8723 {
8724 __GLXcontext *const gc = __glXGetCurrentContext();
8725 const GLuint cmdlen = 16;
8726 emit_header(gc->pc, X_GLrop_SecondaryColor3uivEXT, cmdlen);
8727 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
8728 (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
8729 (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
8730 gc->pc += cmdlen;
8731 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8732 (void) __glXFlushRenderBuffer(gc, gc->pc);
8733 }
8734 }
8735
8736 #define X_GLrop_SecondaryColor3uivEXT 4133
8737 void
8738 __indirect_glSecondaryColor3uivEXT(const GLuint * v)
8739 {
8740 generic_12_byte(X_GLrop_SecondaryColor3uivEXT, v);
8741 }
8742
8743 #define X_GLrop_SecondaryColor3usvEXT 4132
8744 void
8745 __indirect_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue)
8746 {
8747 __GLXcontext *const gc = __glXGetCurrentContext();
8748 const GLuint cmdlen = 12;
8749 emit_header(gc->pc, X_GLrop_SecondaryColor3usvEXT, cmdlen);
8750 (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
8751 (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
8752 (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
8753 gc->pc += cmdlen;
8754 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8755 (void) __glXFlushRenderBuffer(gc, gc->pc);
8756 }
8757 }
8758
8759 #define X_GLrop_SecondaryColor3usvEXT 4132
8760 void
8761 __indirect_glSecondaryColor3usvEXT(const GLushort * v)
8762 {
8763 generic_6_byte(X_GLrop_SecondaryColor3usvEXT, v);
8764 }
8765
8766 #define X_GLrop_FogCoorddvEXT 4125
8767 void
8768 __indirect_glFogCoorddEXT(GLdouble coord)
8769 {
8770 __GLXcontext *const gc = __glXGetCurrentContext();
8771 const GLuint cmdlen = 12;
8772 emit_header(gc->pc, X_GLrop_FogCoorddvEXT, cmdlen);
8773 (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 8);
8774 gc->pc += cmdlen;
8775 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8776 (void) __glXFlushRenderBuffer(gc, gc->pc);
8777 }
8778 }
8779
8780 #define X_GLrop_FogCoorddvEXT 4125
8781 void
8782 __indirect_glFogCoorddvEXT(const GLdouble * coord)
8783 {
8784 generic_8_byte(X_GLrop_FogCoorddvEXT, coord);
8785 }
8786
8787 #define X_GLrop_FogCoordfvEXT 4124
8788 void
8789 __indirect_glFogCoordfEXT(GLfloat coord)
8790 {
8791 __GLXcontext *const gc = __glXGetCurrentContext();
8792 const GLuint cmdlen = 8;
8793 emit_header(gc->pc, X_GLrop_FogCoordfvEXT, cmdlen);
8794 (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
8795 gc->pc += cmdlen;
8796 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8797 (void) __glXFlushRenderBuffer(gc, gc->pc);
8798 }
8799 }
8800
8801 #define X_GLrop_FogCoordfvEXT 4124
8802 void
8803 __indirect_glFogCoordfvEXT(const GLfloat * coord)
8804 {
8805 generic_4_byte(X_GLrop_FogCoordfvEXT, coord);
8806 }
8807
8808 #define X_GLrop_BlendFuncSeparateEXT 4134
8809 void
8810 __indirect_glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB,
8811 GLenum sfactorAlpha, GLenum dfactorAlpha)
8812 {
8813 __GLXcontext *const gc = __glXGetCurrentContext();
8814 const GLuint cmdlen = 20;
8815 emit_header(gc->pc, X_GLrop_BlendFuncSeparateEXT, cmdlen);
8816 (void) memcpy((void *) (gc->pc + 4), (void *) (&sfactorRGB), 4);
8817 (void) memcpy((void *) (gc->pc + 8), (void *) (&dfactorRGB), 4);
8818 (void) memcpy((void *) (gc->pc + 12), (void *) (&sfactorAlpha), 4);
8819 (void) memcpy((void *) (gc->pc + 16), (void *) (&dfactorAlpha), 4);
8820 gc->pc += cmdlen;
8821 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8822 (void) __glXFlushRenderBuffer(gc, gc->pc);
8823 }
8824 }
8825
8826 #define X_GLrop_WindowPos3fvMESA 230
8827 void
8828 __indirect_glWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
8829 {
8830 __GLXcontext *const gc = __glXGetCurrentContext();
8831 const GLuint cmdlen = 16;
8832 emit_header(gc->pc, X_GLrop_WindowPos3fvMESA, cmdlen);
8833 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
8834 (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
8835 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
8836 gc->pc += cmdlen;
8837 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8838 (void) __glXFlushRenderBuffer(gc, gc->pc);
8839 }
8840 }
8841
8842 #define X_GLrop_WindowPos3fvMESA 230
8843 void
8844 __indirect_glWindowPos3fvMESA(const GLfloat * v)
8845 {
8846 generic_12_byte(X_GLrop_WindowPos3fvMESA, v);
8847 }
8848
8849 #define X_GLvop_AreProgramsResidentNV 1293
8850 GLboolean
8851 __indirect_glAreProgramsResidentNV(GLsizei n, const GLuint * ids,
8852 GLboolean * residences)
8853 {
8854 __GLXcontext *const gc = __glXGetCurrentContext();
8855 Display *const dpy = gc->currentDpy;
8856 GLboolean retval = (GLboolean) 0;
8857 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
8858 if (n < 0) {
8859 __glXSetError(gc, GL_INVALID_VALUE);
8860 return 0;
8861 }
8862 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
8863 GLubyte const *pc =
8864 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
8865 X_GLvop_AreProgramsResidentNV, cmdlen);
8866 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
8867 (void) memcpy((void *) (pc + 4), (void *) (ids), (n * 4));
8868 retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_FALSE);
8869 UnlockDisplay(dpy);
8870 SyncHandle();
8871 }
8872 return retval;
8873 }
8874
8875 #define X_GLrop_BindProgramNV 4180
8876 void
8877 __indirect_glBindProgramNV(GLenum target, GLuint program)
8878 {
8879 __GLXcontext *const gc = __glXGetCurrentContext();
8880 const GLuint cmdlen = 12;
8881 emit_header(gc->pc, X_GLrop_BindProgramNV, cmdlen);
8882 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
8883 (void) memcpy((void *) (gc->pc + 8), (void *) (&program), 4);
8884 gc->pc += cmdlen;
8885 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8886 (void) __glXFlushRenderBuffer(gc, gc->pc);
8887 }
8888 }
8889
8890 #define X_GLvop_DeleteProgramsNV 1294
8891 void
8892 __indirect_glDeleteProgramsNV(GLsizei n, const GLuint * programs)
8893 {
8894 __GLXcontext *const gc = __glXGetCurrentContext();
8895 Display *const dpy = gc->currentDpy;
8896 const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
8897 if (n < 0) {
8898 __glXSetError(gc, GL_INVALID_VALUE);
8899 return;
8900 }
8901 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
8902 GLubyte const *pc =
8903 __glXSetupVendorRequest(gc, X_GLXVendorPrivate,
8904 X_GLvop_DeleteProgramsNV, cmdlen);
8905 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
8906 (void) memcpy((void *) (pc + 4), (void *) (programs), (n * 4));
8907 UnlockDisplay(dpy);
8908 SyncHandle();
8909 }
8910 return;
8911 }
8912
8913 #define X_GLrop_ExecuteProgramNV 4181
8914 void
8915 __indirect_glExecuteProgramNV(GLenum target, GLuint id,
8916 const GLfloat * params)
8917 {
8918 __GLXcontext *const gc = __glXGetCurrentContext();
8919 const GLuint cmdlen = 28;
8920 emit_header(gc->pc, X_GLrop_ExecuteProgramNV, cmdlen);
8921 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
8922 (void) memcpy((void *) (gc->pc + 8), (void *) (&id), 4);
8923 (void) memcpy((void *) (gc->pc + 12), (void *) (params), 16);
8924 gc->pc += cmdlen;
8925 if (__builtin_expect(gc->pc > gc->limit, 0)) {
8926 (void) __glXFlushRenderBuffer(gc, gc->pc);
8927 }
8928 }
8929
8930 #define X_GLvop_GenProgramsNV 1295
8931 void
8932 __indirect_glGenProgramsNV(GLsizei n, GLuint * programs)
8933 {
8934 __GLXcontext *const gc = __glXGetCurrentContext();
8935 Display *const dpy = gc->currentDpy;
8936 const GLuint cmdlen = 4;
8937 if (n < 0) {
8938 __glXSetError(gc, GL_INVALID_VALUE);
8939 return;
8940 }
8941 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
8942 GLubyte const *pc =
8943 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
8944 X_GLvop_GenProgramsNV, cmdlen);
8945 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
8946 (void) __glXReadReply(dpy, 4, programs, GL_TRUE);
8947 UnlockDisplay(dpy);
8948 SyncHandle();
8949 }
8950 return;
8951 }
8952
8953 #define X_GLvop_GetProgramParameterdvNV 1297
8954 void
8955 __indirect_glGetProgramParameterdvNV(GLenum target, GLuint index,
8956 GLenum pname, GLdouble * params)
8957 {
8958 __GLXcontext *const gc = __glXGetCurrentContext();
8959 Display *const dpy = gc->currentDpy;
8960 const GLuint cmdlen = 12;
8961 if (__builtin_expect(dpy != NULL, 1)) {
8962 GLubyte const *pc =
8963 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
8964 X_GLvop_GetProgramParameterdvNV, cmdlen);
8965 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
8966 (void) memcpy((void *) (pc + 4), (void *) (&index), 4);
8967 (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
8968 (void) __glXReadReply(dpy, 8, params, GL_FALSE);
8969 UnlockDisplay(dpy);
8970 SyncHandle();
8971 }
8972 return;
8973 }
8974
8975 #define X_GLvop_GetProgramParameterfvNV 1296
8976 void
8977 __indirect_glGetProgramParameterfvNV(GLenum target, GLuint index,
8978 GLenum pname, GLfloat * params)
8979 {
8980 __GLXcontext *const gc = __glXGetCurrentContext();
8981 Display *const dpy = gc->currentDpy;
8982 const GLuint cmdlen = 12;
8983 if (__builtin_expect(dpy != NULL, 1)) {
8984 GLubyte const *pc =
8985 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
8986 X_GLvop_GetProgramParameterfvNV, cmdlen);
8987 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
8988 (void) memcpy((void *) (pc + 4), (void *) (&index), 4);
8989 (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
8990 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
8991 UnlockDisplay(dpy);
8992 SyncHandle();
8993 }
8994 return;
8995 }
8996
8997 #define X_GLvop_GetProgramStringNV 1299
8998 void
8999 __indirect_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte *program)
9000 {
9001 __GLXcontext *const gc = __glXGetCurrentContext();
9002 Display *const dpy = gc->currentDpy;
9003 const GLuint cmdlen = 8;
9004 if (__builtin_expect(dpy != NULL, 1)) {
9005 GLubyte const *pc =
9006 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9007 X_GLvop_GetProgramStringNV, cmdlen);
9008 (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
9009 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
9010 (void) __glXReadReply(dpy, 1, program, GL_TRUE);
9011 UnlockDisplay(dpy);
9012 SyncHandle();
9013 }
9014 return;
9015 }
9016
9017 #define X_GLvop_GetProgramivNV 1298
9018 void
9019 __indirect_glGetProgramivNV(GLuint id, GLenum pname, GLint * params)
9020 {
9021 __GLXcontext *const gc = __glXGetCurrentContext();
9022 Display *const dpy = gc->currentDpy;
9023 const GLuint cmdlen = 8;
9024 if (__builtin_expect(dpy != NULL, 1)) {
9025 GLubyte const *pc =
9026 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9027 X_GLvop_GetProgramivNV, cmdlen);
9028 (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
9029 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
9030 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
9031 UnlockDisplay(dpy);
9032 SyncHandle();
9033 }
9034 return;
9035 }
9036
9037 #define X_GLvop_GetTrackMatrixivNV 1300
9038 void
9039 __indirect_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname,
9040 GLint * params)
9041 {
9042 __GLXcontext *const gc = __glXGetCurrentContext();
9043 Display *const dpy = gc->currentDpy;
9044 const GLuint cmdlen = 12;
9045 if (__builtin_expect(dpy != NULL, 1)) {
9046 GLubyte const *pc =
9047 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9048 X_GLvop_GetTrackMatrixivNV, cmdlen);
9049 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
9050 (void) memcpy((void *) (pc + 4), (void *) (&address), 4);
9051 (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
9052 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
9053 UnlockDisplay(dpy);
9054 SyncHandle();
9055 }
9056 return;
9057 }
9058
9059 #define X_GLvop_GetVertexAttribdvNV 1301
9060 void
9061 __indirect_glGetVertexAttribdvNV(GLuint index, GLenum pname,
9062 GLdouble * params)
9063 {
9064 __GLXcontext *const gc = __glXGetCurrentContext();
9065 Display *const dpy = gc->currentDpy;
9066 const GLuint cmdlen = 8;
9067 if (__builtin_expect(dpy != NULL, 1)) {
9068 GLubyte const *pc =
9069 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9070 X_GLvop_GetVertexAttribdvNV, cmdlen);
9071 (void) memcpy((void *) (pc + 0), (void *) (&index), 4);
9072 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
9073 (void) __glXReadReply(dpy, 8, params, GL_FALSE);
9074 UnlockDisplay(dpy);
9075 SyncHandle();
9076 }
9077 return;
9078 }
9079
9080 #define X_GLvop_GetVertexAttribfvNV 1302
9081 void
9082 __indirect_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * params)
9083 {
9084 __GLXcontext *const gc = __glXGetCurrentContext();
9085 Display *const dpy = gc->currentDpy;
9086 const GLuint cmdlen = 8;
9087 if (__builtin_expect(dpy != NULL, 1)) {
9088 GLubyte const *pc =
9089 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9090 X_GLvop_GetVertexAttribfvNV, cmdlen);
9091 (void) memcpy((void *) (pc + 0), (void *) (&index), 4);
9092 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
9093 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
9094 UnlockDisplay(dpy);
9095 SyncHandle();
9096 }
9097 return;
9098 }
9099
9100 #define X_GLvop_GetVertexAttribivNV 1303
9101 void
9102 __indirect_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params)
9103 {
9104 __GLXcontext *const gc = __glXGetCurrentContext();
9105 Display *const dpy = gc->currentDpy;
9106 const GLuint cmdlen = 8;
9107 if (__builtin_expect(dpy != NULL, 1)) {
9108 GLubyte const *pc =
9109 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9110 X_GLvop_GetVertexAttribivNV, cmdlen);
9111 (void) memcpy((void *) (pc + 0), (void *) (&index), 4);
9112 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
9113 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
9114 UnlockDisplay(dpy);
9115 SyncHandle();
9116 }
9117 return;
9118 }
9119
9120 #define X_GLvop_IsProgramNV 1304
9121 GLboolean
9122 __indirect_glIsProgramNV(GLuint program)
9123 {
9124 __GLXcontext *const gc = __glXGetCurrentContext();
9125 Display *const dpy = gc->currentDpy;
9126 GLboolean retval = (GLboolean) 0;
9127 const GLuint cmdlen = 4;
9128 if (__builtin_expect(dpy != NULL, 1)) {
9129 GLubyte const *pc =
9130 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
9131 X_GLvop_IsProgramNV, cmdlen);
9132 (void) memcpy((void *) (pc + 0), (void *) (&program), 4);
9133 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
9134 UnlockDisplay(dpy);
9135 SyncHandle();
9136 }
9137 return retval;
9138 }
9139
9140 #define X_GLrop_LoadProgramNV 4183
9141 void
9142 __indirect_glLoadProgramNV(GLenum target, GLuint id, GLsizei len,
9143 const GLubyte *program)
9144 {
9145 __GLXcontext *const gc = __glXGetCurrentContext();
9146 const GLuint cmdlen = 16 + __GLX_PAD(len);
9147 if (len < 0) {
9148 __glXSetError(gc, GL_INVALID_VALUE);
9149 return;
9150 }
9151 if (__builtin_expect(len >= 0, 1)) {
9152 emit_header(gc->pc, X_GLrop_LoadProgramNV, cmdlen);
9153 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
9154 (void) memcpy((void *) (gc->pc + 8), (void *) (&id), 4);
9155 (void) memcpy((void *) (gc->pc + 12), (void *) (&len), 4);
9156 (void) memcpy((void *) (gc->pc + 16), (void *) (program), len);
9157 gc->pc += cmdlen;
9158 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9159 (void) __glXFlushRenderBuffer(gc, gc->pc);
9160 }
9161 }
9162 }
9163
9164 #define X_GLrop_ProgramParameters4dvNV 4187
9165 void
9166 __indirect_glProgramParameters4dvNV(GLenum target, GLuint index, GLuint num,
9167 const GLdouble * params)
9168 {
9169 __GLXcontext *const gc = __glXGetCurrentContext();
9170 const GLuint cmdlen = 16 + __GLX_PAD((num * 32));
9171 if (num < 0) {
9172 __glXSetError(gc, GL_INVALID_VALUE);
9173 return;
9174 }
9175 if (__builtin_expect(num >= 0, 1)) {
9176 emit_header(gc->pc, X_GLrop_ProgramParameters4dvNV, cmdlen);
9177 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
9178 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
9179 (void) memcpy((void *) (gc->pc + 12), (void *) (&num), 4);
9180 (void) memcpy((void *) (gc->pc + 16), (void *) (params), (num * 32));
9181 gc->pc += cmdlen;
9182 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9183 (void) __glXFlushRenderBuffer(gc, gc->pc);
9184 }
9185 }
9186 }
9187
9188 #define X_GLrop_ProgramParameters4fvNV 4186
9189 void
9190 __indirect_glProgramParameters4fvNV(GLenum target, GLuint index, GLuint num,
9191 const GLfloat * params)
9192 {
9193 __GLXcontext *const gc = __glXGetCurrentContext();
9194 const GLuint cmdlen = 16 + __GLX_PAD((num * 16));
9195 if (num < 0) {
9196 __glXSetError(gc, GL_INVALID_VALUE);
9197 return;
9198 }
9199 if (__builtin_expect(num >= 0, 1)) {
9200 emit_header(gc->pc, X_GLrop_ProgramParameters4fvNV, cmdlen);
9201 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
9202 (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
9203 (void) memcpy((void *) (gc->pc + 12), (void *) (&num), 4);
9204 (void) memcpy((void *) (gc->pc + 16), (void *) (params), (num * 16));
9205 gc->pc += cmdlen;
9206 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9207 (void) __glXFlushRenderBuffer(gc, gc->pc);
9208 }
9209 }
9210 }
9211
9212 #define X_GLrop_RequestResidentProgramsNV 4182
9213 void
9214 __indirect_glRequestResidentProgramsNV(GLsizei n, const GLuint * ids)
9215 {
9216 __GLXcontext *const gc = __glXGetCurrentContext();
9217 const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
9218 if (n < 0) {
9219 __glXSetError(gc, GL_INVALID_VALUE);
9220 return;
9221 }
9222 if (__builtin_expect(n >= 0, 1)) {
9223 emit_header(gc->pc, X_GLrop_RequestResidentProgramsNV, cmdlen);
9224 (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
9225 (void) memcpy((void *) (gc->pc + 8), (void *) (ids), (n * 4));
9226 gc->pc += cmdlen;
9227 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9228 (void) __glXFlushRenderBuffer(gc, gc->pc);
9229 }
9230 }
9231 }
9232
9233 #define X_GLrop_TrackMatrixNV 4188
9234 void
9235 __indirect_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix,
9236 GLenum transform)
9237 {
9238 __GLXcontext *const gc = __glXGetCurrentContext();
9239 const GLuint cmdlen = 20;
9240 emit_header(gc->pc, X_GLrop_TrackMatrixNV, cmdlen);
9241 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
9242 (void) memcpy((void *) (gc->pc + 8), (void *) (&address), 4);
9243 (void) memcpy((void *) (gc->pc + 12), (void *) (&matrix), 4);
9244 (void) memcpy((void *) (gc->pc + 16), (void *) (&transform), 4);
9245 gc->pc += cmdlen;
9246 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9247 (void) __glXFlushRenderBuffer(gc, gc->pc);
9248 }
9249 }
9250
9251 #define X_GLrop_VertexAttrib1dvNV 4273
9252 void
9253 __indirect_glVertexAttrib1dNV(GLuint index, GLdouble x)
9254 {
9255 __GLXcontext *const gc = __glXGetCurrentContext();
9256 const GLuint cmdlen = 16;
9257 emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
9258 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9259 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
9260 gc->pc += cmdlen;
9261 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9262 (void) __glXFlushRenderBuffer(gc, gc->pc);
9263 }
9264 }
9265
9266 #define X_GLrop_VertexAttrib1dvNV 4273
9267 void
9268 __indirect_glVertexAttrib1dvNV(GLuint index, const GLdouble * v)
9269 {
9270 __GLXcontext *const gc = __glXGetCurrentContext();
9271 const GLuint cmdlen = 16;
9272 emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
9273 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9274 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
9275 gc->pc += cmdlen;
9276 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9277 (void) __glXFlushRenderBuffer(gc, gc->pc);
9278 }
9279 }
9280
9281 #define X_GLrop_VertexAttrib1fvNV 4269
9282 void
9283 __indirect_glVertexAttrib1fNV(GLuint index, GLfloat x)
9284 {
9285 __GLXcontext *const gc = __glXGetCurrentContext();
9286 const GLuint cmdlen = 12;
9287 emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
9288 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9289 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
9290 gc->pc += cmdlen;
9291 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9292 (void) __glXFlushRenderBuffer(gc, gc->pc);
9293 }
9294 }
9295
9296 #define X_GLrop_VertexAttrib1fvNV 4269
9297 void
9298 __indirect_glVertexAttrib1fvNV(GLuint index, const GLfloat * v)
9299 {
9300 __GLXcontext *const gc = __glXGetCurrentContext();
9301 const GLuint cmdlen = 12;
9302 emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
9303 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9304 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
9305 gc->pc += cmdlen;
9306 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9307 (void) __glXFlushRenderBuffer(gc, gc->pc);
9308 }
9309 }
9310
9311 #define X_GLrop_VertexAttrib1svNV 4265
9312 void
9313 __indirect_glVertexAttrib1sNV(GLuint index, GLshort x)
9314 {
9315 __GLXcontext *const gc = __glXGetCurrentContext();
9316 const GLuint cmdlen = 12;
9317 emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
9318 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9319 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
9320 gc->pc += cmdlen;
9321 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9322 (void) __glXFlushRenderBuffer(gc, gc->pc);
9323 }
9324 }
9325
9326 #define X_GLrop_VertexAttrib1svNV 4265
9327 void
9328 __indirect_glVertexAttrib1svNV(GLuint index, const GLshort * v)
9329 {
9330 __GLXcontext *const gc = __glXGetCurrentContext();
9331 const GLuint cmdlen = 12;
9332 emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
9333 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9334 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 2);
9335 gc->pc += cmdlen;
9336 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9337 (void) __glXFlushRenderBuffer(gc, gc->pc);
9338 }
9339 }
9340
9341 #define X_GLrop_VertexAttrib2dvNV 4274
9342 void
9343 __indirect_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y)
9344 {
9345 __GLXcontext *const gc = __glXGetCurrentContext();
9346 const GLuint cmdlen = 24;
9347 emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
9348 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9349 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
9350 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
9351 gc->pc += cmdlen;
9352 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9353 (void) __glXFlushRenderBuffer(gc, gc->pc);
9354 }
9355 }
9356
9357 #define X_GLrop_VertexAttrib2dvNV 4274
9358 void
9359 __indirect_glVertexAttrib2dvNV(GLuint index, const GLdouble * v)
9360 {
9361 __GLXcontext *const gc = __glXGetCurrentContext();
9362 const GLuint cmdlen = 24;
9363 emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
9364 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9365 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
9366 gc->pc += cmdlen;
9367 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9368 (void) __glXFlushRenderBuffer(gc, gc->pc);
9369 }
9370 }
9371
9372 #define X_GLrop_VertexAttrib2fvNV 4270
9373 void
9374 __indirect_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
9375 {
9376 __GLXcontext *const gc = __glXGetCurrentContext();
9377 const GLuint cmdlen = 16;
9378 emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
9379 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9380 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
9381 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
9382 gc->pc += cmdlen;
9383 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9384 (void) __glXFlushRenderBuffer(gc, gc->pc);
9385 }
9386 }
9387
9388 #define X_GLrop_VertexAttrib2fvNV 4270
9389 void
9390 __indirect_glVertexAttrib2fvNV(GLuint index, const GLfloat * v)
9391 {
9392 __GLXcontext *const gc = __glXGetCurrentContext();
9393 const GLuint cmdlen = 16;
9394 emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
9395 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9396 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
9397 gc->pc += cmdlen;
9398 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9399 (void) __glXFlushRenderBuffer(gc, gc->pc);
9400 }
9401 }
9402
9403 #define X_GLrop_VertexAttrib2svNV 4266
9404 void
9405 __indirect_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y)
9406 {
9407 __GLXcontext *const gc = __glXGetCurrentContext();
9408 const GLuint cmdlen = 12;
9409 emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
9410 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9411 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
9412 (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
9413 gc->pc += cmdlen;
9414 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9415 (void) __glXFlushRenderBuffer(gc, gc->pc);
9416 }
9417 }
9418
9419 #define X_GLrop_VertexAttrib2svNV 4266
9420 void
9421 __indirect_glVertexAttrib2svNV(GLuint index, const GLshort * v)
9422 {
9423 __GLXcontext *const gc = __glXGetCurrentContext();
9424 const GLuint cmdlen = 12;
9425 emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
9426 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9427 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
9428 gc->pc += cmdlen;
9429 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9430 (void) __glXFlushRenderBuffer(gc, gc->pc);
9431 }
9432 }
9433
9434 #define X_GLrop_VertexAttrib3dvNV 4275
9435 void
9436 __indirect_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y,
9437 GLdouble z)
9438 {
9439 __GLXcontext *const gc = __glXGetCurrentContext();
9440 const GLuint cmdlen = 32;
9441 emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
9442 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9443 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
9444 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
9445 (void) memcpy((void *) (gc->pc + 24), (void *) (&z), 8);
9446 gc->pc += cmdlen;
9447 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9448 (void) __glXFlushRenderBuffer(gc, gc->pc);
9449 }
9450 }
9451
9452 #define X_GLrop_VertexAttrib3dvNV 4275
9453 void
9454 __indirect_glVertexAttrib3dvNV(GLuint index, const GLdouble * v)
9455 {
9456 __GLXcontext *const gc = __glXGetCurrentContext();
9457 const GLuint cmdlen = 32;
9458 emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
9459 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9460 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 24);
9461 gc->pc += cmdlen;
9462 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9463 (void) __glXFlushRenderBuffer(gc, gc->pc);
9464 }
9465 }
9466
9467 #define X_GLrop_VertexAttrib3fvNV 4271
9468 void
9469 __indirect_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
9470 {
9471 __GLXcontext *const gc = __glXGetCurrentContext();
9472 const GLuint cmdlen = 20;
9473 emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
9474 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9475 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
9476 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
9477 (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4);
9478 gc->pc += cmdlen;
9479 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9480 (void) __glXFlushRenderBuffer(gc, gc->pc);
9481 }
9482 }
9483
9484 #define X_GLrop_VertexAttrib3fvNV 4271
9485 void
9486 __indirect_glVertexAttrib3fvNV(GLuint index, const GLfloat * v)
9487 {
9488 __GLXcontext *const gc = __glXGetCurrentContext();
9489 const GLuint cmdlen = 20;
9490 emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
9491 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9492 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 12);
9493 gc->pc += cmdlen;
9494 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9495 (void) __glXFlushRenderBuffer(gc, gc->pc);
9496 }
9497 }
9498
9499 #define X_GLrop_VertexAttrib3svNV 4267
9500 void
9501 __indirect_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z)
9502 {
9503 __GLXcontext *const gc = __glXGetCurrentContext();
9504 const GLuint cmdlen = 16;
9505 emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
9506 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9507 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
9508 (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
9509 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 2);
9510 gc->pc += cmdlen;
9511 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9512 (void) __glXFlushRenderBuffer(gc, gc->pc);
9513 }
9514 }
9515
9516 #define X_GLrop_VertexAttrib3svNV 4267
9517 void
9518 __indirect_glVertexAttrib3svNV(GLuint index, const GLshort * v)
9519 {
9520 __GLXcontext *const gc = __glXGetCurrentContext();
9521 const GLuint cmdlen = 16;
9522 emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
9523 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9524 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 6);
9525 gc->pc += cmdlen;
9526 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9527 (void) __glXFlushRenderBuffer(gc, gc->pc);
9528 }
9529 }
9530
9531 #define X_GLrop_VertexAttrib4dvNV 4276
9532 void
9533 __indirect_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y,
9534 GLdouble z, GLdouble w)
9535 {
9536 __GLXcontext *const gc = __glXGetCurrentContext();
9537 const GLuint cmdlen = 40;
9538 emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
9539 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9540 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
9541 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
9542 (void) memcpy((void *) (gc->pc + 24), (void *) (&z), 8);
9543 (void) memcpy((void *) (gc->pc + 32), (void *) (&w), 8);
9544 gc->pc += cmdlen;
9545 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9546 (void) __glXFlushRenderBuffer(gc, gc->pc);
9547 }
9548 }
9549
9550 #define X_GLrop_VertexAttrib4dvNV 4276
9551 void
9552 __indirect_glVertexAttrib4dvNV(GLuint index, const GLdouble * v)
9553 {
9554 __GLXcontext *const gc = __glXGetCurrentContext();
9555 const GLuint cmdlen = 40;
9556 emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
9557 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9558 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 32);
9559 gc->pc += cmdlen;
9560 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9561 (void) __glXFlushRenderBuffer(gc, gc->pc);
9562 }
9563 }
9564
9565 #define X_GLrop_VertexAttrib4fvNV 4272
9566 void
9567 __indirect_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z,
9568 GLfloat w)
9569 {
9570 __GLXcontext *const gc = __glXGetCurrentContext();
9571 const GLuint cmdlen = 24;
9572 emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
9573 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9574 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
9575 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
9576 (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4);
9577 (void) memcpy((void *) (gc->pc + 20), (void *) (&w), 4);
9578 gc->pc += cmdlen;
9579 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9580 (void) __glXFlushRenderBuffer(gc, gc->pc);
9581 }
9582 }
9583
9584 #define X_GLrop_VertexAttrib4fvNV 4272
9585 void
9586 __indirect_glVertexAttrib4fvNV(GLuint index, const GLfloat * v)
9587 {
9588 __GLXcontext *const gc = __glXGetCurrentContext();
9589 const GLuint cmdlen = 24;
9590 emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
9591 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9592 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
9593 gc->pc += cmdlen;
9594 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9595 (void) __glXFlushRenderBuffer(gc, gc->pc);
9596 }
9597 }
9598
9599 #define X_GLrop_VertexAttrib4svNV 4268
9600 void
9601 __indirect_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z,
9602 GLshort w)
9603 {
9604 __GLXcontext *const gc = __glXGetCurrentContext();
9605 const GLuint cmdlen = 16;
9606 emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
9607 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9608 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
9609 (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
9610 (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 2);
9611 (void) memcpy((void *) (gc->pc + 14), (void *) (&w), 2);
9612 gc->pc += cmdlen;
9613 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9614 (void) __glXFlushRenderBuffer(gc, gc->pc);
9615 }
9616 }
9617
9618 #define X_GLrop_VertexAttrib4svNV 4268
9619 void
9620 __indirect_glVertexAttrib4svNV(GLuint index, const GLshort * v)
9621 {
9622 __GLXcontext *const gc = __glXGetCurrentContext();
9623 const GLuint cmdlen = 16;
9624 emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
9625 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9626 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
9627 gc->pc += cmdlen;
9628 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9629 (void) __glXFlushRenderBuffer(gc, gc->pc);
9630 }
9631 }
9632
9633 #define X_GLrop_VertexAttrib4ubvNV 4277
9634 void
9635 __indirect_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z,
9636 GLubyte w)
9637 {
9638 __GLXcontext *const gc = __glXGetCurrentContext();
9639 const GLuint cmdlen = 12;
9640 emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
9641 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9642 (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 1);
9643 (void) memcpy((void *) (gc->pc + 9), (void *) (&y), 1);
9644 (void) memcpy((void *) (gc->pc + 10), (void *) (&z), 1);
9645 (void) memcpy((void *) (gc->pc + 11), (void *) (&w), 1);
9646 gc->pc += cmdlen;
9647 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9648 (void) __glXFlushRenderBuffer(gc, gc->pc);
9649 }
9650 }
9651
9652 #define X_GLrop_VertexAttrib4ubvNV 4277
9653 void
9654 __indirect_glVertexAttrib4ubvNV(GLuint index, const GLubyte *v)
9655 {
9656 __GLXcontext *const gc = __glXGetCurrentContext();
9657 const GLuint cmdlen = 12;
9658 emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
9659 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9660 (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
9661 gc->pc += cmdlen;
9662 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9663 (void) __glXFlushRenderBuffer(gc, gc->pc);
9664 }
9665 }
9666
9667 #define X_GLrop_VertexAttribs1dvNV 4210
9668 void
9669 __indirect_glVertexAttribs1dvNV(GLuint index, GLsizei n, const GLdouble * v)
9670 {
9671 __GLXcontext *const gc = __glXGetCurrentContext();
9672 const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
9673 if (n < 0) {
9674 __glXSetError(gc, GL_INVALID_VALUE);
9675 return;
9676 }
9677 if (__builtin_expect(n >= 0, 1)) {
9678 emit_header(gc->pc, X_GLrop_VertexAttribs1dvNV, cmdlen);
9679 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9680 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9681 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 8));
9682 gc->pc += cmdlen;
9683 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9684 (void) __glXFlushRenderBuffer(gc, gc->pc);
9685 }
9686 }
9687 }
9688
9689 #define X_GLrop_VertexAttribs1fvNV 4206
9690 void
9691 __indirect_glVertexAttribs1fvNV(GLuint index, GLsizei n, const GLfloat * v)
9692 {
9693 __GLXcontext *const gc = __glXGetCurrentContext();
9694 const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
9695 if (n < 0) {
9696 __glXSetError(gc, GL_INVALID_VALUE);
9697 return;
9698 }
9699 if (__builtin_expect(n >= 0, 1)) {
9700 emit_header(gc->pc, X_GLrop_VertexAttribs1fvNV, cmdlen);
9701 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9702 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9703 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 4));
9704 gc->pc += cmdlen;
9705 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9706 (void) __glXFlushRenderBuffer(gc, gc->pc);
9707 }
9708 }
9709 }
9710
9711 #define X_GLrop_VertexAttribs1svNV 4202
9712 void
9713 __indirect_glVertexAttribs1svNV(GLuint index, GLsizei n, const GLshort * v)
9714 {
9715 __GLXcontext *const gc = __glXGetCurrentContext();
9716 const GLuint cmdlen = 12 + __GLX_PAD((n * 2));
9717 if (n < 0) {
9718 __glXSetError(gc, GL_INVALID_VALUE);
9719 return;
9720 }
9721 if (__builtin_expect(n >= 0, 1)) {
9722 emit_header(gc->pc, X_GLrop_VertexAttribs1svNV, cmdlen);
9723 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9724 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9725 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 2));
9726 gc->pc += cmdlen;
9727 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9728 (void) __glXFlushRenderBuffer(gc, gc->pc);
9729 }
9730 }
9731 }
9732
9733 #define X_GLrop_VertexAttribs2dvNV 4211
9734 void
9735 __indirect_glVertexAttribs2dvNV(GLuint index, GLsizei n, const GLdouble * v)
9736 {
9737 __GLXcontext *const gc = __glXGetCurrentContext();
9738 const GLuint cmdlen = 12 + __GLX_PAD((n * 16));
9739 if (n < 0) {
9740 __glXSetError(gc, GL_INVALID_VALUE);
9741 return;
9742 }
9743 if (__builtin_expect(n >= 0, 1)) {
9744 emit_header(gc->pc, X_GLrop_VertexAttribs2dvNV, cmdlen);
9745 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9746 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9747 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 16));
9748 gc->pc += cmdlen;
9749 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9750 (void) __glXFlushRenderBuffer(gc, gc->pc);
9751 }
9752 }
9753 }
9754
9755 #define X_GLrop_VertexAttribs2fvNV 4207
9756 void
9757 __indirect_glVertexAttribs2fvNV(GLuint index, GLsizei n, const GLfloat * v)
9758 {
9759 __GLXcontext *const gc = __glXGetCurrentContext();
9760 const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
9761 if (n < 0) {
9762 __glXSetError(gc, GL_INVALID_VALUE);
9763 return;
9764 }
9765 if (__builtin_expect(n >= 0, 1)) {
9766 emit_header(gc->pc, X_GLrop_VertexAttribs2fvNV, cmdlen);
9767 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9768 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9769 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 8));
9770 gc->pc += cmdlen;
9771 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9772 (void) __glXFlushRenderBuffer(gc, gc->pc);
9773 }
9774 }
9775 }
9776
9777 #define X_GLrop_VertexAttribs2svNV 4203
9778 void
9779 __indirect_glVertexAttribs2svNV(GLuint index, GLsizei n, const GLshort * v)
9780 {
9781 __GLXcontext *const gc = __glXGetCurrentContext();
9782 const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
9783 if (n < 0) {
9784 __glXSetError(gc, GL_INVALID_VALUE);
9785 return;
9786 }
9787 if (__builtin_expect(n >= 0, 1)) {
9788 emit_header(gc->pc, X_GLrop_VertexAttribs2svNV, cmdlen);
9789 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9790 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9791 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 4));
9792 gc->pc += cmdlen;
9793 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9794 (void) __glXFlushRenderBuffer(gc, gc->pc);
9795 }
9796 }
9797 }
9798
9799 #define X_GLrop_VertexAttribs3dvNV 4212
9800 void
9801 __indirect_glVertexAttribs3dvNV(GLuint index, GLsizei n, const GLdouble * v)
9802 {
9803 __GLXcontext *const gc = __glXGetCurrentContext();
9804 const GLuint cmdlen = 12 + __GLX_PAD((n * 24));
9805 if (n < 0) {
9806 __glXSetError(gc, GL_INVALID_VALUE);
9807 return;
9808 }
9809 if (__builtin_expect(n >= 0, 1)) {
9810 emit_header(gc->pc, X_GLrop_VertexAttribs3dvNV, cmdlen);
9811 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9812 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9813 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 24));
9814 gc->pc += cmdlen;
9815 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9816 (void) __glXFlushRenderBuffer(gc, gc->pc);
9817 }
9818 }
9819 }
9820
9821 #define X_GLrop_VertexAttribs3fvNV 4208
9822 void
9823 __indirect_glVertexAttribs3fvNV(GLuint index, GLsizei n, const GLfloat * v)
9824 {
9825 __GLXcontext *const gc = __glXGetCurrentContext();
9826 const GLuint cmdlen = 12 + __GLX_PAD((n * 12));
9827 if (n < 0) {
9828 __glXSetError(gc, GL_INVALID_VALUE);
9829 return;
9830 }
9831 if (__builtin_expect(n >= 0, 1)) {
9832 emit_header(gc->pc, X_GLrop_VertexAttribs3fvNV, cmdlen);
9833 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9834 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9835 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 12));
9836 gc->pc += cmdlen;
9837 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9838 (void) __glXFlushRenderBuffer(gc, gc->pc);
9839 }
9840 }
9841 }
9842
9843 #define X_GLrop_VertexAttribs3svNV 4204
9844 void
9845 __indirect_glVertexAttribs3svNV(GLuint index, GLsizei n, const GLshort * v)
9846 {
9847 __GLXcontext *const gc = __glXGetCurrentContext();
9848 const GLuint cmdlen = 12 + __GLX_PAD((n * 6));
9849 if (n < 0) {
9850 __glXSetError(gc, GL_INVALID_VALUE);
9851 return;
9852 }
9853 if (__builtin_expect(n >= 0, 1)) {
9854 emit_header(gc->pc, X_GLrop_VertexAttribs3svNV, cmdlen);
9855 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9856 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9857 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 6));
9858 gc->pc += cmdlen;
9859 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9860 (void) __glXFlushRenderBuffer(gc, gc->pc);
9861 }
9862 }
9863 }
9864
9865 #define X_GLrop_VertexAttribs4dvNV 4213
9866 void
9867 __indirect_glVertexAttribs4dvNV(GLuint index, GLsizei n, const GLdouble * v)
9868 {
9869 __GLXcontext *const gc = __glXGetCurrentContext();
9870 const GLuint cmdlen = 12 + __GLX_PAD((n * 32));
9871 if (n < 0) {
9872 __glXSetError(gc, GL_INVALID_VALUE);
9873 return;
9874 }
9875 if (__builtin_expect(n >= 0, 1)) {
9876 emit_header(gc->pc, X_GLrop_VertexAttribs4dvNV, cmdlen);
9877 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9878 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9879 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 32));
9880 gc->pc += cmdlen;
9881 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9882 (void) __glXFlushRenderBuffer(gc, gc->pc);
9883 }
9884 }
9885 }
9886
9887 #define X_GLrop_VertexAttribs4fvNV 4209
9888 void
9889 __indirect_glVertexAttribs4fvNV(GLuint index, GLsizei n, const GLfloat * v)
9890 {
9891 __GLXcontext *const gc = __glXGetCurrentContext();
9892 const GLuint cmdlen = 12 + __GLX_PAD((n * 16));
9893 if (n < 0) {
9894 __glXSetError(gc, GL_INVALID_VALUE);
9895 return;
9896 }
9897 if (__builtin_expect(n >= 0, 1)) {
9898 emit_header(gc->pc, X_GLrop_VertexAttribs4fvNV, cmdlen);
9899 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9900 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9901 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 16));
9902 gc->pc += cmdlen;
9903 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9904 (void) __glXFlushRenderBuffer(gc, gc->pc);
9905 }
9906 }
9907 }
9908
9909 #define X_GLrop_VertexAttribs4svNV 4205
9910 void
9911 __indirect_glVertexAttribs4svNV(GLuint index, GLsizei n, const GLshort * v)
9912 {
9913 __GLXcontext *const gc = __glXGetCurrentContext();
9914 const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
9915 if (n < 0) {
9916 __glXSetError(gc, GL_INVALID_VALUE);
9917 return;
9918 }
9919 if (__builtin_expect(n >= 0, 1)) {
9920 emit_header(gc->pc, X_GLrop_VertexAttribs4svNV, cmdlen);
9921 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9922 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9923 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 8));
9924 gc->pc += cmdlen;
9925 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9926 (void) __glXFlushRenderBuffer(gc, gc->pc);
9927 }
9928 }
9929 }
9930
9931 #define X_GLrop_VertexAttribs4ubvNV 4214
9932 void
9933 __indirect_glVertexAttribs4ubvNV(GLuint index, GLsizei n, const GLubyte *v)
9934 {
9935 __GLXcontext *const gc = __glXGetCurrentContext();
9936 const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
9937 if (n < 0) {
9938 __glXSetError(gc, GL_INVALID_VALUE);
9939 return;
9940 }
9941 if (__builtin_expect(n >= 0, 1)) {
9942 emit_header(gc->pc, X_GLrop_VertexAttribs4ubvNV, cmdlen);
9943 (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
9944 (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
9945 (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 4));
9946 gc->pc += cmdlen;
9947 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9948 (void) __glXFlushRenderBuffer(gc, gc->pc);
9949 }
9950 }
9951 }
9952
9953 #define X_GLrop_PointParameteriNV 4221
9954 void
9955 __indirect_glPointParameteriNV(GLenum pname, GLint param)
9956 {
9957 __GLXcontext *const gc = __glXGetCurrentContext();
9958 const GLuint cmdlen = 12;
9959 emit_header(gc->pc, X_GLrop_PointParameteriNV, cmdlen);
9960 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
9961 (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
9962 gc->pc += cmdlen;
9963 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9964 (void) __glXFlushRenderBuffer(gc, gc->pc);
9965 }
9966 }
9967
9968 #define X_GLrop_PointParameterivNV 4222
9969 void
9970 __indirect_glPointParameterivNV(GLenum pname, const GLint * params)
9971 {
9972 __GLXcontext *const gc = __glXGetCurrentContext();
9973 const GLuint compsize = __glPointParameterivNV_size(pname);
9974 const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
9975 emit_header(gc->pc, X_GLrop_PointParameterivNV, cmdlen);
9976 (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
9977 (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
9978 gc->pc += cmdlen;
9979 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9980 (void) __glXFlushRenderBuffer(gc, gc->pc);
9981 }
9982 }
9983
9984 #define X_GLrop_ActiveStencilFaceEXT 4220
9985 void
9986 __indirect_glActiveStencilFaceEXT(GLenum face)
9987 {
9988 __GLXcontext *const gc = __glXGetCurrentContext();
9989 const GLuint cmdlen = 8;
9990 emit_header(gc->pc, X_GLrop_ActiveStencilFaceEXT, cmdlen);
9991 (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
9992 gc->pc += cmdlen;
9993 if (__builtin_expect(gc->pc > gc->limit, 0)) {
9994 (void) __glXFlushRenderBuffer(gc, gc->pc);
9995 }
9996 }
9997
9998 #define X_GLvop_GetProgramNamedParameterdvNV 1311
9999 void
10000 __indirect_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len,
10001 const GLubyte *name,
10002 GLdouble * params)
10003 {
10004 __GLXcontext *const gc = __glXGetCurrentContext();
10005 Display *const dpy = gc->currentDpy;
10006 const GLuint cmdlen = 8 + __GLX_PAD(len);
10007 if (len < 0) {
10008 __glXSetError(gc, GL_INVALID_VALUE);
10009 return;
10010 }
10011 if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
10012 GLubyte const *pc =
10013 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10014 X_GLvop_GetProgramNamedParameterdvNV,
10015 cmdlen);
10016 (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
10017 (void) memcpy((void *) (pc + 4), (void *) (&len), 4);
10018 (void) memcpy((void *) (pc + 8), (void *) (name), len);
10019 (void) __glXReadReply(dpy, 8, params, GL_TRUE);
10020 UnlockDisplay(dpy);
10021 SyncHandle();
10022 }
10023 return;
10024 }
10025
10026 #define X_GLvop_GetProgramNamedParameterfvNV 1310
10027 void
10028 __indirect_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len,
10029 const GLubyte *name,
10030 GLfloat * params)
10031 {
10032 __GLXcontext *const gc = __glXGetCurrentContext();
10033 Display *const dpy = gc->currentDpy;
10034 const GLuint cmdlen = 8 + __GLX_PAD(len);
10035 if (len < 0) {
10036 __glXSetError(gc, GL_INVALID_VALUE);
10037 return;
10038 }
10039 if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
10040 GLubyte const *pc =
10041 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10042 X_GLvop_GetProgramNamedParameterfvNV,
10043 cmdlen);
10044 (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
10045 (void) memcpy((void *) (pc + 4), (void *) (&len), 4);
10046 (void) memcpy((void *) (pc + 8), (void *) (name), len);
10047 (void) __glXReadReply(dpy, 4, params, GL_TRUE);
10048 UnlockDisplay(dpy);
10049 SyncHandle();
10050 }
10051 return;
10052 }
10053
10054 #define X_GLrop_ProgramNamedParameter4dvNV 4219
10055 void
10056 __indirect_glProgramNamedParameter4dNV(GLuint id, GLsizei len,
10057 const GLubyte *name, GLdouble x,
10058 GLdouble y, GLdouble z, GLdouble w)
10059 {
10060 __GLXcontext *const gc = __glXGetCurrentContext();
10061 const GLuint cmdlen = 44 + __GLX_PAD(len);
10062 if (len < 0) {
10063 __glXSetError(gc, GL_INVALID_VALUE);
10064 return;
10065 }
10066 if (__builtin_expect(len >= 0, 1)) {
10067 emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
10068 (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
10069 (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
10070 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
10071 (void) memcpy((void *) (gc->pc + 28), (void *) (&w), 8);
10072 (void) memcpy((void *) (gc->pc + 36), (void *) (&id), 4);
10073 (void) memcpy((void *) (gc->pc + 40), (void *) (&len), 4);
10074 (void) memcpy((void *) (gc->pc + 44), (void *) (name), len);
10075 gc->pc += cmdlen;
10076 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10077 (void) __glXFlushRenderBuffer(gc, gc->pc);
10078 }
10079 }
10080 }
10081
10082 #define X_GLrop_ProgramNamedParameter4dvNV 4219
10083 void
10084 __indirect_glProgramNamedParameter4dvNV(GLuint id, GLsizei len,
10085 const GLubyte *name,
10086 const GLdouble * v)
10087 {
10088 __GLXcontext *const gc = __glXGetCurrentContext();
10089 const GLuint cmdlen = 44 + __GLX_PAD(len);
10090 if (len < 0) {
10091 __glXSetError(gc, GL_INVALID_VALUE);
10092 return;
10093 }
10094 if (__builtin_expect(len >= 0, 1)) {
10095 emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
10096 (void) memcpy((void *) (gc->pc + 4), (void *) (v), 32);
10097 (void) memcpy((void *) (gc->pc + 36), (void *) (&id), 4);
10098 (void) memcpy((void *) (gc->pc + 40), (void *) (&len), 4);
10099 (void) memcpy((void *) (gc->pc + 44), (void *) (name), len);
10100 gc->pc += cmdlen;
10101 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10102 (void) __glXFlushRenderBuffer(gc, gc->pc);
10103 }
10104 }
10105 }
10106
10107 #define X_GLrop_ProgramNamedParameter4fvNV 4218
10108 void
10109 __indirect_glProgramNamedParameter4fNV(GLuint id, GLsizei len,
10110 const GLubyte *name, GLfloat x,
10111 GLfloat y, GLfloat z, GLfloat w)
10112 {
10113 __GLXcontext *const gc = __glXGetCurrentContext();
10114 const GLuint cmdlen = 28 + __GLX_PAD(len);
10115 if (len < 0) {
10116 __glXSetError(gc, GL_INVALID_VALUE);
10117 return;
10118 }
10119 if (__builtin_expect(len >= 0, 1)) {
10120 emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
10121 (void) memcpy((void *) (gc->pc + 4), (void *) (&id), 4);
10122 (void) memcpy((void *) (gc->pc + 8), (void *) (&len), 4);
10123 (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
10124 (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
10125 (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 4);
10126 (void) memcpy((void *) (gc->pc + 24), (void *) (&w), 4);
10127 (void) memcpy((void *) (gc->pc + 28), (void *) (name), len);
10128 gc->pc += cmdlen;
10129 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10130 (void) __glXFlushRenderBuffer(gc, gc->pc);
10131 }
10132 }
10133 }
10134
10135 #define X_GLrop_ProgramNamedParameter4fvNV 4218
10136 void
10137 __indirect_glProgramNamedParameter4fvNV(GLuint id, GLsizei len,
10138 const GLubyte *name,
10139 const GLfloat * v)
10140 {
10141 __GLXcontext *const gc = __glXGetCurrentContext();
10142 const GLuint cmdlen = 28 + __GLX_PAD(len);
10143 if (len < 0) {
10144 __glXSetError(gc, GL_INVALID_VALUE);
10145 return;
10146 }
10147 if (__builtin_expect(len >= 0, 1)) {
10148 emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
10149 (void) memcpy((void *) (gc->pc + 4), (void *) (&id), 4);
10150 (void) memcpy((void *) (gc->pc + 8), (void *) (&len), 4);
10151 (void) memcpy((void *) (gc->pc + 12), (void *) (v), 16);
10152 (void) memcpy((void *) (gc->pc + 28), (void *) (name), len);
10153 gc->pc += cmdlen;
10154 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10155 (void) __glXFlushRenderBuffer(gc, gc->pc);
10156 }
10157 }
10158 }
10159
10160 #define X_GLrop_BlendEquationSeparateEXT 4228
10161 void
10162 __indirect_glBlendEquationSeparateEXT(GLenum modeRGB, GLenum modeA)
10163 {
10164 __GLXcontext *const gc = __glXGetCurrentContext();
10165 const GLuint cmdlen = 12;
10166 emit_header(gc->pc, X_GLrop_BlendEquationSeparateEXT, cmdlen);
10167 (void) memcpy((void *) (gc->pc + 4), (void *) (&modeRGB), 4);
10168 (void) memcpy((void *) (gc->pc + 8), (void *) (&modeA), 4);
10169 gc->pc += cmdlen;
10170 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10171 (void) __glXFlushRenderBuffer(gc, gc->pc);
10172 }
10173 }
10174
10175 #define X_GLrop_BindFramebufferEXT 4319
10176 void
10177 __indirect_glBindFramebufferEXT(GLenum target, GLuint framebuffer)
10178 {
10179 __GLXcontext *const gc = __glXGetCurrentContext();
10180 const GLuint cmdlen = 12;
10181 emit_header(gc->pc, X_GLrop_BindFramebufferEXT, cmdlen);
10182 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10183 (void) memcpy((void *) (gc->pc + 8), (void *) (&framebuffer), 4);
10184 gc->pc += cmdlen;
10185 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10186 (void) __glXFlushRenderBuffer(gc, gc->pc);
10187 }
10188 }
10189
10190 #define X_GLrop_BindRenderbufferEXT 4316
10191 void
10192 __indirect_glBindRenderbufferEXT(GLenum target, GLuint renderbuffer)
10193 {
10194 __GLXcontext *const gc = __glXGetCurrentContext();
10195 const GLuint cmdlen = 12;
10196 emit_header(gc->pc, X_GLrop_BindRenderbufferEXT, cmdlen);
10197 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10198 (void) memcpy((void *) (gc->pc + 8), (void *) (&renderbuffer), 4);
10199 gc->pc += cmdlen;
10200 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10201 (void) __glXFlushRenderBuffer(gc, gc->pc);
10202 }
10203 }
10204
10205 #define X_GLvop_CheckFramebufferStatusEXT 1427
10206 GLenum
10207 __indirect_glCheckFramebufferStatusEXT(GLenum target)
10208 {
10209 __GLXcontext *const gc = __glXGetCurrentContext();
10210 Display *const dpy = gc->currentDpy;
10211 GLenum retval = (GLenum) 0;
10212 const GLuint cmdlen = 4;
10213 if (__builtin_expect(dpy != NULL, 1)) {
10214 GLubyte const *pc =
10215 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10216 X_GLvop_CheckFramebufferStatusEXT,
10217 cmdlen);
10218 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
10219 retval = (GLenum) __glXReadReply(dpy, 0, NULL, GL_FALSE);
10220 UnlockDisplay(dpy);
10221 SyncHandle();
10222 }
10223 return retval;
10224 }
10225
10226 #define X_GLrop_DeleteFramebuffersEXT 4320
10227 void
10228 __indirect_glDeleteFramebuffersEXT(GLsizei n, const GLuint * framebuffers)
10229 {
10230 __GLXcontext *const gc = __glXGetCurrentContext();
10231 const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
10232 if (n < 0) {
10233 __glXSetError(gc, GL_INVALID_VALUE);
10234 return;
10235 }
10236 if (__builtin_expect(n >= 0, 1)) {
10237 emit_header(gc->pc, X_GLrop_DeleteFramebuffersEXT, cmdlen);
10238 (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
10239 (void) memcpy((void *) (gc->pc + 8), (void *) (framebuffers),
10240 (n * 4));
10241 gc->pc += cmdlen;
10242 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10243 (void) __glXFlushRenderBuffer(gc, gc->pc);
10244 }
10245 }
10246 }
10247
10248 #define X_GLrop_DeleteRenderbuffersEXT 4317
10249 void
10250 __indirect_glDeleteRenderbuffersEXT(GLsizei n, const GLuint * renderbuffers)
10251 {
10252 __GLXcontext *const gc = __glXGetCurrentContext();
10253 const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
10254 if (n < 0) {
10255 __glXSetError(gc, GL_INVALID_VALUE);
10256 return;
10257 }
10258 if (__builtin_expect(n >= 0, 1)) {
10259 emit_header(gc->pc, X_GLrop_DeleteRenderbuffersEXT, cmdlen);
10260 (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
10261 (void) memcpy((void *) (gc->pc + 8), (void *) (renderbuffers),
10262 (n * 4));
10263 gc->pc += cmdlen;
10264 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10265 (void) __glXFlushRenderBuffer(gc, gc->pc);
10266 }
10267 }
10268 }
10269
10270 #define X_GLrop_FramebufferRenderbufferEXT 4324
10271 void
10272 __indirect_glFramebufferRenderbufferEXT(GLenum target, GLenum attachment,
10273 GLenum renderbuffertarget,
10274 GLuint renderbuffer)
10275 {
10276 __GLXcontext *const gc = __glXGetCurrentContext();
10277 const GLuint cmdlen = 20;
10278 emit_header(gc->pc, X_GLrop_FramebufferRenderbufferEXT, cmdlen);
10279 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10280 (void) memcpy((void *) (gc->pc + 8), (void *) (&attachment), 4);
10281 (void) memcpy((void *) (gc->pc + 12), (void *) (&renderbuffertarget), 4);
10282 (void) memcpy((void *) (gc->pc + 16), (void *) (&renderbuffer), 4);
10283 gc->pc += cmdlen;
10284 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10285 (void) __glXFlushRenderBuffer(gc, gc->pc);
10286 }
10287 }
10288
10289 #define X_GLrop_FramebufferTexture1DEXT 4321
10290 void
10291 __indirect_glFramebufferTexture1DEXT(GLenum target, GLenum attachment,
10292 GLenum textarget, GLuint texture,
10293 GLint level)
10294 {
10295 __GLXcontext *const gc = __glXGetCurrentContext();
10296 const GLuint cmdlen = 24;
10297 emit_header(gc->pc, X_GLrop_FramebufferTexture1DEXT, cmdlen);
10298 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10299 (void) memcpy((void *) (gc->pc + 8), (void *) (&attachment), 4);
10300 (void) memcpy((void *) (gc->pc + 12), (void *) (&textarget), 4);
10301 (void) memcpy((void *) (gc->pc + 16), (void *) (&texture), 4);
10302 (void) memcpy((void *) (gc->pc + 20), (void *) (&level), 4);
10303 gc->pc += cmdlen;
10304 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10305 (void) __glXFlushRenderBuffer(gc, gc->pc);
10306 }
10307 }
10308
10309 #define X_GLrop_FramebufferTexture2DEXT 4322
10310 void
10311 __indirect_glFramebufferTexture2DEXT(GLenum target, GLenum attachment,
10312 GLenum textarget, GLuint texture,
10313 GLint level)
10314 {
10315 __GLXcontext *const gc = __glXGetCurrentContext();
10316 const GLuint cmdlen = 24;
10317 emit_header(gc->pc, X_GLrop_FramebufferTexture2DEXT, cmdlen);
10318 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10319 (void) memcpy((void *) (gc->pc + 8), (void *) (&attachment), 4);
10320 (void) memcpy((void *) (gc->pc + 12), (void *) (&textarget), 4);
10321 (void) memcpy((void *) (gc->pc + 16), (void *) (&texture), 4);
10322 (void) memcpy((void *) (gc->pc + 20), (void *) (&level), 4);
10323 gc->pc += cmdlen;
10324 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10325 (void) __glXFlushRenderBuffer(gc, gc->pc);
10326 }
10327 }
10328
10329 #define X_GLrop_FramebufferTexture3DEXT 4323
10330 void
10331 __indirect_glFramebufferTexture3DEXT(GLenum target, GLenum attachment,
10332 GLenum textarget, GLuint texture,
10333 GLint level, GLint zoffset)
10334 {
10335 __GLXcontext *const gc = __glXGetCurrentContext();
10336 const GLuint cmdlen = 28;
10337 emit_header(gc->pc, X_GLrop_FramebufferTexture3DEXT, cmdlen);
10338 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10339 (void) memcpy((void *) (gc->pc + 8), (void *) (&attachment), 4);
10340 (void) memcpy((void *) (gc->pc + 12), (void *) (&textarget), 4);
10341 (void) memcpy((void *) (gc->pc + 16), (void *) (&texture), 4);
10342 (void) memcpy((void *) (gc->pc + 20), (void *) (&level), 4);
10343 (void) memcpy((void *) (gc->pc + 24), (void *) (&zoffset), 4);
10344 gc->pc += cmdlen;
10345 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10346 (void) __glXFlushRenderBuffer(gc, gc->pc);
10347 }
10348 }
10349
10350 #define X_GLvop_GenFramebuffersEXT 1426
10351 void
10352 __indirect_glGenFramebuffersEXT(GLsizei n, GLuint * framebuffers)
10353 {
10354 __GLXcontext *const gc = __glXGetCurrentContext();
10355 Display *const dpy = gc->currentDpy;
10356 const GLuint cmdlen = 4;
10357 if (n < 0) {
10358 __glXSetError(gc, GL_INVALID_VALUE);
10359 return;
10360 }
10361 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
10362 GLubyte const *pc =
10363 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10364 X_GLvop_GenFramebuffersEXT, cmdlen);
10365 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
10366 (void) __glXReadReply(dpy, 4, framebuffers, GL_TRUE);
10367 UnlockDisplay(dpy);
10368 SyncHandle();
10369 }
10370 return;
10371 }
10372
10373 #define X_GLvop_GenRenderbuffersEXT 1423
10374 void
10375 __indirect_glGenRenderbuffersEXT(GLsizei n, GLuint * renderbuffers)
10376 {
10377 __GLXcontext *const gc = __glXGetCurrentContext();
10378 Display *const dpy = gc->currentDpy;
10379 const GLuint cmdlen = 4;
10380 if (n < 0) {
10381 __glXSetError(gc, GL_INVALID_VALUE);
10382 return;
10383 }
10384 if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
10385 GLubyte const *pc =
10386 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10387 X_GLvop_GenRenderbuffersEXT, cmdlen);
10388 (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
10389 (void) __glXReadReply(dpy, 4, renderbuffers, GL_TRUE);
10390 UnlockDisplay(dpy);
10391 SyncHandle();
10392 }
10393 return;
10394 }
10395
10396 #define X_GLrop_GenerateMipmapEXT 4325
10397 void
10398 __indirect_glGenerateMipmapEXT(GLenum target)
10399 {
10400 __GLXcontext *const gc = __glXGetCurrentContext();
10401 const GLuint cmdlen = 8;
10402 emit_header(gc->pc, X_GLrop_GenerateMipmapEXT, cmdlen);
10403 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10404 gc->pc += cmdlen;
10405 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10406 (void) __glXFlushRenderBuffer(gc, gc->pc);
10407 }
10408 }
10409
10410 #define X_GLvop_GetFramebufferAttachmentParameterivEXT 1428
10411 void
10412 __indirect_glGetFramebufferAttachmentParameterivEXT(GLenum target,
10413 GLenum attachment,
10414 GLenum pname,
10415 GLint * params)
10416 {
10417 __GLXcontext *const gc = __glXGetCurrentContext();
10418 Display *const dpy = gc->currentDpy;
10419 const GLuint cmdlen = 12;
10420 if (__builtin_expect(dpy != NULL, 1)) {
10421 GLubyte const *pc =
10422 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10423 X_GLvop_GetFramebufferAttachmentParameterivEXT,
10424 cmdlen);
10425 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
10426 (void) memcpy((void *) (pc + 4), (void *) (&attachment), 4);
10427 (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
10428 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
10429 UnlockDisplay(dpy);
10430 SyncHandle();
10431 }
10432 return;
10433 }
10434
10435 #define X_GLvop_GetRenderbufferParameterivEXT 1424
10436 void
10437 __indirect_glGetRenderbufferParameterivEXT(GLenum target, GLenum pname,
10438 GLint * params)
10439 {
10440 __GLXcontext *const gc = __glXGetCurrentContext();
10441 Display *const dpy = gc->currentDpy;
10442 const GLuint cmdlen = 8;
10443 if (__builtin_expect(dpy != NULL, 1)) {
10444 GLubyte const *pc =
10445 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10446 X_GLvop_GetRenderbufferParameterivEXT,
10447 cmdlen);
10448 (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
10449 (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
10450 (void) __glXReadReply(dpy, 4, params, GL_FALSE);
10451 UnlockDisplay(dpy);
10452 SyncHandle();
10453 }
10454 return;
10455 }
10456
10457 #define X_GLvop_IsFramebufferEXT 1425
10458 GLboolean
10459 __indirect_glIsFramebufferEXT(GLuint framebuffer)
10460 {
10461 __GLXcontext *const gc = __glXGetCurrentContext();
10462 Display *const dpy = gc->currentDpy;
10463 GLboolean retval = (GLboolean) 0;
10464 const GLuint cmdlen = 4;
10465 if (__builtin_expect(dpy != NULL, 1)) {
10466 GLubyte const *pc =
10467 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10468 X_GLvop_IsFramebufferEXT, cmdlen);
10469 (void) memcpy((void *) (pc + 0), (void *) (&framebuffer), 4);
10470 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
10471 UnlockDisplay(dpy);
10472 SyncHandle();
10473 }
10474 return retval;
10475 }
10476
10477 #define X_GLvop_IsRenderbufferEXT 1422
10478 GLboolean
10479 __indirect_glIsRenderbufferEXT(GLuint renderbuffer)
10480 {
10481 __GLXcontext *const gc = __glXGetCurrentContext();
10482 Display *const dpy = gc->currentDpy;
10483 GLboolean retval = (GLboolean) 0;
10484 const GLuint cmdlen = 4;
10485 if (__builtin_expect(dpy != NULL, 1)) {
10486 GLubyte const *pc =
10487 __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
10488 X_GLvop_IsRenderbufferEXT, cmdlen);
10489 (void) memcpy((void *) (pc + 0), (void *) (&renderbuffer), 4);
10490 retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
10491 UnlockDisplay(dpy);
10492 SyncHandle();
10493 }
10494 return retval;
10495 }
10496
10497 #define X_GLrop_RenderbufferStorageEXT 4318
10498 void
10499 __indirect_glRenderbufferStorageEXT(GLenum target, GLenum internalformat,
10500 GLsizei width, GLsizei height)
10501 {
10502 __GLXcontext *const gc = __glXGetCurrentContext();
10503 const GLuint cmdlen = 20;
10504 emit_header(gc->pc, X_GLrop_RenderbufferStorageEXT, cmdlen);
10505 (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
10506 (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4);
10507 (void) memcpy((void *) (gc->pc + 12), (void *) (&width), 4);
10508 (void) memcpy((void *) (gc->pc + 16), (void *) (&height), 4);
10509 gc->pc += cmdlen;
10510 if (__builtin_expect(gc->pc > gc->limit, 0)) {
10511 (void) __glXFlushRenderBuffer(gc, gc->pc);
10512 }
10513 }
10514
10515
10516 # undef FASTCALL
10517 # undef NOINLINE