/* DO NOT EDIT - This file generated automatically by glX_proto_send.py (from Mesa) script */
/*
- * (C) Copyright IBM Corporation 2004
+ * (C) Copyright IBM Corporation 2004, 2005
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
#include <GL/gl.h>
#include "indirect.h"
#include "glxclient.h"
-#include "size.h"
+#include "indirect_size.h"
#include <GL/glxproto.h>
#define __GLX_PAD(n) (((n) + 3) & ~3)
# define NOINLINE
# endif
+#if !defined __GNUC__ || __GNUC__ < 3
+# define __builtin_expect(x, y) x
+#endif
+
/* If the size and opcode values are known at compile-time, this will, on
* x86 at least, emit them with a single instruction.
*/
(void) _XReply(dpy, (xReply *) & reply, 0, False);
if (size != 0) {
- if ((reply.size >= 1) || reply_is_always_array) {
+ if ((reply.length > 0) || reply_is_always_array) {
const GLint bytes = (reply_is_always_array)
? (4 * reply.length) : (reply.size * size);
const GLint extra = 4 - (bytes & 3);
_XRead(dpy, dest, bytes);
- if ( extra != 0 ) {
+ if ( extra < 4 ) {
_XEatData(dpy, extra);
}
}
#define X_GLXSingle 0
-static NOINLINE GLubyte *
+static NOINLINE FASTCALL GLubyte *
setup_single_request( __GLXcontext * gc, GLint sop, GLint cmdlen )
{
xGLXSingleReq * req;
return (GLubyte *)(req) + sz_xGLXSingleReq;
}
-static NOINLINE GLubyte *
+static NOINLINE FASTCALL GLubyte *
setup_vendor_request( __GLXcontext * gc, GLint code, GLint vop, GLint cmdlen )
{
xGLXVendorPrivateReq * req;
return (GLubyte *)(req) + sz_xGLXVendorPrivateReq;
}
+const GLuint __glXDefaultPixelStore[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 };
+
+#define zero (__glXDefaultPixelStore+0)
+#define one (__glXDefaultPixelStore+8)
+#define default_pixel_store_1D (__glXDefaultPixelStore+4)
+#define default_pixel_store_1D_size 20
+#define default_pixel_store_2D (__glXDefaultPixelStore+4)
+#define default_pixel_store_2D_size 20
+#define default_pixel_store_3D (__glXDefaultPixelStore+0)
+#define default_pixel_store_3D_size 36
+#define default_pixel_store_4D (__glXDefaultPixelStore+0)
+#define default_pixel_store_4D_size 36
+
static FASTCALL NOINLINE void
generic_3_byte( GLint rop, const void * ptr )
{
__GLXcontext * const gc = __glXGetCurrentContext();
- const GLuint cmdlen = 7;
+ const GLuint cmdlen = 8;
emit_header(gc->pc, rop, cmdlen);
- (void) memcpy((void *)(gc->pc + 4), ptr, 3);
+ (void) memcpy((void *)(gc->pc + 4), ptr, 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
static FASTCALL NOINLINE void
emit_header(gc->pc, rop, cmdlen);
(void) memcpy((void *)(gc->pc + 4), ptr, 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
static FASTCALL NOINLINE void
generic_6_byte( GLint rop, const void * ptr )
{
__GLXcontext * const gc = __glXGetCurrentContext();
- const GLuint cmdlen = 10;
+ const GLuint cmdlen = 12;
emit_header(gc->pc, rop, cmdlen);
- (void) memcpy((void *)(gc->pc + 4), ptr, 6);
+ (void) memcpy((void *)(gc->pc + 4), ptr, 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
static FASTCALL NOINLINE void
emit_header(gc->pc, rop, cmdlen);
(void) memcpy((void *)(gc->pc + 4), ptr, 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
static FASTCALL NOINLINE void
emit_header(gc->pc, rop, cmdlen);
(void) memcpy((void *)(gc->pc + 4), ptr, 12);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
static FASTCALL NOINLINE void
emit_header(gc->pc, rop, cmdlen);
(void) memcpy((void *)(gc->pc + 4), ptr, 16);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
static FASTCALL NOINLINE void
emit_header(gc->pc, rop, cmdlen);
(void) memcpy((void *)(gc->pc + 4), ptr, 24);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
static FASTCALL NOINLINE void
emit_header(gc->pc, rop, cmdlen);
(void) memcpy((void *)(gc->pc + 4), ptr, 32);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLsop_NewList 101
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_NewList, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&list), 4);
(void) memcpy((void *)(pc + 4), (void *)(&mode), 4);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 0;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
(void) setup_single_request(gc, X_GLsop_EndList, cmdlen);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__indirect_glCallList(GLuint list)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_CallList, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&list), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_CallLists 2
__indirect_glCallLists(GLsizei n, GLenum type, const GLvoid * lists)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glCallLists_size(type);
const GLuint cmdlen = 12 + __GLX_PAD((compsize * n));
- if (dpy == NULL) return;
- if ( ((gc->pc + cmdlen) > gc->bufEnd)
- || (cmdlen > gc->maxSmallRenderCommandSize)) {
- (void) __glXFlushRenderBuffer(gc, gc->pc);
- }
- if (cmdlen <= gc->maxSmallRenderCommandSize) {
- emit_header(gc->pc, X_GLrop_CallLists, cmdlen);
- (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
- (void) memcpy((void *)(gc->pc + 8), (void *)(&type), 4);
- (void) memcpy((void *)(gc->pc + 12), (void *)(lists), (compsize * n));
- gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
- }
- else {
- const GLint op = X_GLrop_CallLists;
- const GLuint cmdlenLarge = cmdlen + 4;
- (void) memcpy((void *)(gc->pc + 0), (void *)(&op), 4);
- (void) memcpy((void *)(gc->pc + 4), (void *)(&cmdlenLarge), 4);
- (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
- (void) memcpy((void *)(gc->pc + 12), (void *)(&type), 4);
- __glXSendLargeCommand(gc, gc->pc, 16, lists, (compsize * n));
+ if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, X_GLrop_CallLists, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&type), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(lists), (compsize * n));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = X_GLrop_CallLists;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(&n), 4);
+ (void) memcpy((void *)(pc + 12), (void *)(&type), 4);
+ __glXSendLargeCommand(gc, pc, 16, lists, (compsize * n));
+ }
}
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_DeleteLists, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&list), 4);
(void) memcpy((void *)(pc + 4), (void *)(&range), 4);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
Display * const dpy = gc->currentDpy;
GLuint retval = (GLuint) 0;
const GLuint cmdlen = 4;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GenLists, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&range), 4);
- retval = (GLuint) read_reply(gc->currentDpy, 0, NULL, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ retval = (GLuint) read_reply(dpy, 0, NULL, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return retval;
}
__indirect_glListBase(GLuint base)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_ListBase, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&base), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Begin 4
__indirect_glBegin(GLenum mode)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Begin, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Bitmap 5
+void
+__indirect_glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = (bitmap != NULL) ? __glImageSize(width, height, 1, GL_COLOR_INDEX, GL_BITMAP, 0) : 0;
+ const GLuint cmdlen = 48 + __GLX_PAD(compsize);
+ if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, X_GLrop_Bitmap, cmdlen);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4);
+ (void) memcpy((void *)(gc->pc + 32), (void *)(&xorig), 4);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&yorig), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&xmove), 4);
+ (void) memcpy((void *)(gc->pc + 44), (void *)(&ymove), 4);
+ if (compsize > 0) {
+ (*gc->fillImage)(gc, 2, width, height, 1, GL_COLOR_INDEX, GL_BITMAP, bitmap, gc->pc + 48, gc->pc + 4);
+ }
+ else {
+ (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+ }
+ gc->pc += cmdlen;
+ if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = X_GLrop_Bitmap;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 28), (void *)(&width), 4);
+ (void) memcpy((void *)(pc + 32), (void *)(&height), 4);
+ (void) memcpy((void *)(pc + 36), (void *)(&xorig), 4);
+ (void) memcpy((void *)(pc + 40), (void *)(&yorig), 4);
+ (void) memcpy((void *)(pc + 44), (void *)(&xmove), 4);
+ (void) memcpy((void *)(pc + 48), (void *)(&ymove), 4);
+ __glXSendLargeImage(gc, compsize, 2, width, height, 1, GL_COLOR_INDEX, GL_BITMAP, bitmap, pc + 52, pc + 8);
+ }
+ }
}
#define X_GLrop_Color3bv 6
__indirect_glColor3b(GLbyte red, GLbyte green, GLbyte blue)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Color3bv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
(void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
(void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Color3bv 6
__indirect_glColor3d(GLdouble red, GLdouble green, GLdouble blue)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 28;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Color3dv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
(void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Color3dv 7
__indirect_glColor3f(GLfloat red, GLfloat green, GLfloat blue)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Color3fv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Color3fv 8
__indirect_glColor3i(GLint red, GLint green, GLint blue)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Color3iv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Color3iv 9
__indirect_glColor3s(GLshort red, GLshort green, GLshort blue)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Color3sv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
(void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
(void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Color3sv 10
__indirect_glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Color3ubv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
(void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
(void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Color3ubv 11
__indirect_glColor3ui(GLuint red, GLuint green, GLuint blue)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Color3uiv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Color3uiv 12
__indirect_glColor3us(GLushort red, GLushort green, GLushort blue)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Color3usv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
(void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
(void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Color3usv 13
__indirect_glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Color4bv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
(void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
(void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
(void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Color4bv 14
__indirect_glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 36;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Color4dv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
(void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
(void) memcpy((void *)(gc->pc + 28), (void *)(&alpha), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Color4dv 15
__indirect_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Color4fv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Color4fv 16
__indirect_glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Color4iv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Color4iv 17
__indirect_glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Color4sv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
(void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
(void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
(void) memcpy((void *)(gc->pc + 10), (void *)(&alpha), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Color4sv 18
__indirect_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Color4ubv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
(void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
(void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
(void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Color4ubv 19
__indirect_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Color4uiv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Color4uiv 20
__indirect_glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Color4usv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
(void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
(void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
(void) memcpy((void *)(gc->pc + 10), (void *)(&alpha), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Color4usv 21
__indirect_glEdgeFlag(GLboolean flag)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&flag), 1);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_EdgeFlagv 22
__indirect_glEdgeFlagv(const GLboolean * flag)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(flag), 1);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_End 23
__indirect_glEnd(void)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4;
- (void) dpy;
emit_header(gc->pc, X_GLrop_End, cmdlen);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Indexdv 24
__indirect_glIndexd(GLdouble c)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Indexdv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&c), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Indexdv 24
__indirect_glIndexf(GLfloat c)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Indexfv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Indexfv 25
__indirect_glIndexi(GLint c)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Indexiv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Indexiv 26
__indirect_glIndexs(GLshort c)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&c), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Indexsv 27
__indirect_glIndexsv(const GLshort * c)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(c), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Normal3bv 28
__indirect_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Normal3bv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 1);
(void) memcpy((void *)(gc->pc + 5), (void *)(&ny), 1);
(void) memcpy((void *)(gc->pc + 6), (void *)(&nz), 1);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Normal3bv 28
__indirect_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 28;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Normal3dv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&ny), 8);
(void) memcpy((void *)(gc->pc + 20), (void *)(&nz), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Normal3dv 29
__indirect_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Normal3fv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&ny), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&nz), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Normal3fv 30
__indirect_glNormal3i(GLint nx, GLint ny, GLint nz)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Normal3iv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&ny), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&nz), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Normal3iv 31
__indirect_glNormal3s(GLshort nx, GLshort ny, GLshort nz)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Normal3sv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 2);
(void) memcpy((void *)(gc->pc + 6), (void *)(&ny), 2);
(void) memcpy((void *)(gc->pc + 8), (void *)(&nz), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Normal3sv 32
__indirect_glRasterPos2d(GLdouble x, GLdouble y)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_RasterPos2dv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_RasterPos2dv 33
__indirect_glRasterPos2f(GLfloat x, GLfloat y)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_RasterPos2fv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_RasterPos2fv 34
__indirect_glRasterPos2i(GLint x, GLint y)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_RasterPos2iv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_RasterPos2iv 35
__indirect_glRasterPos2s(GLshort x, GLshort y)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_RasterPos2sv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
(void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_RasterPos2sv 36
__indirect_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 28;
- (void) dpy;
emit_header(gc->pc, X_GLrop_RasterPos3dv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
(void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_RasterPos3dv 37
__indirect_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_RasterPos3fv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_RasterPos3fv 38
__indirect_glRasterPos3i(GLint x, GLint y, GLint z)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_RasterPos3iv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_RasterPos3iv 39
__indirect_glRasterPos3s(GLshort x, GLshort y, GLshort z)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_RasterPos3sv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
(void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
(void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_RasterPos3sv 40
__indirect_glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 36;
- (void) dpy;
emit_header(gc->pc, X_GLrop_RasterPos4dv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
(void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
(void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_RasterPos4dv 41
__indirect_glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_RasterPos4fv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_RasterPos4fv 42
__indirect_glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_RasterPos4iv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_RasterPos4iv 43
__indirect_glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_RasterPos4sv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
(void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
(void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
(void) memcpy((void *)(gc->pc + 10), (void *)(&w), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_RasterPos4sv 44
__indirect_glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 36;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&y1), 8);
(void) memcpy((void *)(gc->pc + 20), (void *)(&x2), 8);
(void) memcpy((void *)(gc->pc + 28), (void *)(&y2), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Rectdv 45
__indirect_glRectdv(const GLdouble * v1, const GLdouble * v2)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 36;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(v1), 16);
(void) memcpy((void *)(gc->pc + 20), (void *)(v2), 16);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Rectfv 46
__indirect_glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&y1), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&x2), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&y2), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Rectfv 46
__indirect_glRectfv(const GLfloat * v1, const GLfloat * v2)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(v1), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(v2), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Rectiv 47
__indirect_glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Rectiv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&y1), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&x2), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&y2), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Rectiv 47
__indirect_glRectiv(const GLint * v1, const GLint * v2)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Rectiv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(v1), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(v2), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Rectsv 48
__indirect_glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 2);
(void) memcpy((void *)(gc->pc + 6), (void *)(&y1), 2);
(void) memcpy((void *)(gc->pc + 8), (void *)(&x2), 2);
(void) memcpy((void *)(gc->pc + 10), (void *)(&y2), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Rectsv 48
__indirect_glRectsv(const GLshort * v1, const GLshort * v2)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(v1), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(v2), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexCoord1dv 49
__indirect_glTexCoord1d(GLdouble s)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexCoord1dv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexCoord1dv 49
__indirect_glTexCoord1f(GLfloat s)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexCoord1fv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexCoord1fv 50
__indirect_glTexCoord1i(GLint s)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexCoord1iv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexCoord1iv 51
__indirect_glTexCoord1s(GLshort s)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexCoord1sv 52
__indirect_glTexCoord1sv(const GLshort * v)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(v), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexCoord2dv 53
__indirect_glTexCoord2d(GLdouble s, GLdouble t)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexCoord2dv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexCoord2dv 53
__indirect_glTexCoord2f(GLfloat s, GLfloat t)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexCoord2fv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexCoord2fv 54
__indirect_glTexCoord2i(GLint s, GLint t)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexCoord2iv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexCoord2iv 55
__indirect_glTexCoord2s(GLshort s, GLshort t)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexCoord2sv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
(void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexCoord2sv 56
__indirect_glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 28;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexCoord3dv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
(void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexCoord3dv 57
__indirect_glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexCoord3fv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexCoord3fv 58
__indirect_glTexCoord3i(GLint s, GLint t, GLint r)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexCoord3iv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexCoord3iv 59
__indirect_glTexCoord3s(GLshort s, GLshort t, GLshort r)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexCoord3sv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
(void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
(void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexCoord3sv 60
__indirect_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 36;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexCoord4dv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
(void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
(void) memcpy((void *)(gc->pc + 28), (void *)(&q), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexCoord4dv 61
__indirect_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexCoord4fv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexCoord4fv 62
__indirect_glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexCoord4iv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexCoord4iv 63
__indirect_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexCoord4sv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
(void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
(void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2);
(void) memcpy((void *)(gc->pc + 10), (void *)(&q), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexCoord4sv 64
__indirect_glVertex2d(GLdouble x, GLdouble y)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Vertex2dv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Vertex2dv 65
__indirect_glVertex2f(GLfloat x, GLfloat y)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Vertex2fv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Vertex2fv 66
__indirect_glVertex2i(GLint x, GLint y)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Vertex2iv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Vertex2iv 67
__indirect_glVertex2s(GLshort x, GLshort y)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Vertex2sv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
(void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Vertex2sv 68
__indirect_glVertex3d(GLdouble x, GLdouble y, GLdouble z)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 28;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Vertex3dv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
(void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Vertex3dv 69
__indirect_glVertex3f(GLfloat x, GLfloat y, GLfloat z)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Vertex3fv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Vertex3fv 70
__indirect_glVertex3i(GLint x, GLint y, GLint z)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Vertex3iv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Vertex3iv 71
__indirect_glVertex3s(GLshort x, GLshort y, GLshort z)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Vertex3sv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
(void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
(void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Vertex3sv 72
__indirect_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 36;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Vertex4dv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
(void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
(void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Vertex4dv 73
__indirect_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Vertex4fv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Vertex4fv 74
__indirect_glVertex4i(GLint x, GLint y, GLint z, GLint w)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Vertex4iv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Vertex4iv 75
__indirect_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Vertex4sv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
(void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
(void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
(void) memcpy((void *)(gc->pc + 10), (void *)(&w), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Vertex4sv 76
__indirect_glClipPlane(GLenum plane, const GLdouble * equation)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 40;
- (void) dpy;
emit_header(gc->pc, X_GLrop_ClipPlane, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(equation), 32);
(void) memcpy((void *)(gc->pc + 36), (void *)(&plane), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_ColorMaterial 78
__indirect_glColorMaterial(GLenum face, GLenum mode)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_ColorMaterial, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_CullFace 79
__indirect_glCullFace(GLenum mode)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_CullFace, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Fogf 80
__indirect_glFogf(GLenum pname, GLfloat param)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Fogf, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Fogfv 81
__indirect_glFogfv(GLenum pname, const GLfloat * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glFogfv_size(pname);
const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
- (void) dpy;
emit_header(gc->pc, X_GLrop_Fogfv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Fogi 82
__indirect_glFogi(GLenum pname, GLint param)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Fogi, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Fogiv 83
__indirect_glFogiv(GLenum pname, const GLint * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glFogiv_size(pname);
const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
- (void) dpy;
emit_header(gc->pc, X_GLrop_Fogiv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_FrontFace 84
__indirect_glFrontFace(GLenum mode)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_FrontFace, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Hint 85
__indirect_glHint(GLenum target, GLenum mode)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Hint, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Lightf 86
__indirect_glLightf(GLenum light, GLenum pname, GLfloat param)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Lightf, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Lightfv 87
__indirect_glLightfv(GLenum light, GLenum pname, const GLfloat * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glLightfv_size(pname);
const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
- (void) dpy;
emit_header(gc->pc, X_GLrop_Lightfv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Lighti 88
__indirect_glLighti(GLenum light, GLenum pname, GLint param)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Lighti, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Lightiv 89
__indirect_glLightiv(GLenum light, GLenum pname, const GLint * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glLightiv_size(pname);
const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
- (void) dpy;
emit_header(gc->pc, X_GLrop_Lightiv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_LightModelf 90
__indirect_glLightModelf(GLenum pname, GLfloat param)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_LightModelf, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_LightModelfv 91
__indirect_glLightModelfv(GLenum pname, const GLfloat * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glLightModelfv_size(pname);
const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
- (void) dpy;
emit_header(gc->pc, X_GLrop_LightModelfv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_LightModeli 92
__indirect_glLightModeli(GLenum pname, GLint param)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_LightModeli, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_LightModeliv 93
__indirect_glLightModeliv(GLenum pname, const GLint * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glLightModeliv_size(pname);
const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
- (void) dpy;
emit_header(gc->pc, X_GLrop_LightModeliv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_LineStipple 94
__indirect_glLineStipple(GLint factor, GLushort pattern)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_LineStipple, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&factor), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pattern), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_LineWidth 95
__indirect_glLineWidth(GLfloat width)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_LineWidth, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&width), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Materialf 96
__indirect_glMaterialf(GLenum face, GLenum pname, GLfloat param)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Materialf, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Materialfv 97
__indirect_glMaterialfv(GLenum face, GLenum pname, const GLfloat * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glMaterialfv_size(pname);
const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
- (void) dpy;
emit_header(gc->pc, X_GLrop_Materialfv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Materiali 98
__indirect_glMateriali(GLenum face, GLenum pname, GLint param)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Materiali, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Materialiv 99
__indirect_glMaterialiv(GLenum face, GLenum pname, const GLint * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glMaterialiv_size(pname);
const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
- (void) dpy;
emit_header(gc->pc, X_GLrop_Materialiv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_PointSize 100
__indirect_glPointSize(GLfloat size)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_PointSize, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&size), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_PolygonMode 101
__indirect_glPolygonMode(GLenum face, GLenum mode)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_PolygonMode, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PolygonStipple 102
+void
+__indirect_glPolygonStipple(const GLubyte * mask)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = (mask != NULL) ? __glImageSize(32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, 0) : 0;
+ const GLuint cmdlen = 24 + __GLX_PAD(compsize);
+ emit_header(gc->pc, X_GLrop_PolygonStipple, cmdlen);
+ if (compsize > 0) {
+ (*gc->fillImage)(gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, mask, gc->pc + 24, gc->pc + 4);
+ }
+ else {
+ (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+ }
+ gc->pc += cmdlen;
if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
__indirect_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Scissor, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_ShadeModel 104
__indirect_glShadeModel(GLenum mode)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_ShadeModel, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexParameterf 105
__indirect_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexParameterf, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexParameterfv 106
__indirect_glTexParameterfv(GLenum target, GLenum pname, const GLfloat * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glTexParameterfv_size(pname);
const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexParameterfv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexParameteri 107
__indirect_glTexParameteri(GLenum target, GLenum pname, GLint param)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexParameteri, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexParameteriv 108
__indirect_glTexParameteriv(GLenum target, GLenum pname, const GLint * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glTexParameteriv_size(pname);
const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexParameteriv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+static void
+__glx_TexImage_1D2D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels )
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = __glImageSize(width, height, 1, format, type, target);
+ const GLuint cmdlen = 56 + __GLX_PAD(compsize);
+ if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, opcode, cmdlen);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&level), 4);
+ (void) memcpy((void *)(gc->pc + 32), (void *)(&internalformat), 4);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&width), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&height), 4);
+ (void) memcpy((void *)(gc->pc + 44), (void *)(&border), 4);
+ (void) memcpy((void *)(gc->pc + 48), (void *)(&format), 4);
+ (void) memcpy((void *)(gc->pc + 52), (void *)(&type), 4);
+ if ((compsize > 0) && (pixels != NULL)) {
+ (*gc->fillImage)(gc, dim, width, height, 1, format, type, pixels, gc->pc + 56, gc->pc + 4);
+ }
+ else {
+ (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+ }
+ gc->pc += cmdlen;
+ if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = opcode;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 32), (void *)(&level), 4);
+ (void) memcpy((void *)(pc + 36), (void *)(&internalformat), 4);
+ (void) memcpy((void *)(pc + 40), (void *)(&width), 4);
+ (void) memcpy((void *)(pc + 44), (void *)(&height), 4);
+ (void) memcpy((void *)(pc + 48), (void *)(&border), 4);
+ (void) memcpy((void *)(pc + 52), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 56), (void *)(&type), 4);
+ __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, pixels, pc + 60, pc + 8);
+ }
+ }
}
-#define X_GLrop_TexEnvf 111
+#define X_GLrop_TexImage1D 109
+void
+__indirect_glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
+{
+ __glx_TexImage_1D2D(X_GLrop_TexImage1D, 1, target, level, internalformat, width, 1, border, format, type, pixels );
+}
+
+#define X_GLrop_TexImage2D 110
+void
+__indirect_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
+{
+ __glx_TexImage_1D2D(X_GLrop_TexImage2D, 2, target, level, internalformat, width, height, border, format, type, pixels );
+}
+
+#define X_GLrop_TexEnvf 111
void
__indirect_glTexEnvf(GLenum target, GLenum pname, GLfloat param)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexEnvf, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexEnvfv 112
__indirect_glTexEnvfv(GLenum target, GLenum pname, const GLfloat * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glTexEnvfv_size(pname);
const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexEnvfv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexEnvi 113
__indirect_glTexEnvi(GLenum target, GLenum pname, GLint param)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexEnvi, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexEnviv 114
__indirect_glTexEnviv(GLenum target, GLenum pname, const GLint * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glTexEnviv_size(pname);
const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexEnviv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexGend 115
__indirect_glTexGend(GLenum coord, GLenum pname, GLdouble param)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexGend, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(¶m), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&coord), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&pname), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexGendv 116
__indirect_glTexGendv(GLenum coord, GLenum pname, const GLdouble * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glTexGendv_size(pname);
const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8));
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexGendv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 8));
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexGenf 117
__indirect_glTexGenf(GLenum coord, GLenum pname, GLfloat param)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexGenf, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexGenfv 118
__indirect_glTexGenfv(GLenum coord, GLenum pname, const GLfloat * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glTexGenfv_size(pname);
const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexGenfv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexGeni 119
__indirect_glTexGeni(GLenum coord, GLenum pname, GLint param)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexGeni, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(¶m), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_TexGeniv 120
__indirect_glTexGeniv(GLenum coord, GLenum pname, const GLint * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glTexGeniv_size(pname);
const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
- (void) dpy;
emit_header(gc->pc, X_GLrop_TexGeniv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_InitNames 121
__indirect_glInitNames(void)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4;
- (void) dpy;
emit_header(gc->pc, X_GLrop_InitNames, cmdlen);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_LoadName 122
__indirect_glLoadName(GLuint name)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_LoadName, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&name), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_PassThrough 123
__indirect_glPassThrough(GLfloat token)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_PassThrough, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&token), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_PopName 124
__indirect_glPopName(void)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4;
- (void) dpy;
emit_header(gc->pc, X_GLrop_PopName, cmdlen);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_PushName 125
__indirect_glPushName(GLuint name)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_PushName, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&name), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_DrawBuffer 126
__indirect_glDrawBuffer(GLenum mode)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_DrawBuffer, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Clear 127
__indirect_glClear(GLbitfield mask)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Clear, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_ClearAccum 128
__indirect_glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_ClearAccum, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_ClearIndex 129
__indirect_glClearIndex(GLfloat c)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_ClearIndex, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_ClearColor 130
__indirect_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_ClearColor, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_ClearStencil 131
__indirect_glClearStencil(GLint s)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_ClearStencil, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_ClearDepth 132
__indirect_glClearDepth(GLclampd depth)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_ClearDepth, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&depth), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_StencilMask 133
__indirect_glStencilMask(GLuint mask)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_StencilMask, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_ColorMask 134
__indirect_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_ColorMask, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
(void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
(void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
(void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_DepthMask 135
__indirect_glDepthMask(GLboolean flag)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_DepthMask, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&flag), 1);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_IndexMask 136
__indirect_glIndexMask(GLuint mask)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_IndexMask, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Accum 137
__indirect_glAccum(GLenum op, GLfloat value)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Accum, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&op), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&value), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_PopAttrib 141
__indirect_glPopAttrib(void)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4;
- (void) dpy;
emit_header(gc->pc, X_GLrop_PopAttrib, cmdlen);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_PushAttrib 142
__indirect_glPushAttrib(GLbitfield mask)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_PushAttrib, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MapGrid1d 147
__indirect_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 24;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MapGrid1d, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&u1), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 8);
(void) memcpy((void *)(gc->pc + 20), (void *)(&un), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MapGrid1f 148
__indirect_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MapGrid1f, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&un), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&u1), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MapGrid2d 149
__indirect_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 44;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MapGrid2d, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&u1), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 8);
(void) memcpy((void *)(gc->pc + 36), (void *)(&un), 4);
(void) memcpy((void *)(gc->pc + 40), (void *)(&vn), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MapGrid2f 150
__indirect_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 28;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MapGrid2f, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&un), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&u1), 4);
(void) memcpy((void *)(gc->pc + 20), (void *)(&v1), 4);
(void) memcpy((void *)(gc->pc + 24), (void *)(&v2), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_EvalCoord1dv 151
__indirect_glEvalCoord1d(GLdouble u)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_EvalCoord1dv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&u), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_EvalCoord1dv 151
__indirect_glEvalCoord1f(GLfloat u)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_EvalCoord1fv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&u), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_EvalCoord1fv 152
__indirect_glEvalCoord2d(GLdouble u, GLdouble v)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_EvalCoord2dv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&u), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&v), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_EvalCoord2dv 153
__indirect_glEvalCoord2f(GLfloat u, GLfloat v)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_EvalCoord2fv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&u), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&v), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_EvalCoord2fv 154
__indirect_glEvalMesh1(GLenum mode, GLint i1, GLint i2)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_EvalMesh1, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&i1), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&i2), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_EvalPoint1 156
__indirect_glEvalPoint1(GLint i)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_EvalPoint1, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&i), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_EvalMesh2 157
__indirect_glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 24;
- (void) dpy;
emit_header(gc->pc, X_GLrop_EvalMesh2, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&i1), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&j1), 4);
(void) memcpy((void *)(gc->pc + 20), (void *)(&j2), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_EvalPoint2 158
__indirect_glEvalPoint2(GLint i, GLint j)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_EvalPoint2, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&i), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&j), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_AlphaFunc 159
__indirect_glAlphaFunc(GLenum func, GLclampf ref)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_AlphaFunc, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&ref), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_BlendFunc 160
__indirect_glBlendFunc(GLenum sfactor, GLenum dfactor)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_BlendFunc, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&sfactor), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&dfactor), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_LogicOp 161
__indirect_glLogicOp(GLenum opcode)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_LogicOp, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&opcode), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_StencilFunc 162
__indirect_glStencilFunc(GLenum func, GLint ref, GLuint mask)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_StencilFunc, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&ref), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&mask), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_StencilOp 163
__indirect_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_StencilOp, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&fail), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&zfail), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&zpass), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_DepthFunc 164
__indirect_glDepthFunc(GLenum func)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_DepthFunc, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_PixelZoom 165
__indirect_glPixelZoom(GLfloat xfactor, GLfloat yfactor)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_PixelZoom, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&xfactor), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&yfactor), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_PixelTransferf 166
__indirect_glPixelTransferf(GLenum pname, GLfloat param)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_PixelTransferf, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_PixelTransferi 167
__indirect_glPixelTransferi(GLenum pname, GLint param)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_PixelTransferi, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_PixelMapfv 168
__indirect_glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat * values)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
- if (mapsize < 0) return;
- if (dpy == NULL) return;
- if ( ((gc->pc + cmdlen) > gc->bufEnd)
- || (cmdlen > gc->maxSmallRenderCommandSize)) {
- (void) __glXFlushRenderBuffer(gc, gc->pc);
- }
- if (cmdlen <= gc->maxSmallRenderCommandSize) {
- emit_header(gc->pc, X_GLrop_PixelMapfv, cmdlen);
- (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
- (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
- (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 4));
- gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
- }
- else {
- const GLint op = X_GLrop_PixelMapfv;
- const GLuint cmdlenLarge = cmdlen + 4;
- (void) memcpy((void *)(gc->pc + 0), (void *)(&op), 4);
- (void) memcpy((void *)(gc->pc + 4), (void *)(&cmdlenLarge), 4);
- (void) memcpy((void *)(gc->pc + 8), (void *)(&map), 4);
- (void) memcpy((void *)(gc->pc + 12), (void *)(&mapsize), 4);
- __glXSendLargeCommand(gc, gc->pc, 16, values, (mapsize * 4));
+ if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, X_GLrop_PixelMapfv, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 4));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = X_GLrop_PixelMapfv;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(&map), 4);
+ (void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4);
+ __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4));
+ }
}
}
__indirect_glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint * values)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
- if (mapsize < 0) return;
- if (dpy == NULL) return;
- if ( ((gc->pc + cmdlen) > gc->bufEnd)
- || (cmdlen > gc->maxSmallRenderCommandSize)) {
- (void) __glXFlushRenderBuffer(gc, gc->pc);
- }
- if (cmdlen <= gc->maxSmallRenderCommandSize) {
- emit_header(gc->pc, X_GLrop_PixelMapuiv, cmdlen);
- (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
- (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
- (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 4));
- gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
- }
- else {
- const GLint op = X_GLrop_PixelMapuiv;
- const GLuint cmdlenLarge = cmdlen + 4;
- (void) memcpy((void *)(gc->pc + 0), (void *)(&op), 4);
- (void) memcpy((void *)(gc->pc + 4), (void *)(&cmdlenLarge), 4);
- (void) memcpy((void *)(gc->pc + 8), (void *)(&map), 4);
- (void) memcpy((void *)(gc->pc + 12), (void *)(&mapsize), 4);
- __glXSendLargeCommand(gc, gc->pc, 16, values, (mapsize * 4));
+ if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, X_GLrop_PixelMapuiv, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 4));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = X_GLrop_PixelMapuiv;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(&map), 4);
+ (void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4);
+ __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4));
+ }
}
}
__indirect_glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort * values)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 2));
- if (mapsize < 0) return;
- if (dpy == NULL) return;
- if ( ((gc->pc + cmdlen) > gc->bufEnd)
- || (cmdlen > gc->maxSmallRenderCommandSize)) {
- (void) __glXFlushRenderBuffer(gc, gc->pc);
- }
- if (cmdlen <= gc->maxSmallRenderCommandSize) {
- emit_header(gc->pc, X_GLrop_PixelMapusv, cmdlen);
- (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
- (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
- (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 2));
- gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
- }
- else {
- const GLint op = X_GLrop_PixelMapusv;
- const GLuint cmdlenLarge = cmdlen + 4;
- (void) memcpy((void *)(gc->pc + 0), (void *)(&op), 4);
- (void) memcpy((void *)(gc->pc + 4), (void *)(&cmdlenLarge), 4);
- (void) memcpy((void *)(gc->pc + 8), (void *)(&map), 4);
- (void) memcpy((void *)(gc->pc + 12), (void *)(&mapsize), 4);
- __glXSendLargeCommand(gc, gc->pc, 16, values, (mapsize * 2));
+ if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, X_GLrop_PixelMapusv, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
+ (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 2));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = X_GLrop_PixelMapusv;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 8), (void *)(&map), 4);
+ (void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4);
+ __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 2));
+ }
}
}
__indirect_glReadBuffer(GLenum mode)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_ReadBuffer, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_CopyPixels 172
__indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 24;
- (void) dpy;
emit_header(gc->pc, X_GLrop_CopyPixels, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
(void) memcpy((void *)(gc->pc + 20), (void *)(&type), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_DrawPixels 173
+void
+__indirect_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, 1, format, type, 0) : 0;
+ const GLuint cmdlen = 40 + __GLX_PAD(compsize);
+ if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, X_GLrop_DrawPixels, cmdlen);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4);
+ (void) memcpy((void *)(gc->pc + 32), (void *)(&format), 4);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&type), 4);
+ if (compsize > 0) {
+ (*gc->fillImage)(gc, 2, width, height, 1, format, type, pixels, gc->pc + 40, gc->pc + 4);
+ }
+ else {
+ (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+ }
+ gc->pc += cmdlen;
+ if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = X_GLrop_DrawPixels;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 28), (void *)(&width), 4);
+ (void) memcpy((void *)(pc + 32), (void *)(&height), 4);
+ (void) memcpy((void *)(pc + 36), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 40), (void *)(&type), 4);
+ __glXSendLargeImage(gc, compsize, 2, width, height, 1, format, type, pixels, pc + 44, pc + 8);
+ }
+ }
}
#define X_GLsop_GetClipPlane 113
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetClipPlane, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&plane), 4);
- (void) read_reply(gc->currentDpy, 8, equation, GL_TRUE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 8, equation, GL_TRUE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetLightfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&light), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetLightiv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&light), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMapdv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&query), 4);
- (void) read_reply(gc->currentDpy, 8, v, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 8, v, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMapfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&query), 4);
- (void) read_reply(gc->currentDpy, 4, v, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, v, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMapiv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&query), 4);
- (void) read_reply(gc->currentDpy, 4, v, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, v, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMaterialfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&face), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMaterialiv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&face), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetPixelMapfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&map), 4);
- (void) read_reply(gc->currentDpy, 4, values, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, values, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetPixelMapuiv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&map), 4);
- (void) read_reply(gc->currentDpy, 4, values, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, values, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetPixelMapusv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&map), 4);
- (void) read_reply(gc->currentDpy, 2, values, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 2, values, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexEnvfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexEnviv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexGendv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(gc->currentDpy, 8, params, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 8, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexGenfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexGeniv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexParameterfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexParameteriv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexLevelParameterfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&level), 4);
(void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
- (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexLevelParameteriv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&level), 4);
(void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
- (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
Display * const dpy = gc->currentDpy;
GLboolean retval = (GLboolean) 0;
const GLuint cmdlen = 4;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_IsList, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&list), 4);
- retval = (GLboolean) read_reply(gc->currentDpy, 0, NULL, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ retval = (GLboolean) read_reply(dpy, 0, NULL, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return retval;
}
__indirect_glDepthRange(GLclampd zNear, GLclampd zFar)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_DepthRange, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&zNear), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&zFar), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Frustum 175
__indirect_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 52;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Frustum, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&left), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&right), 8);
(void) memcpy((void *)(gc->pc + 36), (void *)(&zNear), 8);
(void) memcpy((void *)(gc->pc + 44), (void *)(&zFar), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_LoadIdentity 176
__indirect_glLoadIdentity(void)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4;
- (void) dpy;
emit_header(gc->pc, X_GLrop_LoadIdentity, cmdlen);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_LoadMatrixf 177
__indirect_glLoadMatrixf(const GLfloat * m)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 68;
- (void) dpy;
emit_header(gc->pc, X_GLrop_LoadMatrixf, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(m), 64);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_LoadMatrixd 178
__indirect_glLoadMatrixd(const GLdouble * m)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 132;
- (void) dpy;
emit_header(gc->pc, X_GLrop_LoadMatrixd, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(m), 128);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MatrixMode 179
__indirect_glMatrixMode(GLenum mode)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MatrixMode, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultMatrixf 180
__indirect_glMultMatrixf(const GLfloat * m)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 68;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultMatrixf, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(m), 64);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultMatrixd 181
__indirect_glMultMatrixd(const GLdouble * m)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 132;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultMatrixd, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(m), 128);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Ortho 182
__indirect_glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 52;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Ortho, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&left), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&right), 8);
(void) memcpy((void *)(gc->pc + 36), (void *)(&zNear), 8);
(void) memcpy((void *)(gc->pc + 44), (void *)(&zFar), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_PopMatrix 183
__indirect_glPopMatrix(void)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4;
- (void) dpy;
emit_header(gc->pc, X_GLrop_PopMatrix, cmdlen);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_PushMatrix 184
__indirect_glPushMatrix(void)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4;
- (void) dpy;
emit_header(gc->pc, X_GLrop_PushMatrix, cmdlen);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Rotated 185
__indirect_glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 36;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Rotated, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&angle), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8);
(void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8);
(void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Rotatef 186
__indirect_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Rotatef, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&angle), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Scaled 187
__indirect_glScaled(GLdouble x, GLdouble y, GLdouble z)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 28;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Scaled, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
(void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Scalef 188
__indirect_glScalef(GLfloat x, GLfloat y, GLfloat z)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Scalef, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Translated 189
__indirect_glTranslated(GLdouble x, GLdouble y, GLdouble z)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 28;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Translated, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
(void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Translatef 190
__indirect_glTranslatef(GLfloat x, GLfloat y, GLfloat z)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Translatef, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Viewport 191
__indirect_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Viewport, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_BindTexture 4117
__indirect_glBindTexture(GLenum target, GLuint texture)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_BindTexture, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&texture), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Indexubv 194
__indirect_glIndexub(GLubyte c)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&c), 1);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Indexubv 194
__indirect_glIndexubv(const GLubyte * c)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(c), 1);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_PolygonOffset 192
__indirect_glPolygonOffset(GLfloat factor, GLfloat units)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_PolygonOffset, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&factor), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&units), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLsop_AreTexturesResident 143
Display * const dpy = gc->currentDpy;
GLboolean retval = (GLboolean) 0;
const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
- if (n < 0) return retval;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_AreTexturesResident, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&n), 4);
(void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
- retval = (GLboolean) read_reply(gc->currentDpy, 1, residences, GL_TRUE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ retval = (GLboolean) read_reply(dpy, 1, residences, GL_TRUE);
+ UnlockDisplay(dpy); SyncHandle();
}
return retval;
}
__indirect_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 32;
- (void) dpy;
emit_header(gc->pc, X_GLrop_CopyTexImage1D, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
(void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
(void) memcpy((void *)(gc->pc + 28), (void *)(&border), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_CopyTexImage2D 4120
__indirect_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 36;
- (void) dpy;
emit_header(gc->pc, X_GLrop_CopyTexImage2D, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
(void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4);
(void) memcpy((void *)(gc->pc + 32), (void *)(&border), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_CopyTexSubImage1D 4121
__indirect_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 28;
- (void) dpy;
emit_header(gc->pc, X_GLrop_CopyTexSubImage1D, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
(void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
(void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_CopyTexSubImage2D 4122
__indirect_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 36;
- (void) dpy;
emit_header(gc->pc, X_GLrop_CopyTexSubImage2D, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
(void) memcpy((void *)(gc->pc + 28), (void *)(&width), 4);
(void) memcpy((void *)(gc->pc + 32), (void *)(&height), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLsop_DeleteTextures 144
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
- if (n < 0) return;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_DeleteTextures, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&n), 4);
(void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GenTextures, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&n), 4);
- (void) read_reply(gc->currentDpy, 4, textures, GL_TRUE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, textures, GL_TRUE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
Display * const dpy = gc->currentDpy;
GLboolean retval = (GLboolean) 0;
const GLuint cmdlen = 4;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_IsTexture, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&texture), 4);
- retval = (GLboolean) read_reply(gc->currentDpy, 0, NULL, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ retval = (GLboolean) read_reply(dpy, 0, NULL, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return retval;
}
__indirect_glPrioritizeTextures(GLsizei n, const GLuint * textures, const GLclampf * priorities)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8 + __GLX_PAD((n * 4)) + __GLX_PAD((n * 4));
- if (n < 0) return;
- (void) dpy;
- emit_header(gc->pc, X_GLrop_PrioritizeTextures, cmdlen);
- (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
- (void) memcpy((void *)(gc->pc + 8), (void *)(textures), (n * 4));
- (void) memcpy((void *)(gc->pc + 8), (void *)(priorities), (n * 4));
- gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(n >= 0, 1)) {
+ emit_header(gc->pc, X_GLrop_PrioritizeTextures, cmdlen);
+ (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
+ (void) memcpy((void *)(gc->pc + 8), (void *)(textures), (n * 4));
+ (void) memcpy((void *)(gc->pc + 8), (void *)(priorities), (n * 4));
+ gc->pc += cmdlen;
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+}
+
+static void
+__glx_TexSubImage_1D2D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels )
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, 1, format, type, target) : 0;
+ const GLuint cmdlen = 60 + __GLX_PAD(compsize);
+ if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, opcode, cmdlen);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&level), 4);
+ (void) memcpy((void *)(gc->pc + 32), (void *)(&xoffset), 4);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&yoffset), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&width), 4);
+ (void) memcpy((void *)(gc->pc + 44), (void *)(&height), 4);
+ (void) memcpy((void *)(gc->pc + 48), (void *)(&format), 4);
+ (void) memcpy((void *)(gc->pc + 52), (void *)(&type), 4);
+ (void) memcpy((void *)(gc->pc + 56), (void *)((pixels == NULL) ? one : zero), 4);
+ if (compsize > 0) {
+ (*gc->fillImage)(gc, dim, width, height, 1, format, type, pixels, gc->pc + 60, gc->pc + 4);
+ }
+ else {
+ (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+ }
+ gc->pc += cmdlen;
+ if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = opcode;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 32), (void *)(&level), 4);
+ (void) memcpy((void *)(pc + 36), (void *)(&xoffset), 4);
+ (void) memcpy((void *)(pc + 40), (void *)(&yoffset), 4);
+ (void) memcpy((void *)(pc + 44), (void *)(&width), 4);
+ (void) memcpy((void *)(pc + 48), (void *)(&height), 4);
+ (void) memcpy((void *)(pc + 52), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 56), (void *)(&type), 4);
+ (void) memcpy((void *)(pc + 60), zero, 4);
+ __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, pixels, pc + 64, pc + 8);
+ }
+ }
+}
+
+#define X_GLrop_TexSubImage1D 4099
+void
+__indirect_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels)
+{
+ __glx_TexSubImage_1D2D(X_GLrop_TexSubImage1D, 1, target, level, xoffset, 1, width, 1, format, type, pixels );
+}
+
+#define X_GLrop_TexSubImage2D 4100
+void
+__indirect_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
+{
+ __glx_TexSubImage_1D2D(X_GLrop_TexSubImage2D, 2, target, level, xoffset, yoffset, width, height, format, type, pixels );
}
#define X_GLrop_BlendColor 4096
__indirect_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_BlendColor, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_BlendEquation 4097
__indirect_glBlendEquation(GLenum mode)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_BlendEquation, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ColorTable 2053
+void
+__indirect_glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = (table != NULL) ? __glImageSize(width, 1, 1, format, type, target) : 0;
+ const GLuint cmdlen = 44 + __GLX_PAD(compsize);
+ if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, X_GLrop_ColorTable, cmdlen);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&internalformat), 4);
+ (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&format), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&type), 4);
+ if (compsize > 0) {
+ (*gc->fillImage)(gc, 1, width, 1, 1, format, type, table, gc->pc + 44, gc->pc + 4);
+ }
+ else {
+ (void) memcpy( gc->pc + 4, default_pixel_store_1D, default_pixel_store_1D_size );
+ }
+ gc->pc += cmdlen;
+ if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = X_GLrop_ColorTable;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 32), (void *)(&internalformat), 4);
+ (void) memcpy((void *)(pc + 36), (void *)(&width), 4);
+ (void) memcpy((void *)(pc + 40), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 44), (void *)(&type), 4);
+ __glXSendLargeImage(gc, compsize, 1, width, 1, 1, format, type, table, pc + 48, pc + 8);
+ }
+ }
}
#define X_GLrop_ColorTableParameterfv 2054
__indirect_glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glColorTableParameterfv_size(pname);
const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
- (void) dpy;
emit_header(gc->pc, X_GLrop_ColorTableParameterfv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_ColorTableParameteriv 2055
__indirect_glColorTableParameteriv(GLenum target, GLenum pname, const GLint * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glColorTableParameteriv_size(pname);
const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
- (void) dpy;
emit_header(gc->pc, X_GLrop_ColorTableParameteriv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_CopyColorTable 2056
__indirect_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 24;
- (void) dpy;
emit_header(gc->pc, X_GLrop_CopyColorTable, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
(void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLsop_GetColorTableParameterfv 148
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetColorTableParameterfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetColorTableParameteriv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
+#define X_GLrop_ColorSubTable 195
+void
+__indirect_glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data)
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = (data != NULL) ? __glImageSize(count, 1, 1, format, type, target) : 0;
+ const GLuint cmdlen = 44 + __GLX_PAD(compsize);
+ if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, X_GLrop_ColorSubTable, cmdlen);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&start), 4);
+ (void) memcpy((void *)(gc->pc + 32), (void *)(&count), 4);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&format), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&type), 4);
+ if (compsize > 0) {
+ (*gc->fillImage)(gc, 1, count, 1, 1, format, type, data, gc->pc + 44, gc->pc + 4);
+ }
+ else {
+ (void) memcpy( gc->pc + 4, default_pixel_store_1D, default_pixel_store_1D_size );
+ }
+ gc->pc += cmdlen;
+ if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = X_GLrop_ColorSubTable;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 32), (void *)(&start), 4);
+ (void) memcpy((void *)(pc + 36), (void *)(&count), 4);
+ (void) memcpy((void *)(pc + 40), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 44), (void *)(&type), 4);
+ __glXSendLargeImage(gc, compsize, 1, count, 1, 1, format, type, data, pc + 48, pc + 8);
+ }
+ }
+}
+
#define X_GLrop_CopyColorSubTable 196
void
__indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 24;
- (void) dpy;
emit_header(gc->pc, X_GLrop_CopyColorSubTable, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&start), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
(void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+static void
+__glx_ConvolutionFilter_1D2D( unsigned opcode, unsigned dim, GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image )
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = (image != NULL) ? __glImageSize(width, height, 1, format, type, target) : 0;
+ const GLuint cmdlen = 48 + __GLX_PAD(compsize);
+ if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, opcode, cmdlen);
+ (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 28), (void *)(&internalformat), 4);
+ (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4);
+ (void) memcpy((void *)(gc->pc + 36), (void *)(&height), 4);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&format), 4);
+ (void) memcpy((void *)(gc->pc + 44), (void *)(&type), 4);
+ if (compsize > 0) {
+ (*gc->fillImage)(gc, dim, width, height, 1, format, type, image, gc->pc + 48, gc->pc + 4);
+ }
+ else {
+ (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+ }
+ gc->pc += cmdlen;
+ if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = opcode;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 32), (void *)(&internalformat), 4);
+ (void) memcpy((void *)(pc + 36), (void *)(&width), 4);
+ (void) memcpy((void *)(pc + 40), (void *)(&height), 4);
+ (void) memcpy((void *)(pc + 44), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 48), (void *)(&type), 4);
+ __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, image, pc + 52, pc + 8);
+ }
+ }
+}
+
+#define X_GLrop_ConvolutionFilter1D 4101
+void
+__indirect_glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image)
+{
+ __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter1D, 1, target, internalformat, width, 1, format, type, image );
+}
+
+#define X_GLrop_ConvolutionFilter2D 4102
+void
+__indirect_glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image)
+{
+ __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter2D, 2, target, internalformat, width, height, format, type, image );
}
#define X_GLrop_ConvolutionParameterf 4103
__indirect_glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_ConvolutionParameterf, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(¶ms), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_ConvolutionParameterfv 4104
__indirect_glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glConvolutionParameterfv_size(pname);
const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
- (void) dpy;
emit_header(gc->pc, X_GLrop_ConvolutionParameterfv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_ConvolutionParameteri 4105
__indirect_glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_ConvolutionParameteri, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(¶ms), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_ConvolutionParameteriv 4106
__indirect_glConvolutionParameteriv(GLenum target, GLenum pname, const GLint * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glConvolutionParameteriv_size(pname);
const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
- (void) dpy;
emit_header(gc->pc, X_GLrop_ConvolutionParameteriv, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_CopyConvolutionFilter1D 4107
__indirect_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 24;
- (void) dpy;
emit_header(gc->pc, X_GLrop_CopyConvolutionFilter1D, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
(void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_CopyConvolutionFilter2D 4108
__indirect_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 28;
- (void) dpy;
emit_header(gc->pc, X_GLrop_CopyConvolutionFilter2D, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
(void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
(void) memcpy((void *)(gc->pc + 24), (void *)(&height), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLsop_GetConvolutionParameterfv 151
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetConvolutionParameterfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetConvolutionParameteriv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetHistogramParameterfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetHistogramParameteriv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMinmaxParameterfv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMinmaxParameteriv, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
- (void) read_reply(gc->currentDpy, 4, params, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, params, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
__indirect_glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Histogram, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&width), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&sink), 1);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_Minmax 4111
__indirect_glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_Minmax, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&sink), 1);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_ResetHistogram 4112
__indirect_glResetHistogram(GLenum target)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_ResetHistogram, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_ResetMinmax 4113
__indirect_glResetMinmax(GLenum target)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_ResetMinmax, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+static void
+__glx_TexImage_3D4D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLint border, GLenum format, GLenum type, const GLvoid * pixels )
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, depth, format, type, target) : 0;
+ const GLuint cmdlen = 84 + __GLX_PAD(compsize);
+ if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, opcode, cmdlen);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 44), (void *)(&level), 4);
+ (void) memcpy((void *)(gc->pc + 48), (void *)(&internalformat), 4);
+ (void) memcpy((void *)(gc->pc + 52), (void *)(&width), 4);
+ (void) memcpy((void *)(gc->pc + 56), (void *)(&height), 4);
+ (void) memcpy((void *)(gc->pc + 60), (void *)(&depth), 4);
+ (void) memcpy((void *)(gc->pc + 64), (void *)(&extent), 4);
+ (void) memcpy((void *)(gc->pc + 68), (void *)(&border), 4);
+ (void) memcpy((void *)(gc->pc + 72), (void *)(&format), 4);
+ (void) memcpy((void *)(gc->pc + 76), (void *)(&type), 4);
+ (void) memcpy((void *)(gc->pc + 80), (void *)((pixels == NULL) ? one : zero), 4);
+ if (compsize > 0) {
+ (*gc->fillImage)(gc, dim, width, height, depth, format, type, pixels, gc->pc + 84, gc->pc + 4);
+ }
+ else {
+ (void) memcpy( gc->pc + 4, default_pixel_store_4D, default_pixel_store_4D_size );
+ }
+ gc->pc += cmdlen;
+ if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = opcode;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 44), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 48), (void *)(&level), 4);
+ (void) memcpy((void *)(pc + 52), (void *)(&internalformat), 4);
+ (void) memcpy((void *)(pc + 56), (void *)(&width), 4);
+ (void) memcpy((void *)(pc + 60), (void *)(&height), 4);
+ (void) memcpy((void *)(pc + 64), (void *)(&depth), 4);
+ (void) memcpy((void *)(pc + 68), (void *)(&extent), 4);
+ (void) memcpy((void *)(pc + 72), (void *)(&border), 4);
+ (void) memcpy((void *)(pc + 76), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 80), (void *)(&type), 4);
+ (void) memcpy((void *)(pc + 84), zero, 4);
+ __glXSendLargeImage(gc, compsize, dim, width, height, depth, format, type, pixels, pc + 88, pc + 8);
+ }
+ }
+}
+
+#define X_GLrop_TexImage3D 4114
+void
+__indirect_glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
+{
+ __glx_TexImage_3D4D(X_GLrop_TexImage3D, 3, target, level, internalformat, width, height, depth, 1, border, format, type, pixels );
+}
+
+static void
+__glx_TexSubImage_3D4D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLenum format, GLenum type, const GLvoid * pixels )
+{
+ __GLXcontext * const gc = __glXGetCurrentContext();
+ const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, depth, format, type, target) : 0;
+ const GLuint cmdlen = 92 + __GLX_PAD(compsize);
+ if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+ if (cmdlen <= gc->maxSmallRenderCommandSize) {
+ if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+ (void) __glXFlushRenderBuffer(gc, gc->pc);
+ }
+ emit_header(gc->pc, opcode, cmdlen);
+ (void) memcpy((void *)(gc->pc + 40), (void *)(&target), 4);
+ (void) memcpy((void *)(gc->pc + 44), (void *)(&level), 4);
+ (void) memcpy((void *)(gc->pc + 48), (void *)(&xoffset), 4);
+ (void) memcpy((void *)(gc->pc + 52), (void *)(&yoffset), 4);
+ (void) memcpy((void *)(gc->pc + 56), (void *)(&zoffset), 4);
+ (void) memcpy((void *)(gc->pc + 60), (void *)(&woffset), 4);
+ (void) memcpy((void *)(gc->pc + 64), (void *)(&width), 4);
+ (void) memcpy((void *)(gc->pc + 68), (void *)(&height), 4);
+ (void) memcpy((void *)(gc->pc + 72), (void *)(&depth), 4);
+ (void) memcpy((void *)(gc->pc + 76), (void *)(&extent), 4);
+ (void) memcpy((void *)(gc->pc + 80), (void *)(&format), 4);
+ (void) memcpy((void *)(gc->pc + 84), (void *)(&type), 4);
+ (void) memcpy((void *)(gc->pc + 88), (void *)((pixels == NULL) ? one : zero), 4);
+ if (compsize > 0) {
+ (*gc->fillImage)(gc, dim, width, height, depth, format, type, pixels, gc->pc + 92, gc->pc + 4);
+ }
+ else {
+ (void) memcpy( gc->pc + 4, default_pixel_store_4D, default_pixel_store_4D_size );
+ }
+ gc->pc += cmdlen;
+ if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ }
+ else {
+ const GLint op = opcode;
+ const GLuint cmdlenLarge = cmdlen + 4;
+ GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+ (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+ (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+ (void) memcpy((void *)(pc + 44), (void *)(&target), 4);
+ (void) memcpy((void *)(pc + 48), (void *)(&level), 4);
+ (void) memcpy((void *)(pc + 52), (void *)(&xoffset), 4);
+ (void) memcpy((void *)(pc + 56), (void *)(&yoffset), 4);
+ (void) memcpy((void *)(pc + 60), (void *)(&zoffset), 4);
+ (void) memcpy((void *)(pc + 64), (void *)(&woffset), 4);
+ (void) memcpy((void *)(pc + 68), (void *)(&width), 4);
+ (void) memcpy((void *)(pc + 72), (void *)(&height), 4);
+ (void) memcpy((void *)(pc + 76), (void *)(&depth), 4);
+ (void) memcpy((void *)(pc + 80), (void *)(&extent), 4);
+ (void) memcpy((void *)(pc + 84), (void *)(&format), 4);
+ (void) memcpy((void *)(pc + 88), (void *)(&type), 4);
+ (void) memcpy((void *)(pc + 92), zero, 4);
+ __glXSendLargeImage(gc, compsize, dim, width, height, depth, format, type, pixels, pc + 96, pc + 8);
+ }
+ }
+}
+
+#define X_GLrop_TexSubImage3D 4115
+void
+__indirect_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels)
+{
+ __glx_TexSubImage_3D4D(X_GLrop_TexSubImage3D, 3, target, level, xoffset, yoffset, zoffset, 1, width, height, depth, 1, format, type, pixels );
}
#define X_GLrop_CopyTexSubImage3D 4123
__indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 40;
- (void) dpy;
emit_header(gc->pc, X_GLrop_CopyTexSubImage3D, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
(void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4);
(void) memcpy((void *)(gc->pc + 36), (void *)(&height), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_ActiveTextureARB 197
__indirect_glActiveTextureARB(GLenum texture)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_ActiveTextureARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&texture), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord1dvARB 198
__indirect_glMultiTexCoord1dARB(GLenum target, GLdouble s)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord1dvARB 198
__indirect_glMultiTexCoord1dvARB(GLenum target, const GLdouble * v)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord1fvARB 199
__indirect_glMultiTexCoord1fARB(GLenum target, GLfloat s)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord1fvARB 199
__indirect_glMultiTexCoord1fvARB(GLenum target, const GLfloat * v)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord1ivARB 200
__indirect_glMultiTexCoord1iARB(GLenum target, GLint s)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord1ivARB 200
__indirect_glMultiTexCoord1ivARB(GLenum target, const GLint * v)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord1svARB 201
__indirect_glMultiTexCoord1sARB(GLenum target, GLshort s)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord1svARB 201
__indirect_glMultiTexCoord1svARB(GLenum target, const GLshort * v)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord2dvARB 202
__indirect_glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 24;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
(void) memcpy((void *)(gc->pc + 20), (void *)(&target), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord2dvARB 202
__indirect_glMultiTexCoord2dvARB(GLenum target, const GLdouble * v)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 24;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(v), 16);
(void) memcpy((void *)(gc->pc + 20), (void *)(&target), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord2fvARB 203
__indirect_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord2fvARB 203
__indirect_glMultiTexCoord2fvARB(GLenum target, const GLfloat * v)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord2ivARB 204
__indirect_glMultiTexCoord2iARB(GLenum target, GLint s, GLint t)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord2ivARB 204
__indirect_glMultiTexCoord2ivARB(GLenum target, const GLint * v)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord2svARB 205
__indirect_glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
(void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord2svARB 205
__indirect_glMultiTexCoord2svARB(GLenum target, const GLshort * v)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord3dvARB 206
__indirect_glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 32;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
(void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
(void) memcpy((void *)(gc->pc + 28), (void *)(&target), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord3dvARB 206
__indirect_glMultiTexCoord3dvARB(GLenum target, const GLdouble * v)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 32;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(v), 24);
(void) memcpy((void *)(gc->pc + 28), (void *)(&target), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord3fvARB 207
__indirect_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord3fvARB 207
__indirect_glMultiTexCoord3fvARB(GLenum target, const GLfloat * v)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord3ivARB 208
__indirect_glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord3ivARB 208
__indirect_glMultiTexCoord3ivARB(GLenum target, const GLint * v)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord3svARB 209
__indirect_glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
(void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
(void) memcpy((void *)(gc->pc + 12), (void *)(&r), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord3svARB 209
__indirect_glMultiTexCoord3svARB(GLenum target, const GLshort * v)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord4dvARB 210
__indirect_glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 40;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
(void) memcpy((void *)(gc->pc + 28), (void *)(&q), 8);
(void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord4dvARB 210
__indirect_glMultiTexCoord4dvARB(GLenum target, const GLdouble * v)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 40;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
(void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord4fvARB 211
__indirect_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 24;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
(void) memcpy((void *)(gc->pc + 20), (void *)(&q), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord4fvARB 211
__indirect_glMultiTexCoord4fvARB(GLenum target, const GLfloat * v)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 24;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord4ivARB 212
__indirect_glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 24;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
(void) memcpy((void *)(gc->pc + 20), (void *)(&q), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord4ivARB 212
__indirect_glMultiTexCoord4ivARB(GLenum target, const GLint * v)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 24;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord4svARB 213
__indirect_glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
(void) memcpy((void *)(gc->pc + 12), (void *)(&r), 2);
(void) memcpy((void *)(gc->pc + 14), (void *)(&q), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_MultiTexCoord4svARB 213
__indirect_glMultiTexCoord4svARB(GLenum target, const GLshort * v)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_SampleCoverageARB 229
__indirect_glSampleCoverageARB(GLclampf value, GLboolean invert)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_SampleCoverageARB, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&value), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&invert), 1);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLvop_AreTexturesResidentEXT 11
Display * const dpy = gc->currentDpy;
GLboolean retval = (GLboolean) 0;
const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
- if (n < 0) return retval;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
GLubyte const * pc = setup_vendor_request(gc, X_GLXVendorPrivateWithReply, X_GLvop_AreTexturesResidentEXT, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&n), 4);
(void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
- retval = (GLboolean) read_reply(gc->currentDpy, 1, residences, GL_TRUE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ retval = (GLboolean) read_reply(dpy, 1, residences, GL_TRUE);
+ UnlockDisplay(dpy); SyncHandle();
}
return retval;
}
__GLXcontext * const gc = __glXGetCurrentContext();
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_vendor_request(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenTexturesEXT, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&n), 4);
- (void) read_reply(gc->currentDpy, 4, textures, GL_TRUE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ (void) read_reply(dpy, 4, textures, GL_TRUE);
+ UnlockDisplay(dpy); SyncHandle();
}
return;
}
Display * const dpy = gc->currentDpy;
GLboolean retval = (GLboolean) 0;
const GLuint cmdlen = 4;
- (void) dpy;
- if (dpy != NULL) {
+ if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_vendor_request(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsTextureEXT, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&texture), 4);
- retval = (GLboolean) read_reply(gc->currentDpy, 0, NULL, GL_FALSE);
- UnlockDisplay(gc->currentDpy); SyncHandle();
+ retval = (GLboolean) read_reply(dpy, 0, NULL, GL_FALSE);
+ UnlockDisplay(dpy); SyncHandle();
}
return retval;
}
__indirect_glSampleMaskSGIS(GLclampf value, GLboolean invert)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_SampleMaskSGIS, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&value), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&invert), 1);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_SamplePatternSGIS 2049
__indirect_glSamplePatternSGIS(GLenum pattern)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_SamplePatternSGIS, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&pattern), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_PointParameterfEXT 2065
__indirect_glPointParameterfEXT(GLenum pname, GLfloat param)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_PointParameterfEXT, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(¶m), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_PointParameterfvEXT 2066
__indirect_glPointParameterfvEXT(GLenum pname, const GLfloat * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glPointParameterfvEXT_size(pname);
const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
- (void) dpy;
emit_header(gc->pc, X_GLrop_PointParameterfvEXT, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_WindowPos3fvMESA 230
__indirect_glWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_WindowPos3fvMESA, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_WindowPos3fvMESA 230
__indirect_glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
- (void) dpy;
emit_header(gc->pc, X_GLrop_BlendFuncSeparateEXT, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&sfactorRGB), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&dfactorRGB), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&sfactorAlpha), 4);
(void) memcpy((void *)(gc->pc + 16), (void *)(&dfactorAlpha), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_FogCoordfvEXT 4124
__indirect_glFogCoordfEXT(GLfloat coord)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_FogCoordfvEXT, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_FogCoordfvEXT 4124
__indirect_glFogCoorddEXT(GLdouble coord)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_FogCoorddvEXT, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_FogCoorddvEXT 4125
__indirect_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_SecondaryColor3bvEXT, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
(void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
(void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_SecondaryColor3bvEXT 4126
__indirect_glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 28;
- (void) dpy;
emit_header(gc->pc, X_GLrop_SecondaryColor3dvEXT, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
(void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
(void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_SecondaryColor3dvEXT 4130
__indirect_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_SecondaryColor3fvEXT, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_SecondaryColor3fvEXT 4129
__indirect_glSecondaryColor3iEXT(GLint red, GLint green, GLint blue)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_SecondaryColor3ivEXT, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_SecondaryColor3ivEXT 4128
__indirect_glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_SecondaryColor3svEXT, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
(void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
(void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_SecondaryColor3svEXT 4128
__indirect_glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_SecondaryColor3ubvEXT, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
(void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
(void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_SecondaryColor3ubvEXT 4131
__indirect_glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
- (void) dpy;
emit_header(gc->pc, X_GLrop_SecondaryColor3uivEXT, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
(void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_SecondaryColor3uivEXT 4133
__indirect_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_SecondaryColor3usvEXT, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
(void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
(void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_SecondaryColor3usvEXT 4132
__indirect_glPointParameteriNV(GLenum pname, GLint params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 12;
- (void) dpy;
emit_header(gc->pc, X_GLrop_PointParameteriNV, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(¶ms), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_PointParameterivNV 4222
__indirect_glPointParameterivNV(GLenum pname, const GLint * params)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint compsize = __glPointParameterivNV_size(pname);
const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
- (void) dpy;
emit_header(gc->pc, X_GLrop_PointParameterivNV, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
(void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}
#define X_GLrop_ActiveStencilFaceEXT 4220
__indirect_glActiveStencilFaceEXT(GLenum face)
{
__GLXcontext * const gc = __glXGetCurrentContext();
- Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 8;
- (void) dpy;
emit_header(gc->pc, X_GLrop_ActiveStencilFaceEXT, cmdlen);
(void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
gc->pc += cmdlen;
- if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+ if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
}