andreacavalli/xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'master' into my-XACE-modular

Browse Source 
Conflicts:

	configure.ac
This commit is contained in:
Eamon Walsh 2006-09-05 18:03:25 -04:00 committed by Eamon Walsh
commit 0b81fccd2e
68 changed files with 5692 additions and 11129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
GL/glx/Makefile.am
View File

@ -31,13 +31,12 @@ INCLUDES = \
nodist_libglx_la_SOURCES = indirect_size.h
libglxdri_la_SOURCES = \
glxdri.c
glxdri.c \
extension_string.c \
extension_string.h
libglx_la_SOURCES = \
g_disptab.c \
g_disptab.h \
g_disptab_EXT.c \
g_disptab_EXT.h \
glapi.c \
glcontextmodes.c \
glcontextmodes.h \
@ -57,10 +56,14 @@ libglx_la_SOURCES = \
indirect_dispatch.c \
indirect_dispatch.h \
indirect_dispatch_swap.c \
indirect_program.c \
indirect_reqsize.c \
indirect_reqsize.h \
indirect_size_get.c \
indirect_size_get.h \
indirect_table.c \
indirect_table.h \
indirect_texture_compression.c \
indirect_util.c \
indirect_util.h \
render2.c \
@ -68,12 +71,12 @@ libglx_la_SOURCES = \
renderpix.c \
renderpixswap.c \
rensize.c \
rensizetab.c \
single2.c \
single2swap.c \
singlepix.c \
singlepixswap.c \
singlesize.c \
singlesize.h \
swap_interval.c \
unpack.h \
xfont.c

165
GL/glx/extension_string.c Normal file
View File

@ -0,0 +1,165 @@
/*
* (C) Copyright IBM Corporation 2002-2006
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* on the rights to use, copy, modify, merge, publish, distribute, sub
* license, and/or sell copies of the Software, and to permit persons to whom
* the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
* THE COPYRIGHT HOLDERS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
* USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/**
* \file extension_string.c
* Routines to manage the GLX extension string and GLX version for AIGLX
* drivers. This code is loosely based on src/glx/x11/glxextensions.c from
* Mesa.
*
* \author Ian Romanick <idr@us.ibm.com>
*/
#include <string.h>
#include "extension_string.h"
#define SET_BIT(m,b) (m[ (b) / 8 ] |= (1U << ((b) % 8)))
#define CLR_BIT(m,b) (m[ (b) / 8 ] &= ~(1U << ((b) % 8)))
#define IS_SET(m,b) ((m[ (b) / 8 ] & (1U << ((b) % 8))) != 0)
#define CONCAT(a,b) a ## b
#define GLX(n) "GLX_" # n, 4 + sizeof( # n ) - 1, CONCAT(n,_bit)
#define VER(a,b) a, b
#define Y 1
#define N 0
#define EXT_ENABLED(bit,supported) (IS_SET(supported, bit))
struct extension_info {
const char * const name;
unsigned name_len;
unsigned char bit;
/**
* This is the lowest version of GLX that "requires" this extension.
* For example, GLX 1.3 requires SGIX_fbconfig, SGIX_pbuffer, and
* SGI_make_current_read. If the extension is not required by any known
* version of GLX, use 0, 0.
*/
unsigned char version_major;
unsigned char version_minor;
/**
* Is driver support forced by the ABI?
*/
unsigned char driver_support;
};
static const struct extension_info known_glx_extensions[] = {
/* GLX_ARB_get_proc_address is implemented on the client. */
{ GLX(ARB_multisample), VER(1,4), Y, },
{ GLX(EXT_import_context), VER(0,0), Y, },
{ GLX(EXT_texture_from_pixmap), VER(0,0), Y, },
{ GLX(EXT_visual_info), VER(0,0), Y, },
{ GLX(EXT_visual_rating), VER(0,0), Y, },
{ GLX(MESA_copy_sub_buffer), VER(0,0), N, },
{ GLX(OML_swap_method), VER(0,0), Y, },
{ GLX(SGI_make_current_read), VER(1,3), N, },
{ GLX(SGI_swap_control), VER(0,0), N, },
{ GLX(SGIS_multisample), VER(0,0), Y, },
{ GLX(SGIX_fbconfig), VER(1,3), Y, },
{ GLX(SGIX_pbuffer), VER(1,3), N, },
{ GLX(SGIX_visual_select_group), VER(0,0), Y, },
{ NULL }
};
/**
* Create a GLX extension string for a set of enable bits.
*
* Creates a GLX extension string for the set of bit in \c enable_bits. This
* string is then stored in \c buffer if buffer is not \c NULL. This allows
* two-pass operation. On the first pass the caller passes \c NULL for
* \c buffer, and the function determines how much space is required to store
* the extension string. The caller allocates the buffer and calls the
* function again.
*
* \param enable_bits Bits representing the enabled extensions.
* \param buffer Buffer to store the extension string. May be \c NULL.
*
* \return
* The number of characters in \c buffer that were written to. If \c buffer
* is \c NULL, this is the size of buffer that must be allocated by the
* caller.
*/
int
__glXGetExtensionString(const unsigned char *enable_bits, char *buffer)
{
unsigned i;
int length = 0;
for (i = 0; known_glx_extensions[i].name != NULL; i++) {
const unsigned bit = known_glx_extensions[i].bit;
const size_t len = known_glx_extensions[i].name_len;
if (EXT_ENABLED(bit, enable_bits)) {
if (buffer != NULL) {
(void) memcpy(& buffer[length], known_glx_extensions[i].name,
len);
buffer[length + len + 0] = ' ';
buffer[length + len + 1] = '\0';
}
length += len + 1;
}
}
return length + 1;
}
void
__glXEnableExtension(unsigned char *enable_bits, const char *ext)
{
const size_t ext_name_len = strlen(ext);
unsigned i;
for (i = 0; known_glx_extensions[i].name != NULL; i++) {
if ((ext_name_len == known_glx_extensions[i].name_len)
&& (memcmp(ext, known_glx_extensions[i].name, ext_name_len) == 0)) {
SET_BIT(enable_bits, known_glx_extensions[i].bit);
break;
}
}
}
void
__glXInitExtensionEnableBits(unsigned char *enable_bits)
{
unsigned i;
(void) memset(enable_bits, 0, __GLX_EXT_BYTES);
for (i = 0; known_glx_extensions[i].name != NULL; i++) {
if (known_glx_extensions[i].driver_support) {
SET_BIT(enable_bits, known_glx_extensions[i].bit);
}
}
}

63
GL/glx/extension_string.h Normal file
View File

@ -0,0 +1,63 @@
/*
* (C) Copyright IBM Corporation 2002-2006
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* on the rights to use, copy, modify, merge, publish, distribute, sub
* license, and/or sell copies of the Software, and to permit persons to whom
* the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
* THE COPYRIGHT HOLDERS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
* USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/**
* \file extension_string.h
* Routines to manage the GLX extension string and GLX version for AIGLX
* drivers. This code is loosely based on src/glx/x11/glxextensions.c from
* Mesa.
*
* \author Ian Romanick <idr@us.ibm.com>
*/
#ifndef GLX_EXTENSION_STRING_H
#define GLX_EXTENSION_STRING_H
enum {
/* GLX_ARB_get_proc_address is implemented on the client. */
ARB_multisample_bit = 0,
EXT_import_context_bit,
EXT_texture_from_pixmap_bit,
EXT_visual_info_bit,
EXT_visual_rating_bit,
MESA_copy_sub_buffer_bit,
OML_swap_method_bit,
SGI_make_current_read_bit,
SGI_swap_control_bit,
SGI_video_sync_bit,
SGIS_multisample_bit,
SGIX_fbconfig_bit,
SGIX_pbuffer_bit,
SGIX_visual_select_group_bit,
__NUM_GLX_EXTS,
};
#define __GLX_EXT_BYTES ((__NUM_GLX_EXTS + 7) / 8)
extern int __glXGetExtensionString(const unsigned char *enable_bits,
char *buffer);
extern void __glXEnableExtension(unsigned char *enable_bits, const char *ext);
extern void __glXInitExtensionEnableBits(unsigned char *enable_bits);
#endif /* GLX_EXTENSION_STRING_H */

840
GL/glx/g_disptab.c
View File

@ -1,840 +0,0 @@
/* DO NOT EDIT - THIS FILE IS AUTOMATICALLY GENERATED */
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: This software was created using the
** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
** not been independently verified as being compliant with the OpenGL(R)
** version 1.2.1 Specification.
*/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include "glxserver.h"
#include "glxext.h"
#include "g_disptab.h"
#include "indirect_dispatch.h"
__GLXdispatchSingleProcPtr __glXSingleTable[__GLX_SINGLE_TABLE_SIZE] = {
__glXNoSuchSingleOpcode,
__glXRender,
__glXRenderLarge,
__glXCreateContext,
__glXDestroyContext,
__glXMakeCurrent,
__glXIsDirect,
__glXQueryVersion,
__glXWaitGL, /* 0x08 */
__glXWaitX,
__glXCopyContext,
__glXSwapBuffers,
__glXUseXFont,
__glXCreateGLXPixmap,
__glXGetVisualConfigs,
__glXDestroyGLXPixmap,
__glXVendorPrivate, /* 0x10 */
__glXVendorPrivateWithReply,
__glXQueryExtensionsString,
__glXQueryServerString,
__glXClientInfo,
__glXGetFBConfigs,
__glXCreatePixmap,
__glXDestroyPixmap,
__glXCreateNewContext, /* 0x18 */
__glXQueryContext,
__glXMakeContextCurrent,
__glXCreatePbuffer,
__glXDestroyPbuffer,
__glXGetDrawableAttributes,
__glXChangeDrawableAttributes,
__glXCreateWindow,
__glXDestroyWindow, /* 0x20 */
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXDisp_NewList,
__glXDisp_EndList,
__glXDisp_DeleteLists,
__glXDisp_GenLists,
__glXDisp_FeedbackBuffer,
__glXDisp_SelectBuffer,
__glXDisp_RenderMode,
__glXDisp_Finish,
__glXDisp_PixelStoref,
__glXDisp_PixelStorei,
__glXDisp_ReadPixels,
__glXDisp_GetBooleanv,
__glXDisp_GetClipPlane,
__glXDisp_GetDoublev,
__glXDisp_GetError,
__glXDisp_GetFloatv,
__glXDisp_GetIntegerv,
__glXDisp_GetLightfv,
__glXDisp_GetLightiv,
__glXDisp_GetMapdv,
__glXDisp_GetMapfv,
__glXDisp_GetMapiv,
__glXDisp_GetMaterialfv,
__glXDisp_GetMaterialiv,
__glXDisp_GetPixelMapfv,
__glXDisp_GetPixelMapuiv,
__glXDisp_GetPixelMapusv,
__glXDisp_GetPolygonStipple,
__glXDisp_GetString,
__glXDisp_GetTexEnvfv,
__glXDisp_GetTexEnviv,
__glXDisp_GetTexGendv,
__glXDisp_GetTexGenfv,
__glXDisp_GetTexGeniv,
__glXDisp_GetTexImage,
__glXDisp_GetTexParameterfv,
__glXDisp_GetTexParameteriv,
__glXDisp_GetTexLevelParameterfv,
__glXDisp_GetTexLevelParameteriv,
__glXDisp_IsEnabled,
__glXDisp_IsList,
__glXDisp_Flush,
__glXDisp_AreTexturesResident,
__glXDisp_DeleteTextures,
__glXDisp_GenTextures,
__glXDisp_IsTexture,
__glXDisp_GetColorTable,
__glXDisp_GetColorTableParameterfv,
__glXDisp_GetColorTableParameteriv,
__glXDisp_GetConvolutionFilter,
__glXDisp_GetConvolutionParameterfv,
__glXDisp_GetConvolutionParameteriv,
__glXDisp_GetSeparableFilter,
__glXDisp_GetHistogram,
__glXDisp_GetHistogramParameterfv,
__glXDisp_GetHistogramParameteriv,
__glXDisp_GetMinmax,
__glXDisp_GetMinmaxParameterfv,
__glXDisp_GetMinmaxParameteriv,
};
__GLXdispatchRenderProcPtr __glXRenderTable[] = {
__glXNoSuchRenderOpcode,
__glXDisp_CallList,
__glXDisp_CallLists,
__glXDisp_ListBase,
__glXDisp_Begin,
__glXDisp_Bitmap,
__glXDisp_Color3bv,
__glXDisp_Color3dv,
__glXDisp_Color3fv,
__glXDisp_Color3iv,
__glXDisp_Color3sv,
__glXDisp_Color3ubv,
__glXDisp_Color3uiv,
__glXDisp_Color3usv,
__glXDisp_Color4bv,
__glXDisp_Color4dv,
__glXDisp_Color4fv,
__glXDisp_Color4iv,
__glXDisp_Color4sv,
__glXDisp_Color4ubv,
__glXDisp_Color4uiv,
__glXDisp_Color4usv,
__glXDisp_EdgeFlagv,
__glXDisp_End,
__glXDisp_Indexdv,
__glXDisp_Indexfv,
__glXDisp_Indexiv,
__glXDisp_Indexsv,
__glXDisp_Normal3bv,
__glXDisp_Normal3dv,
__glXDisp_Normal3fv,
__glXDisp_Normal3iv,
__glXDisp_Normal3sv,
__glXDisp_RasterPos2dv,
__glXDisp_RasterPos2fv,
__glXDisp_RasterPos2iv,
__glXDisp_RasterPos2sv,
__glXDisp_RasterPos3dv,
__glXDisp_RasterPos3fv,
__glXDisp_RasterPos3iv,
__glXDisp_RasterPos3sv,
__glXDisp_RasterPos4dv,
__glXDisp_RasterPos4fv,
__glXDisp_RasterPos4iv,
__glXDisp_RasterPos4sv,
__glXDisp_Rectdv,
__glXDisp_Rectfv,
__glXDisp_Rectiv,
__glXDisp_Rectsv,
__glXDisp_TexCoord1dv,
__glXDisp_TexCoord1fv,
__glXDisp_TexCoord1iv,
__glXDisp_TexCoord1sv,
__glXDisp_TexCoord2dv,
__glXDisp_TexCoord2fv,
__glXDisp_TexCoord2iv,
__glXDisp_TexCoord2sv,
__glXDisp_TexCoord3dv,
__glXDisp_TexCoord3fv,
__glXDisp_TexCoord3iv,
__glXDisp_TexCoord3sv,
__glXDisp_TexCoord4dv,
__glXDisp_TexCoord4fv,
__glXDisp_TexCoord4iv,
__glXDisp_TexCoord4sv,
__glXDisp_Vertex2dv,
__glXDisp_Vertex2fv,
__glXDisp_Vertex2iv,
__glXDisp_Vertex2sv,
__glXDisp_Vertex3dv,
__glXDisp_Vertex3fv,
__glXDisp_Vertex3iv,
__glXDisp_Vertex3sv,
__glXDisp_Vertex4dv,
__glXDisp_Vertex4fv,
__glXDisp_Vertex4iv,
__glXDisp_Vertex4sv,
__glXDisp_ClipPlane,
__glXDisp_ColorMaterial,
__glXDisp_CullFace,
__glXDisp_Fogf,
__glXDisp_Fogfv,
__glXDisp_Fogi,
__glXDisp_Fogiv,
__glXDisp_FrontFace,
__glXDisp_Hint,
__glXDisp_Lightf,
__glXDisp_Lightfv,
__glXDisp_Lighti,
__glXDisp_Lightiv,
__glXDisp_LightModelf,
__glXDisp_LightModelfv,
__glXDisp_LightModeli,
__glXDisp_LightModeliv,
__glXDisp_LineStipple,
__glXDisp_LineWidth,
__glXDisp_Materialf,
__glXDisp_Materialfv,
__glXDisp_Materiali,
__glXDisp_Materialiv,
__glXDisp_PointSize,
__glXDisp_PolygonMode,
__glXDisp_PolygonStipple,
__glXDisp_Scissor,
__glXDisp_ShadeModel,
__glXDisp_TexParameterf,
__glXDisp_TexParameterfv,
__glXDisp_TexParameteri,
__glXDisp_TexParameteriv,
__glXDisp_TexImage1D,
__glXDisp_TexImage2D,
__glXDisp_TexEnvf,
__glXDisp_TexEnvfv,
__glXDisp_TexEnvi,
__glXDisp_TexEnviv,
__glXDisp_TexGend,
__glXDisp_TexGendv,
__glXDisp_TexGenf,
__glXDisp_TexGenfv,
__glXDisp_TexGeni,
__glXDisp_TexGeniv,
__glXDisp_InitNames,
__glXDisp_LoadName,
__glXDisp_PassThrough,
__glXDisp_PopName,
__glXDisp_PushName,
__glXDisp_DrawBuffer,
__glXDisp_Clear,
__glXDisp_ClearAccum,
__glXDisp_ClearIndex,
__glXDisp_ClearColor,
__glXDisp_ClearStencil,
__glXDisp_ClearDepth,
__glXDisp_StencilMask,
__glXDisp_ColorMask,
__glXDisp_DepthMask,
__glXDisp_IndexMask,
__glXDisp_Accum,
__glXDisp_Disable,
__glXDisp_Enable,
__glXNoSuchRenderOpcode,
__glXDisp_PopAttrib,
__glXDisp_PushAttrib,
__glXDisp_Map1d,
__glXDisp_Map1f,
__glXDisp_Map2d,
__glXDisp_Map2f,
__glXDisp_MapGrid1d,
__glXDisp_MapGrid1f,
__glXDisp_MapGrid2d,
__glXDisp_MapGrid2f,
__glXDisp_EvalCoord1dv,
__glXDisp_EvalCoord1fv,
__glXDisp_EvalCoord2dv,
__glXDisp_EvalCoord2fv,
__glXDisp_EvalMesh1,
__glXDisp_EvalPoint1,
__glXDisp_EvalMesh2,
__glXDisp_EvalPoint2,
__glXDisp_AlphaFunc,
__glXDisp_BlendFunc,
__glXDisp_LogicOp,
__glXDisp_StencilFunc,
__glXDisp_StencilOp,
__glXDisp_DepthFunc,
__glXDisp_PixelZoom,
__glXDisp_PixelTransferf,
__glXDisp_PixelTransferi,
__glXDisp_PixelMapfv,
__glXDisp_PixelMapuiv,
__glXDisp_PixelMapusv,
__glXDisp_ReadBuffer,
__glXDisp_CopyPixels,
__glXDisp_DrawPixels,
__glXDisp_DepthRange,
__glXDisp_Frustum,
__glXDisp_LoadIdentity,
__glXDisp_LoadMatrixf,
__glXDisp_LoadMatrixd,
__glXDisp_MatrixMode,
__glXDisp_MultMatrixf,
__glXDisp_MultMatrixd,
__glXDisp_Ortho,
__glXDisp_PopMatrix,
__glXDisp_PushMatrix,
__glXDisp_Rotated,
__glXDisp_Rotatef,
__glXDisp_Scaled,
__glXDisp_Scalef,
__glXDisp_Translated,
__glXDisp_Translatef,
__glXDisp_Viewport,
__glXDisp_PolygonOffset,
__glXDisp_DrawArrays,
__glXDisp_Indexubv,
__glXDisp_ColorSubTable,
__glXDisp_CopyColorSubTable,
__glXDisp_ActiveTextureARB,
__glXDisp_MultiTexCoord1dvARB,
__glXDisp_MultiTexCoord1fvARB,
__glXDisp_MultiTexCoord1ivARB,
__glXDisp_MultiTexCoord1svARB,
__glXDisp_MultiTexCoord2dvARB,
__glXDisp_MultiTexCoord2fvARB,
__glXDisp_MultiTexCoord2ivARB,
__glXDisp_MultiTexCoord2svARB,
__glXDisp_MultiTexCoord3dvARB,
__glXDisp_MultiTexCoord3fvARB,
__glXDisp_MultiTexCoord3ivARB,
__glXDisp_MultiTexCoord3svARB,
__glXDisp_MultiTexCoord4dvARB,
__glXDisp_MultiTexCoord4fvARB,
__glXDisp_MultiTexCoord4ivARB,
__glXDisp_MultiTexCoord4svARB, /* 213 */
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode, /* 220 */
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXDisp_SampleCoverageARB,
#ifndef MISSING_GL_EXTS
__glXDisp_WindowPos3fvMESA /* 230 */
#else
__glXNoSuchRenderOpcode
#endif
};
__GLXdispatchSingleProcPtr __glXSwapSingleTable[__GLX_SINGLE_TABLE_SIZE] = {
__glXNoSuchSingleOpcode,
__glXSwapRender,
__glXSwapRenderLarge,
__glXSwapCreateContext,
__glXSwapDestroyContext,
__glXSwapMakeCurrent,
__glXSwapIsDirect,
__glXSwapQueryVersion,
__glXSwapWaitGL, /* 0x08 */
__glXSwapWaitX,
__glXSwapCopyContext,
__glXSwapSwapBuffers,
__glXSwapUseXFont,
__glXSwapCreateGLXPixmap,
__glXSwapGetVisualConfigs,
__glXSwapDestroyGLXPixmap,
__glXSwapVendorPrivate, /* 0x10 */
__glXSwapVendorPrivateWithReply,
__glXSwapQueryExtensionsString,
__glXSwapQueryServerString,
__glXSwapClientInfo,
__glXSwapGetFBConfigs,
__glXSwapCreatePixmap,
__glXSwapDestroyPixmap,
__glXSwapCreateNewContext, /* 0x18 */
__glXSwapQueryContext,
__glXSwapMakeContextCurrent,
__glXSwapCreatePbuffer,
__glXSwapDestroyPbuffer,
__glXSwapGetDrawableAttributes,
__glXSwapChangeDrawableAttributes,
__glXSwapCreateWindow,
__glXSwapDestroyWindow, /* 0x20 */
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXNoSuchSingleOpcode,
__glXDispSwap_NewList,
__glXDispSwap_EndList,
__glXDispSwap_DeleteLists,
__glXDispSwap_GenLists,
__glXDispSwap_FeedbackBuffer,
__glXDispSwap_SelectBuffer,
__glXDispSwap_RenderMode,
__glXDispSwap_Finish,
__glXDispSwap_PixelStoref,
__glXDispSwap_PixelStorei,
__glXDispSwap_ReadPixels,
__glXDispSwap_GetBooleanv,
__glXDispSwap_GetClipPlane,
__glXDispSwap_GetDoublev,
__glXDispSwap_GetError,
__glXDispSwap_GetFloatv,
__glXDispSwap_GetIntegerv,
__glXDispSwap_GetLightfv,
__glXDispSwap_GetLightiv,
__glXDispSwap_GetMapdv,
__glXDispSwap_GetMapfv,
__glXDispSwap_GetMapiv,
__glXDispSwap_GetMaterialfv,
__glXDispSwap_GetMaterialiv,
__glXDispSwap_GetPixelMapfv,
__glXDispSwap_GetPixelMapuiv,
__glXDispSwap_GetPixelMapusv,
__glXDispSwap_GetPolygonStipple,
__glXDispSwap_GetString,
__glXDispSwap_GetTexEnvfv,
__glXDispSwap_GetTexEnviv,
__glXDispSwap_GetTexGendv,
__glXDispSwap_GetTexGenfv,
__glXDispSwap_GetTexGeniv,
__glXDispSwap_GetTexImage,
__glXDispSwap_GetTexParameterfv,
__glXDispSwap_GetTexParameteriv,
__glXDispSwap_GetTexLevelParameterfv,
__glXDispSwap_GetTexLevelParameteriv,
__glXDispSwap_IsEnabled,
__glXDispSwap_IsList,
__glXDispSwap_Flush,
__glXDispSwap_AreTexturesResident,
__glXDispSwap_DeleteTextures,
__glXDispSwap_GenTextures,
__glXDispSwap_IsTexture,
__glXDispSwap_GetColorTable,
__glXDispSwap_GetColorTableParameterfv,
__glXDispSwap_GetColorTableParameteriv,
__glXDispSwap_GetConvolutionFilter,
__glXDispSwap_GetConvolutionParameterfv,
__glXDispSwap_GetConvolutionParameteriv,
__glXDispSwap_GetSeparableFilter,
__glXDispSwap_GetHistogram,
__glXDispSwap_GetHistogramParameterfv,
__glXDispSwap_GetHistogramParameteriv,
__glXDispSwap_GetMinmax,
__glXDispSwap_GetMinmaxParameterfv,
__glXDispSwap_GetMinmaxParameteriv,
};
__GLXdispatchRenderProcPtr __glXSwapRenderTable[__GLX_RENDER_TABLE_SIZE] = {
__glXNoSuchRenderOpcode,
__glXDispSwap_CallList,
__glXDispSwap_CallLists,
__glXDispSwap_ListBase,
__glXDispSwap_Begin,
__glXDispSwap_Bitmap,
__glXDispSwap_Color3bv,
__glXDispSwap_Color3dv,
__glXDispSwap_Color3fv,
__glXDispSwap_Color3iv,
__glXDispSwap_Color3sv,
__glXDispSwap_Color3ubv,
__glXDispSwap_Color3uiv,
__glXDispSwap_Color3usv,
__glXDispSwap_Color4bv,
__glXDispSwap_Color4dv,
__glXDispSwap_Color4fv,
__glXDispSwap_Color4iv,
__glXDispSwap_Color4sv,
__glXDispSwap_Color4ubv,
__glXDispSwap_Color4uiv,
__glXDispSwap_Color4usv,
__glXDispSwap_EdgeFlagv,
__glXDispSwap_End,
__glXDispSwap_Indexdv,
__glXDispSwap_Indexfv,
__glXDispSwap_Indexiv,
__glXDispSwap_Indexsv,
__glXDispSwap_Normal3bv,
__glXDispSwap_Normal3dv,
__glXDispSwap_Normal3fv,
__glXDispSwap_Normal3iv,
__glXDispSwap_Normal3sv,
__glXDispSwap_RasterPos2dv,
__glXDispSwap_RasterPos2fv,
__glXDispSwap_RasterPos2iv,
__glXDispSwap_RasterPos2sv,
__glXDispSwap_RasterPos3dv,
__glXDispSwap_RasterPos3fv,
__glXDispSwap_RasterPos3iv,
__glXDispSwap_RasterPos3sv,
__glXDispSwap_RasterPos4dv,
__glXDispSwap_RasterPos4fv,
__glXDispSwap_RasterPos4iv,
__glXDispSwap_RasterPos4sv,
__glXDispSwap_Rectdv,
__glXDispSwap_Rectfv,
__glXDispSwap_Rectiv,
__glXDispSwap_Rectsv,
__glXDispSwap_TexCoord1dv,
__glXDispSwap_TexCoord1fv,
__glXDispSwap_TexCoord1iv,
__glXDispSwap_TexCoord1sv,
__glXDispSwap_TexCoord2dv,
__glXDispSwap_TexCoord2fv,
__glXDispSwap_TexCoord2iv,
__glXDispSwap_TexCoord2sv,
__glXDispSwap_TexCoord3dv,
__glXDispSwap_TexCoord3fv,
__glXDispSwap_TexCoord3iv,
__glXDispSwap_TexCoord3sv,
__glXDispSwap_TexCoord4dv,
__glXDispSwap_TexCoord4fv,
__glXDispSwap_TexCoord4iv,
__glXDispSwap_TexCoord4sv,
__glXDispSwap_Vertex2dv,
__glXDispSwap_Vertex2fv,
__glXDispSwap_Vertex2iv,
__glXDispSwap_Vertex2sv,
__glXDispSwap_Vertex3dv,
__glXDispSwap_Vertex3fv,
__glXDispSwap_Vertex3iv,
__glXDispSwap_Vertex3sv,
__glXDispSwap_Vertex4dv,
__glXDispSwap_Vertex4fv,
__glXDispSwap_Vertex4iv,
__glXDispSwap_Vertex4sv,
__glXDispSwap_ClipPlane,
__glXDispSwap_ColorMaterial,
__glXDispSwap_CullFace,
__glXDispSwap_Fogf,
__glXDispSwap_Fogfv,
__glXDispSwap_Fogi,
__glXDispSwap_Fogiv,
__glXDispSwap_FrontFace,
__glXDispSwap_Hint,
__glXDispSwap_Lightf,
__glXDispSwap_Lightfv,
__glXDispSwap_Lighti,
__glXDispSwap_Lightiv,
__glXDispSwap_LightModelf,
__glXDispSwap_LightModelfv,
__glXDispSwap_LightModeli,
__glXDispSwap_LightModeliv,
__glXDispSwap_LineStipple,
__glXDispSwap_LineWidth,
__glXDispSwap_Materialf,
__glXDispSwap_Materialfv,
__glXDispSwap_Materiali,
__glXDispSwap_Materialiv,
__glXDispSwap_PointSize,
__glXDispSwap_PolygonMode,
__glXDispSwap_PolygonStipple,
__glXDispSwap_Scissor,
__glXDispSwap_ShadeModel,
__glXDispSwap_TexParameterf,
__glXDispSwap_TexParameterfv,
__glXDispSwap_TexParameteri,
__glXDispSwap_TexParameteriv,
__glXDispSwap_TexImage1D,
__glXDispSwap_TexImage2D,
__glXDispSwap_TexEnvf,
__glXDispSwap_TexEnvfv,
__glXDispSwap_TexEnvi,
__glXDispSwap_TexEnviv,
__glXDispSwap_TexGend,
__glXDispSwap_TexGendv,
__glXDispSwap_TexGenf,
__glXDispSwap_TexGenfv,
__glXDispSwap_TexGeni,
__glXDispSwap_TexGeniv,
__glXDispSwap_InitNames,
__glXDispSwap_LoadName,
__glXDispSwap_PassThrough,
__glXDispSwap_PopName,
__glXDispSwap_PushName,
__glXDispSwap_DrawBuffer,
__glXDispSwap_Clear,
__glXDispSwap_ClearAccum,
__glXDispSwap_ClearIndex,
__glXDispSwap_ClearColor,
__glXDispSwap_ClearStencil,
__glXDispSwap_ClearDepth,
__glXDispSwap_StencilMask,
__glXDispSwap_ColorMask,
__glXDispSwap_DepthMask,
__glXDispSwap_IndexMask,
__glXDispSwap_Accum,
__glXDispSwap_Disable,
__glXDispSwap_Enable,
__glXNoSuchRenderOpcode,
__glXDispSwap_PopAttrib,
__glXDispSwap_PushAttrib,
__glXDispSwap_Map1d,
__glXDispSwap_Map1f,
__glXDispSwap_Map2d,
__glXDispSwap_Map2f,
__glXDispSwap_MapGrid1d,
__glXDispSwap_MapGrid1f,
__glXDispSwap_MapGrid2d,
__glXDispSwap_MapGrid2f,
__glXDispSwap_EvalCoord1dv,
__glXDispSwap_EvalCoord1fv,
__glXDispSwap_EvalCoord2dv,
__glXDispSwap_EvalCoord2fv,
__glXDispSwap_EvalMesh1,
__glXDispSwap_EvalPoint1,
__glXDispSwap_EvalMesh2,
__glXDispSwap_EvalPoint2,
__glXDispSwap_AlphaFunc,
__glXDispSwap_BlendFunc,
__glXDispSwap_LogicOp,
__glXDispSwap_StencilFunc,
__glXDispSwap_StencilOp,
__glXDispSwap_DepthFunc,
__glXDispSwap_PixelZoom,
__glXDispSwap_PixelTransferf,
__glXDispSwap_PixelTransferi,
__glXDispSwap_PixelMapfv,
__glXDispSwap_PixelMapuiv,
__glXDispSwap_PixelMapusv,
__glXDispSwap_ReadBuffer,
__glXDispSwap_CopyPixels,
__glXDispSwap_DrawPixels,
__glXDispSwap_DepthRange,
__glXDispSwap_Frustum,
__glXDispSwap_LoadIdentity,
__glXDispSwap_LoadMatrixf,
__glXDispSwap_LoadMatrixd,
__glXDispSwap_MatrixMode,
__glXDispSwap_MultMatrixf,
__glXDispSwap_MultMatrixd,
__glXDispSwap_Ortho,
__glXDispSwap_PopMatrix,
__glXDispSwap_PushMatrix,
__glXDispSwap_Rotated,
__glXDispSwap_Rotatef,
__glXDispSwap_Scaled,
__glXDispSwap_Scalef,
__glXDispSwap_Translated,
__glXDispSwap_Translatef,
__glXDispSwap_Viewport,
__glXDispSwap_PolygonOffset,
__glXDispSwap_DrawArrays,
__glXDispSwap_Indexubv,
__glXDispSwap_ColorSubTable,
__glXDispSwap_CopyColorSubTable,
__glXDispSwap_ActiveTextureARB,
__glXDispSwap_MultiTexCoord1dvARB,
__glXDispSwap_MultiTexCoord1fvARB,
__glXDispSwap_MultiTexCoord1ivARB,
__glXDispSwap_MultiTexCoord1svARB,
__glXDispSwap_MultiTexCoord2dvARB,
__glXDispSwap_MultiTexCoord2fvARB,
__glXDispSwap_MultiTexCoord2ivARB,
__glXDispSwap_MultiTexCoord2svARB,
__glXDispSwap_MultiTexCoord3dvARB,
__glXDispSwap_MultiTexCoord3fvARB,
__glXDispSwap_MultiTexCoord3ivARB,
__glXDispSwap_MultiTexCoord3svARB,
__glXDispSwap_MultiTexCoord4dvARB,
__glXDispSwap_MultiTexCoord4fvARB,
__glXDispSwap_MultiTexCoord4ivARB,
__glXDispSwap_MultiTexCoord4svARB, /* 213 */
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode, /* 220 */
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
__glXDispSwap_SampleCoverageARB,
#ifndef MISSING_GL_EXTS
__glXDispSwap_WindowPos3fvMESA /* 230 */
#else
__glXNoSuchRenderOpcode
#endif
};

110
GL/glx/g_disptab.h
View File

@ -34,102 +34,20 @@
** version 1.2.1 Specification.
*/
extern int __glXRender(__GLXclientState*, GLbyte*);
extern int __glXRenderLarge(__GLXclientState*, GLbyte*);
extern int __glXCreateContext(__GLXclientState*, GLbyte*);
extern int __glXDestroyContext(__GLXclientState*, GLbyte*);
extern int __glXMakeCurrent(__GLXclientState*, GLbyte*);
extern int __glXIsDirect(__GLXclientState*, GLbyte*);
extern int __glXQueryVersion(__GLXclientState*, GLbyte*);
extern int __glXWaitGL(__GLXclientState*, GLbyte*);
extern int __glXWaitX(__GLXclientState*, GLbyte*);
extern int __glXCopyContext(__GLXclientState*, GLbyte*);
extern int __glXSwapBuffers(__GLXclientState*, GLbyte*);
extern int __glXBindTexImageEXT(__GLXclientState *cl, GLbyte *pc);
extern int __glXReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc);
extern int __glXCopySubBufferMESA(__GLXclientState *cl, GLbyte *pc);
extern int __glXGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc);
extern int __glXUseXFont(__GLXclientState*, GLbyte*);
extern int __glXCreateGLXPixmap(__GLXclientState*, GLbyte*);
extern int __glXGetVisualConfigs(__GLXclientState*, GLbyte*);
extern int __glXDestroyGLXPixmap(__GLXclientState*, GLbyte*);
extern int __glXVendorPrivate(__GLXclientState*, GLbyte*);
extern int __glXVendorPrivateWithReply(__GLXclientState*, GLbyte*);
extern int __glXQueryExtensionsString(__GLXclientState*, GLbyte*);
extern int __glXQueryServerString(__GLXclientState*, GLbyte*);
extern int __glXClientInfo(__GLXclientState*, GLbyte*);
extern int __glXMakeContextCurrent(__GLXclientState*, GLbyte*);
extern int __glXGetFBConfigs(__GLXclientState*, GLbyte*);
extern int __glXCreatePixmap(__GLXclientState*, GLbyte*);
extern int __glXDestroyPixmap(__GLXclientState*, GLbyte*);
extern int __glXCreateNewContext(__GLXclientState*, GLbyte*);
extern int __glXQueryContext(__GLXclientState*, GLbyte*);
extern int __glXMakeContextCurrent(__GLXclientState*, GLbyte*);
extern int __glXCreatePbuffer(__GLXclientState*, GLbyte*);
extern int __glXDestroyPbuffer(__GLXclientState*, GLbyte*);
extern int __glXGetDrawableAttributes(__GLXclientState*, GLbyte*);
extern int __glXChangeDrawableAttributes(__GLXclientState*, GLbyte*);
extern int __glXCreateWindow(__GLXclientState*, GLbyte*);
extern int __glXDestroyWindow(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc);
extern int __glXDisp_BindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc);
extern int __glXDisp_QueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc);
extern int __glXDisp_QueryHyperpipeNetworkSGIX(__GLXclientState *cl, GLbyte *pc);
extern int __glXDisp_DestroyHyperpipeConfigSGIX (__GLXclientState *cl, GLbyte *pc);
extern int __glXDisp_QueryHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc);
extern int __glXDisp_HyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc);
extern int __glXSwapRender(__GLXclientState*, GLbyte*);
extern int __glXSwapRenderLarge(__GLXclientState*, GLbyte*);
extern int __glXSwapCreateContext(__GLXclientState*, GLbyte*);
extern int __glXSwapDestroyContext(__GLXclientState*, GLbyte*);
extern int __glXSwapMakeCurrent(__GLXclientState*, GLbyte*);
extern int __glXSwapIsDirect(__GLXclientState*, GLbyte*);
extern int __glXSwapQueryVersion(__GLXclientState*, GLbyte*);
extern int __glXSwapWaitGL(__GLXclientState*, GLbyte*);
extern int __glXSwapWaitX(__GLXclientState*, GLbyte*);
extern int __glXSwapCopyContext(__GLXclientState*, GLbyte*);
extern int __glXSwapSwapBuffers(__GLXclientState*, GLbyte*);
extern int __glXSwapBindTexImageEXT(__GLXclientState *cl, GLbyte *pc);
extern int __glXSwapReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc);
extern int __glXSwapReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc);
extern int __glXSwapGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc);
extern int __glXSwapUseXFont(__GLXclientState*, GLbyte*);
extern int __glXSwapCreateGLXPixmap(__GLXclientState*, GLbyte*);
extern int __glXSwapGetVisualConfigs(__GLXclientState*, GLbyte*);
extern int __glXSwapDestroyGLXPixmap(__GLXclientState*, GLbyte*);
extern int __glXSwapVendorPrivate(__GLXclientState*, GLbyte*);
extern int __glXSwapVendorPrivateWithReply(__GLXclientState*, GLbyte*);
extern int __glXSwapQueryExtensionsString(__GLXclientState*, GLbyte*);
extern int __glXSwapQueryServerString(__GLXclientState*, GLbyte*);
extern int __glXSwapClientInfo(__GLXclientState*, GLbyte*);
extern int __glXSwapMakeContextCurrent(__GLXclientState*, GLbyte*);
extern int __glXSwapGetFBConfigs(__GLXclientState*, GLbyte*);
extern int __glXSwapCreatePixmap(__GLXclientState*, GLbyte*);
extern int __glXSwapDestroyPixmap(__GLXclientState*, GLbyte*);
extern int __glXSwapCreateNewContext(__GLXclientState*, GLbyte*);
extern int __glXSwapQueryContext(__GLXclientState*, GLbyte*);
extern int __glXSwapMakeContextCurrent(__GLXclientState*, GLbyte*);
extern int __glXSwapCreatePbuffer(__GLXclientState*, GLbyte*);
extern int __glXSwapDestroyPbuffer(__GLXclientState*, GLbyte*);
extern int __glXSwapGetDrawableAttributes(__GLXclientState*, GLbyte*);
extern int __glXSwapChangeDrawableAttributes(__GLXclientState*, GLbyte*);
extern int __glXSwapCreateWindow(__GLXclientState*, GLbyte*);
extern int __glXSwapDestroyWindow(__GLXclientState*, GLbyte*);
#define __GLX_MIN_GLXCMD_OPCODE 1
#define __GLX_MAX_GLXCMD_OPCODE 20
#define __GLX_MIN_RENDER_OPCODE 1
/*#define __GLX_MAX_RENDER_OPCODE 213*/
#define __GLX_MAX_RENDER_OPCODE 230
#define __GLX_MIN_SINGLE_OPCODE 1
#define __GLX_MAX_SINGLE_OPCODE 159
#define __GLX_SINGLE_TABLE_SIZE 160
/*#define __GLX_RENDER_TABLE_SIZE 214*/
#define __GLX_RENDER_TABLE_SIZE 231
extern __GLXdispatchRenderProcPtr __glXRenderTable[__GLX_RENDER_TABLE_SIZE];
extern __GLXdispatchSingleProcPtr __glXSingleTable[__GLX_SINGLE_TABLE_SIZE];
extern __GLXdispatchRenderProcPtr __glXSwapRenderTable[__GLX_RENDER_TABLE_SIZE];
extern __GLXdispatchSingleProcPtr __glXSwapSingleTable[__GLX_SINGLE_TABLE_SIZE];
/* Copied from mesa src/glx/x11/glxcmds.c
*
* Apparently there's no standardized opcode for this extension.
*/
#define X_GLXvop_CopySubBufferMESA 5154 /* temporary */
extern int __glXDispSwap_GetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc);
extern int __glXDispSwap_BindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc);
extern int __glXDispSwap_QueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc);
extern int __glXDispSwap_QueryHyperpipeNetworkSGIX(__GLXclientState *cl, GLbyte *pc);
extern int __glXDispSwap_DestroyHyperpipeConfigSGIX (__GLXclientState *cl, GLbyte *pc);
extern int __glXDispSwap_QueryHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc);
extern int __glXDispSwap_HyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc);
#endif /* _GLX_g_disptab_h_ */

4656
GL/glx/g_disptab_EXT.c
View File

File diff suppressed because it is too large Load Diff

47
GL/glx/g_disptab_EXT.h
View File

@ -1,47 +0,0 @@
/* DO NOT EDIT - THIS FILE IS AUTOMATICALLY GENERATED */
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#ifndef _GLX_g_disptab_EXT_h_
#define _GLX_g_disptab_EXT_h_
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: This software was created using the
** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
** not been independently verified as being compliant with the OpenGL(R)
** version 1.2.1 Specification.
*/
#define __GLX_MIN_RENDER_OPCODE_EXT 2053
#define __GLX_MAX_RENDER_OPCODE_EXT 4325
#define __GLX_MIN_VENDPRIV_OPCODE_EXT 11
#define __GLX_MAX_VENDPRIV_OPCODE_EXT 14
#define __GLX_VENDPRIV_TABLE_SIZE_EXT (__GLX_MAX_VENDPRIV_OPCODE_EXT - __GLX_MIN_VENDPRIV_OPCODE_EXT + 1)
#define __GLX_RENDER_TABLE_SIZE_EXT (__GLX_MAX_RENDER_OPCODE_EXT - __GLX_MIN_RENDER_OPCODE_EXT + 1)
extern __GLXdispatchRenderProcPtr __glXRenderTable_EXT[__GLX_RENDER_TABLE_SIZE_EXT];
extern __GLXdispatchVendorPrivProcPtr __glXVendorPrivTable_EXT[__GLX_VENDPRIV_TABLE_SIZE_EXT];
extern __GLXdispatchRenderProcPtr __glXSwapRenderTable_EXT[__GLX_RENDER_TABLE_SIZE_EXT];
extern __GLXdispatchVendorPrivProcPtr __glXSwapVendorPrivTable_EXT[__GLX_VENDPRIV_TABLE_SIZE_EXT];
#endif /* _GLX_g_disptab_EXT_h_ */

356
GL/glx/glxcmds.c
View File

@ -48,7 +48,6 @@
#include "g_disptab.h"
#include <pixmapstr.h>
#include <windowstr.h>
#include "g_disptab_EXT.h"
#include "glxutil.h"
#include "glxext.h"
#include "glcontextmodes.h"
@ -57,6 +56,8 @@
#include "glthread.h"
#include "dispatch.h"
#include "indirect_dispatch.h"
#include "indirect_table.h"
#include "indirect_util.h"
/************************************************************************/
@ -66,18 +67,6 @@ GlxSetRenderTables (struct _glapi_table *table)
_glapi_set_dispatch (table);
}
static int __glXGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc);
static int __glXCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc);
static int __glXCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc);
static int __glXMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc);
static int __glXBindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc);
static int __glXQueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc);
static int __glxQueryHyperpipeNetworkSGIX(__GLXclientState *cl, GLbyte *pc);
static int __glxDestroyHyperpipeConfigSGIX (__GLXclientState *cl, GLbyte *pc);
static int __glxQueryHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc);
static int __glxHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc);
/************************************************************************/
@ -254,7 +243,7 @@ int DoCreateContext(__GLXclientState *cl, GLXContextID gcId,
}
int __glXCreateContext(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_CreateContext(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;
return DoCreateContext( cl, req->context, req->shareList, req->visual,
@ -262,7 +251,7 @@ int __glXCreateContext(__GLXclientState *cl, GLbyte *pc)
}
int __glXCreateNewContext(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_CreateNewContext(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreateNewContextReq *req = (xGLXCreateNewContextReq *) pc;
return DoCreateContext( cl, req->context, req->shareList, req->fbconfig,
@ -270,7 +259,7 @@ int __glXCreateNewContext(__GLXclientState *cl, GLbyte *pc)
}
int __glXCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_CreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreateContextWithConfigSGIXReq *req =
(xGLXCreateContextWithConfigSGIXReq *) pc;
@ -281,7 +270,7 @@ int __glXCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
/*
** Destroy a GL context as an X resource.
*/
int __glXDestroyContext(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_DestroyContext(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXDestroyContextReq *req = (xGLXDestroyContextReq *) pc;
@ -399,7 +388,7 @@ static void StartUsingContext(__GLXclientState *cl, __GLXcontext *glxc)
** Make an OpenGL context and drawable current.
*/
int __glXMakeCurrent(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_MakeCurrent(__GLXclientState *cl, GLbyte *pc)
{
xGLXMakeCurrentReq *req = (xGLXMakeCurrentReq *) pc;
@ -407,7 +396,7 @@ int __glXMakeCurrent(__GLXclientState *cl, GLbyte *pc)
req->context, req->oldContextTag );
}
int __glXMakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_MakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
{
xGLXMakeContextCurrentReq *req = (xGLXMakeContextCurrentReq *) pc;
@ -415,7 +404,7 @@ int __glXMakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
req->context, req->oldContextTag );
}
int __glXMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_MakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
{
xGLXMakeCurrentReadSGIReq *req = (xGLXMakeCurrentReadSGIReq *) pc;
@ -750,7 +739,7 @@ int DoMakeCurrent( __GLXclientState *cl,
return Success;
}
int __glXIsDirect(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_IsDirect(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXIsDirectReq *req = (xGLXIsDirectReq *) pc;
@ -780,7 +769,7 @@ int __glXIsDirect(__GLXclientState *cl, GLbyte *pc)
return Success;
}
int __glXQueryVersion(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_QueryVersion(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) pc;
@ -811,7 +800,7 @@ int __glXQueryVersion(__GLXclientState *cl, GLbyte *pc)
return Success;
}
int __glXWaitGL(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_WaitGL(__GLXclientState *cl, GLbyte *pc)
{
xGLXWaitGLReq *req = (xGLXWaitGLReq *)pc;
int error;
@ -823,7 +812,7 @@ int __glXWaitGL(__GLXclientState *cl, GLbyte *pc)
return Success;
}
int __glXWaitX(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_WaitX(__GLXclientState *cl, GLbyte *pc)
{
xGLXWaitXReq *req = (xGLXWaitXReq *)pc;
int error;
@ -840,7 +829,7 @@ int __glXWaitX(__GLXclientState *cl, GLbyte *pc)
return Success;
}
int __glXCopyContext(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_CopyContext(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXCopyContextReq *req = (xGLXCopyContextReq *) pc;
@ -1011,7 +1000,7 @@ int DoGetVisualConfigs(__GLXclientState *cl, unsigned screen,
return Success;
}
int __glXGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_GetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
{
xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;
return DoGetVisualConfigs( cl, req->screen, GL_FALSE );
@ -1187,14 +1176,14 @@ int DoGetFBConfigs(__GLXclientState *cl, unsigned screen, GLboolean do_swap)
}
int __glXGetFBConfigs(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_GetFBConfigs(__GLXclientState *cl, GLbyte *pc)
{
xGLXGetFBConfigsReq *req = (xGLXGetFBConfigsReq *) pc;
return DoGetFBConfigs( cl, req->screen, GL_FALSE );
}
int __glXGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_GetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
{
xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *) pc;
return DoGetFBConfigs( cl, req->screen, GL_FALSE );
@ -1290,21 +1279,21 @@ int DoCreateGLXPixmap(__GLXclientState *cl, XID fbconfigId,
return Success;
}
int __glXCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_CreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc;
return DoCreateGLXPixmap( cl, req->visual, req->screen,
req->pixmap, req->glxpixmap );
}
int __glXCreatePixmap(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_CreatePixmap(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
return DoCreateGLXPixmap( cl, req->fbconfig, req->screen,
req->pixmap, req->glxpixmap );
}
int __glXCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_CreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreateGLXPixmapWithConfigSGIXReq *req =
(xGLXCreateGLXPixmapWithConfigSGIXReq *) pc;
@ -1329,21 +1318,21 @@ int DoDestroyPixmap(__GLXclientState *cl, XID glxpixmap)
return Success;
}
int __glXDestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_DestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
{
xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;
return DoDestroyPixmap(cl, req->glxpixmap);
}
int __glXDestroyPixmap(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_DestroyPixmap(__GLXclientState *cl, GLbyte *pc)
{
xGLXDestroyPixmapReq *req = (xGLXDestroyPixmapReq *) pc;
return DoDestroyPixmap(cl, req->glxpixmap);
}
int __glXCreatePbuffer(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_CreatePbuffer(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *) pc;
@ -1352,7 +1341,7 @@ int __glXCreatePbuffer(__GLXclientState *cl, GLbyte *pc)
return BadRequest;
}
int __glXDestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_DestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
{
xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) pc;
@ -1361,7 +1350,7 @@ int __glXDestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
return BadRequest;
}
int __glXChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_ChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
{
xGLXChangeDrawableAttributesReq *req =
(xGLXChangeDrawableAttributesReq *) pc;
@ -1371,7 +1360,7 @@ int __glXChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
return BadRequest;
}
int __glXCreateWindow(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_CreateWindow(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
ClientPtr client = cl->client;
@ -1403,7 +1392,7 @@ int __glXCreateWindow(__GLXclientState *cl, GLbyte *pc)
return Success;
}
int __glXDestroyWindow(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_DestroyWindow(__GLXclientState *cl, GLbyte *pc)
{
xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc;
ClientPtr client = cl->client;
@ -1428,7 +1417,7 @@ int __glXDestroyWindow(__GLXclientState *cl, GLbyte *pc)
** this time that is of value. Consequently, this code must be
** implemented by somebody other than SGI.
*/
int __glXSwapBuffers(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_SwapBuffers(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXSwapBuffersReq *req = (xGLXSwapBuffersReq *) pc;
@ -1518,21 +1507,21 @@ int DoQueryContext(__GLXclientState *cl, GLXContextID gcId)
return Success;
}
int __glXQueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_QueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc)
{
xGLXQueryContextInfoEXTReq *req = (xGLXQueryContextInfoEXTReq *) pc;
return DoQueryContext(cl, req->context);
}
int __glXQueryContext(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_QueryContext(__GLXclientState *cl, GLbyte *pc)
{
xGLXQueryContextReq *req = (xGLXQueryContextReq *) pc;
return DoQueryContext(cl, req->context);
}
int __glXBindTexImageEXT(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_BindTexImageEXT(__GLXclientState *cl, GLbyte *pc)
{
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
ClientPtr client = cl->client;
@ -1568,7 +1557,7 @@ int __glXBindTexImageEXT(__GLXclientState *cl, GLbyte *pc)
pGlxPixmap);
}
int __glXReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_ReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc)
{
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
ClientPtr client = cl->client;
@ -1601,7 +1590,7 @@ int __glXReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc)
pGlxPixmap);
}
int __glXCopySubBufferMESA(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_CopySubBufferMESA(__GLXclientState *cl, GLbyte *pc)
{
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
GLXContextTag tag = req->contextTag;
@ -1701,7 +1690,7 @@ DoGetDrawableAttributes(__GLXclientState *cl, XID drawId)
return Success;
}
int __glXGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_GetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc)
{
xGLXVendorPrivateWithReplyReq *req = (xGLXVendorPrivateWithReplyReq *)pc;
CARD32 *data;
@ -1713,7 +1702,7 @@ int __glXGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc)
return DoGetDrawableAttributes(cl, drawable);
}
int __glXGetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_GetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
{
xGLXGetDrawableAttributesReq *req = (xGLXGetDrawableAttributesReq *)pc;
@ -1727,10 +1716,7 @@ int __glXGetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
** client library to send batches of GL rendering commands.
*/
/*
** Execute all the drawing commands in a request.
*/
int __glXRender(__GLXclientState *cl, GLbyte *pc)
int DoRender(__GLXclientState *cl, GLbyte *pc, int do_swap)
{
xGLXRenderReq *req;
ClientPtr client= cl->client;
@ -1739,14 +1725,15 @@ int __glXRender(__GLXclientState *cl, GLbyte *pc)
CARD16 opcode;
__GLXrenderHeader *hdr;
__GLXcontext *glxc;
__GLX_DECLARE_SWAP_VARIABLES;
/*
** NOTE: much of this code also appears in the byteswapping version of this
** routine, __glXSwapRender(). Any changes made here should also be
** duplicated there.
*/
req = (xGLXRenderReq *) pc;
if (do_swap) {
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->contextTag);
}
glxc = __glXForceCurrent(cl, req->contextTag, &error);
if (!glxc) {
return error;
@ -1756,56 +1743,47 @@ int __glXRender(__GLXclientState *cl, GLbyte *pc)
pc += sz_xGLXRenderReq;
left = (req->length << 2) - sz_xGLXRenderReq;
while (left > 0) {
__GLXrenderSizeData *entry;
__GLXrenderSizeData entry;
int extra;
void (* proc)(GLbyte *);
__GLXdispatchRenderProcPtr proc;
int err;
/*
** Verify that the header length and the overall length agree.
** Also, each command must be word aligned.
*/
hdr = (__GLXrenderHeader *) pc;
if (do_swap) {
__GLX_SWAP_SHORT(&hdr->length);
__GLX_SWAP_SHORT(&hdr->opcode);
}
cmdlen = hdr->length;
opcode = hdr->opcode;
/*
** Check for core opcodes and grab entry data.
*/
if ( (opcode >= __GLX_MIN_RENDER_OPCODE) &&
(opcode <= __GLX_MAX_RENDER_OPCODE) ) {
entry = &__glXRenderSizeTable[opcode];
proc = __glXRenderTable[opcode];
#if __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT
} else if ( (opcode >= __GLX_MIN_RENDER_OPCODE_EXT) &&
(opcode <= __GLX_MAX_RENDER_OPCODE_EXT) ) {
entry =
&__glXRenderSizeTable_EXT[opcode -
__GLX_MIN_RENDER_OPCODE_EXT];
proc = __glXRenderTable_EXT[opcode -
__GLX_MIN_RENDER_OPCODE_EXT];
#endif /* __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT */
} else {
err = __glXGetProtocolSizeData(& Render_dispatch_info, opcode, & entry);
proc = (__GLXdispatchRenderProcPtr)
__glXGetProtocolDecodeFunction(& Render_dispatch_info, opcode, do_swap);
if ((err < 0) || (proc == NULL)) {
client->errorValue = commandsDone;
return __glXError(GLXBadRenderRequest);
}
if (!entry->bytes) {
/* unused opcode */
client->errorValue = commandsDone;
return __glXError(GLXBadRenderRequest);
}
if (entry->varsize) {
if (entry.varsize) {
/* variable size command */
extra = (*entry->varsize)(pc + __GLX_RENDER_HDR_SIZE, False);
extra = (*entry.varsize)(pc + __GLX_RENDER_HDR_SIZE, do_swap);
if (extra < 0) {
extra = 0;
}
if (cmdlen != __GLX_PAD(entry->bytes + extra)) {
if (cmdlen != __GLX_PAD(entry.bytes + extra)) {
return BadLength;
}
} else {
/* constant size command */
if (cmdlen != __GLX_PAD(entry->bytes)) {
if (cmdlen != __GLX_PAD(entry.bytes)) {
return BadLength;
}
}
@ -1830,26 +1808,34 @@ int __glXRender(__GLXclientState *cl, GLbyte *pc)
}
/*
** Execute a large rendering request (one that spans multiple X requests).
** Execute all the drawing commands in a request.
*/
int __glXRenderLarge(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_Render(__GLXclientState *cl, GLbyte *pc)
{
return DoRender(cl, pc, False);
}
int DoRenderLarge(__GLXclientState *cl, GLbyte *pc, int do_swap)
{
xGLXRenderLargeReq *req;
ClientPtr client= cl->client;
GLuint dataBytes;
void (*proc)(GLbyte *);
size_t dataBytes;
__GLXrenderLargeHeader *hdr;
__GLXcontext *glxc;
int error;
CARD16 opcode;
__GLX_DECLARE_SWAP_VARIABLES;
/*
** NOTE: much of this code also appears in the byteswapping version of this
** routine, __glXSwapRenderLarge(). Any changes made here should also be
** duplicated there.
*/
req = (xGLXRenderLargeReq *) pc;
if (do_swap) {
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->contextTag);
__GLX_SWAP_INT(&req->dataBytes);
__GLX_SWAP_SHORT(&req->requestNumber);
__GLX_SWAP_SHORT(&req->requestTotal);
}
glxc = __glXForceCurrent(cl, req->contextTag, &error);
if (!glxc) {
/* Reset in case this isn't 1st request. */
@ -1870,8 +1856,11 @@ int __glXRenderLarge(__GLXclientState *cl, GLbyte *pc)
pc += sz_xGLXRenderLargeReq;
if (cl->largeCmdRequestsSoFar == 0) {
__GLXrenderSizeData *entry;
int extra, cmdlen;
__GLXrenderSizeData entry;
int extra;
size_t cmdlen;
int err;
/*
** This is the first request of a multi request command.
** Make enough space in the buffer, then copy the entire request.
@ -1882,48 +1871,39 @@ int __glXRenderLarge(__GLXclientState *cl, GLbyte *pc)
}
hdr = (__GLXrenderLargeHeader *) pc;
if (do_swap) {
__GLX_SWAP_INT(&hdr->length);
__GLX_SWAP_INT(&hdr->opcode);
}
cmdlen = hdr->length;
opcode = hdr->opcode;
/*
** Check for core opcodes and grab entry data.
*/
if ( (opcode >= __GLX_MIN_RENDER_OPCODE) &&
(opcode <= __GLX_MAX_RENDER_OPCODE) ) {
entry = &__glXRenderSizeTable[opcode];
#if __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT
} else if ( (opcode >= __GLX_MIN_RENDER_OPCODE_EXT) &&
(opcode <= __GLX_MAX_RENDER_OPCODE_EXT) ) {
opcode -= __GLX_MIN_RENDER_OPCODE_EXT;
entry = &__glXRenderSizeTable_EXT[opcode];
#endif /* __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT */
} else {
err = __glXGetProtocolSizeData(& Render_dispatch_info, opcode, & entry);
if (err < 0) {
client->errorValue = opcode;
return __glXError(GLXBadLargeRequest);
}
if (!entry->bytes) {
/* unused opcode */
client->errorValue = opcode;
return __glXError(GLXBadLargeRequest);
}
if (entry->varsize) {
if (entry.varsize) {
/*
** If it's a variable-size command (a command whose length must
** be computed from its parameters), all the parameters needed
** will be in the 1st request, so it's okay to do this.
*/
extra = (*entry->varsize)(pc + __GLX_RENDER_LARGE_HDR_SIZE, False);
extra = (*entry.varsize)(pc + __GLX_RENDER_LARGE_HDR_SIZE, do_swap);
if (extra < 0) {
extra = 0;
}
/* large command's header is 4 bytes longer, so add 4 */
if (cmdlen != __GLX_PAD(entry->bytes + 4 + extra)) {
if (cmdlen != __GLX_PAD(entry.bytes + 4 + extra)) {
return BadLength;
}
} else {
/* constant size command */
if (cmdlen != __GLX_PAD(entry->bytes + 4)) {
if (cmdlen != __GLX_PAD(entry.bytes + 4)) {
return BadLength;
}
}
@ -1932,10 +1912,9 @@ int __glXRenderLarge(__GLXclientState *cl, GLbyte *pc)
*/
if (cl->largeCmdBufSize < cmdlen) {
if (!cl->largeCmdBuf) {
cl->largeCmdBuf = (GLbyte *) xalloc((size_t)cmdlen);
cl->largeCmdBuf = (GLbyte *) xalloc(cmdlen);
} else {
cl->largeCmdBuf = (GLbyte *) xrealloc(cl->largeCmdBuf,
(size_t)cmdlen);
cl->largeCmdBuf = (GLbyte *) xrealloc(cl->largeCmdBuf, cmdlen);
}
if (!cl->largeCmdBuf) {
return BadAlloc;
@ -1983,6 +1962,8 @@ int __glXRenderLarge(__GLXclientState *cl, GLbyte *pc)
cl->largeCmdRequestsSoFar++;
if (req->requestNumber == cl->largeCmdRequestsTotal) {
__GLXdispatchRenderProcPtr proc;
/*
** This is the last request; it must have enough bytes to complete
** the command.
@ -2003,21 +1984,17 @@ int __glXRenderLarge(__GLXclientState *cl, GLbyte *pc)
return __glXError(GLXBadLargeRequest);
}
hdr = (__GLXrenderLargeHeader *) cl->largeCmdBuf;
opcode = hdr->opcode;
/*
** The opcode and length field in the header had already been
** swapped when the first request was received.
**
** Use the opcode to index into the procedure table.
*/
if ( (opcode >= __GLX_MIN_RENDER_OPCODE) &&
(opcode <= __GLX_MAX_RENDER_OPCODE) ) {
proc = __glXRenderTable[opcode];
#if __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT
} else if ( (opcode >= __GLX_MIN_RENDER_OPCODE_EXT) &&
(opcode <= __GLX_MAX_RENDER_OPCODE_EXT) ) {
opcode -= __GLX_MIN_RENDER_OPCODE_EXT;
proc = __glXRenderTable_EXT[opcode];
#endif /* __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT */
} else {
opcode = hdr->opcode;
proc = (__GLXdispatchRenderProcPtr)
__glXGetProtocolDecodeFunction(& Render_dispatch_info, opcode, do_swap);
if (proc == NULL) {
client->errorValue = opcode;
return __glXError(GLXBadLargeRequest);
}
@ -2041,9 +2018,17 @@ int __glXRenderLarge(__GLXclientState *cl, GLbyte *pc)
}
}
/*
** Execute a large rendering request (one that spans multiple X requests).
*/
int __glXDisp_RenderLarge(__GLXclientState *cl, GLbyte *pc)
{
return DoRenderLarge(cl, pc, False);
}
extern RESTYPE __glXSwapBarrierRes;
static int __glXBindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_BindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXBindSwapBarrierSGIXReq *req = (xGLXBindSwapBarrierSGIXReq *) pc;
@ -2073,7 +2058,7 @@ static int __glXBindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc)
}
static int __glXQueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_QueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXQueryMaxSwapBarriersSGIXReq *req =
@ -2104,7 +2089,7 @@ static int __glXQueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc)
#define GLX_BAD_HYPERPIPE_SGIX 92
static int __glxQueryHyperpipeNetworkSGIX(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_QueryHyperpipeNetworkSGIX(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXQueryHyperpipeNetworkSGIXReq * req = (xGLXQueryHyperpipeNetworkSGIXReq *) pc;
@ -2144,7 +2129,7 @@ static int __glxQueryHyperpipeNetworkSGIX(__GLXclientState *cl, GLbyte *pc)
return Success;
}
static int __glxDestroyHyperpipeConfigSGIX (__GLXclientState *cl, GLbyte *pc)
int __glXDisp_DestroyHyperpipeConfigSGIX (__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXDestroyHyperpipeConfigSGIXReq * req =
@ -2179,7 +2164,7 @@ static int __glxDestroyHyperpipeConfigSGIX (__GLXclientState *cl, GLbyte *pc)
return Success;
}
static int __glxQueryHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_QueryHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXQueryHyperpipeConfigSGIXReq * req =
@ -2223,7 +2208,7 @@ static int __glxQueryHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc)
return Success;
}
static int __glxHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_HyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXHyperpipeConfigSGIXReq * req =
@ -2274,108 +2259,44 @@ static int __glxHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc)
** allocating the entry points in the dispatch table.
*/
int __glXVendorPrivate(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_VendorPrivate(__GLXclientState *cl, GLbyte *pc)
{
xGLXVendorPrivateReq *req;
GLint vendorcode;
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
GLint vendorcode = req->vendorCode;
__GLXdispatchVendorPrivProcPtr proc;
req = (xGLXVendorPrivateReq *) pc;
vendorcode = req->vendorCode;
#ifndef __DARWIN__
switch( vendorcode ) {
case X_GLvop_SampleMaskSGIS:
CALL_SampleMaskSGIS( GET_DISPATCH(),
(*(GLfloat *)(pc + 4), *(GLboolean *)(pc + 8)) );
return Success;
case X_GLvop_SamplePatternSGIS:
CALL_SamplePatternSGIS( GET_DISPATCH(), (*(GLenum *)(pc + 4)) );
return Success;
case X_GLXvop_BindSwapBarrierSGIX:
return __glXBindSwapBarrierSGIX(cl, pc);
case X_GLXvop_BindTexImageEXT:
return __glXBindTexImageEXT(cl, pc);
case X_GLXvop_ReleaseTexImageEXT:
return __glXReleaseTexImageEXT(cl, pc);
case X_GLXvop_CopySubBufferMESA:
return __glXCopySubBufferMESA(cl, pc);
}
#endif
if ((vendorcode >= __GLX_MIN_VENDPRIV_OPCODE_EXT) &&
(vendorcode <= __GLX_MAX_VENDPRIV_OPCODE_EXT)) {
(*__glXVendorPrivTable_EXT[vendorcode-__GLX_MIN_VENDPRIV_OPCODE_EXT])
(cl, (GLbyte*)req);
proc = (__GLXdispatchVendorPrivProcPtr)
__glXGetProtocolDecodeFunction(& VendorPriv_dispatch_info,
vendorcode, 0);
if (proc != NULL) {
(*proc)(cl, (GLbyte*)req);
return Success;
}
/*
** This sample implemention does not support any private requests.
*/
cl->client->errorValue = req->vendorCode;
return __glXError(GLXUnsupportedPrivateRequest);
}
int __glXVendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_VendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
{
xGLXVendorPrivateWithReplyReq *req;
GLint vendorcode;
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
GLint vendorcode = req->vendorCode;
__GLXdispatchVendorPrivProcPtr proc;
req = (xGLXVendorPrivateWithReplyReq *) pc;
vendorcode = req->vendorCode;
switch (vendorcode) {
case X_GLXvop_QueryContextInfoEXT:
return __glXQueryContextInfoEXT(cl, pc);
case X_GLXvop_MakeCurrentReadSGI:
return __glXMakeCurrentReadSGI(cl, pc);
case X_GLXvop_QueryMaxSwapBarriersSGIX:
return __glXQueryMaxSwapBarriersSGIX(cl, pc);
case X_GLXvop_QueryHyperpipeNetworkSGIX:
return __glxQueryHyperpipeNetworkSGIX(cl, pc);
case X_GLXvop_QueryHyperpipeConfigSGIX:
return __glxQueryHyperpipeConfigSGIX(cl, pc);
case X_GLXvop_DestroyHyperpipeConfigSGIX:
return __glxDestroyHyperpipeConfigSGIX(cl, pc);
case X_GLXvop_HyperpipeConfigSGIX:
return __glxHyperpipeConfigSGIX(cl, pc);
case X_GLXvop_GetFBConfigsSGIX:
return __glXGetFBConfigsSGIX(cl, pc);
case X_GLXvop_CreateContextWithConfigSGIX:
return __glXCreateContextWithConfigSGIX(cl, pc);
case X_GLXvop_CreateGLXPixmapWithConfigSGIX:
return __glXCreateGLXPixmapWithConfigSGIX(cl, pc);
case X_GLXvop_GetDrawableAttributesSGIX:
return __glXGetDrawableAttributesSGIX(cl, pc);
case X_GLvop_IsRenderbufferEXT:
return __glXDisp_IsRenderbufferEXT(cl, pc);
case X_GLvop_GenRenderbuffersEXT:
return __glXDisp_GenRenderbuffersEXT(cl, pc);
case X_GLvop_GetRenderbufferParameterivEXT:
return __glXDisp_GetRenderbufferParameterivEXT(cl, pc);
case X_GLvop_IsFramebufferEXT:
return __glXDisp_IsFramebufferEXT(cl, pc);
case X_GLvop_GenFramebuffersEXT:
return __glXDisp_GenFramebuffersEXT(cl, pc);
case X_GLvop_CheckFramebufferStatusEXT:
return __glXDisp_CheckFramebufferStatusEXT(cl, pc);
case X_GLvop_GetFramebufferAttachmentParameterivEXT:
return __glXDisp_GetFramebufferAttachmentParameterivEXT(cl, pc);
default:
break;
}
if ((vendorcode >= __GLX_MIN_VENDPRIV_OPCODE_EXT) &&
(vendorcode <= __GLX_MAX_VENDPRIV_OPCODE_EXT)) {
return
(*__glXVendorPrivTable_EXT[vendorcode-__GLX_MIN_VENDPRIV_OPCODE_EXT])
(cl, (GLbyte*)req);
proc = (__GLXdispatchVendorPrivProcPtr)
__glXGetProtocolDecodeFunction(& VendorPriv_dispatch_info,
vendorcode, 0);
if (proc != NULL) {
return (*proc)(cl, (GLbyte*)req);
}
cl->client->errorValue = vendorcode;
return __glXError(GLXUnsupportedPrivateRequest);
}
int __glXQueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_QueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXQueryExtensionsStringReq *req = (xGLXQueryExtensionsStringReq *) pc;
@ -2420,7 +2341,7 @@ int __glXQueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
return Success;
}
int __glXQueryServerString(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_QueryServerString(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *) pc;
@ -2478,7 +2399,7 @@ int __glXQueryServerString(__GLXclientState *cl, GLbyte *pc)
return Success;
}
int __glXClientInfo(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_ClientInfo(__GLXclientState *cl, GLbyte *pc)
{
xGLXClientInfoReq *req = (xGLXClientInfoReq *) pc;
const char *buf;
@ -2492,4 +2413,3 @@ int __glXClientInfo(__GLXclientState *cl, GLbyte *pc)
return Success;
}

514
GL/glx/glxcmdsswap.c
View File

@ -44,8 +44,7 @@
#include "glxutil.h"
#include <GL/glxtokens.h>
#include <unpack.h>
#include <g_disptab.h>
#include <g_disptab_EXT.h>
#include "g_disptab.h"
#include <pixmapstr.h>
#include <windowstr.h>
#include "glxext.h"
@ -54,11 +53,9 @@
#include "glthread.h"
#include "dispatch.h"
#include "indirect_dispatch.h"
#include "indirect_table.h"
#include "indirect_util.h"
static int __glXSwapGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc);
static int __glXSwapCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc);
static int __glXSwapCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc);
static int __glXSwapMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc);
/************************************************************************/
@ -69,7 +66,7 @@ static int __glXSwapMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc);
** it is called at the end of the unswapped routine.
*/
int __glXSwapCreateContext(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_CreateContext(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -84,7 +81,7 @@ int __glXSwapCreateContext(__GLXclientState *cl, GLbyte *pc)
req->screen, req->isDirect );
}
int __glXSwapCreateNewContext(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_CreateNewContext(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreateNewContextReq *req = (xGLXCreateNewContextReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -100,7 +97,7 @@ int __glXSwapCreateNewContext(__GLXclientState *cl, GLbyte *pc)
req->screen, req->isDirect );
}
int __glXSwapCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_CreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreateContextWithConfigSGIXReq *req =
(xGLXCreateContextWithConfigSGIXReq *) pc;
@ -117,7 +114,7 @@ int __glXSwapCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
req->screen, req->isDirect );
}
int __glXSwapDestroyContext(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_DestroyContext(__GLXclientState *cl, GLbyte *pc)
{
xGLXDestroyContextReq *req = (xGLXDestroyContextReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -125,10 +122,10 @@ int __glXSwapDestroyContext(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->context);
return __glXDestroyContext(cl, pc);
return __glXDisp_DestroyContext(cl, pc);
}
int __glXSwapMakeCurrent(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_MakeCurrent(__GLXclientState *cl, GLbyte *pc)
{
xGLXMakeCurrentReq *req = (xGLXMakeCurrentReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -142,7 +139,7 @@ int __glXSwapMakeCurrent(__GLXclientState *cl, GLbyte *pc)
req->context, req->oldContextTag );
}
int __glXSwapMakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_MakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
{
xGLXMakeContextCurrentReq *req = (xGLXMakeContextCurrentReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -157,7 +154,7 @@ int __glXSwapMakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
req->context, req->oldContextTag );
}
int __glXSwapMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_MakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
{
xGLXMakeCurrentReadSGIReq *req = (xGLXMakeCurrentReadSGIReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -172,7 +169,7 @@ int __glXSwapMakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
req->context, req->oldContextTag );
}
int __glXSwapIsDirect(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_IsDirect(__GLXclientState *cl, GLbyte *pc)
{
xGLXIsDirectReq *req = (xGLXIsDirectReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -180,10 +177,10 @@ int __glXSwapIsDirect(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->context);
return __glXIsDirect(cl, pc);
return __glXDisp_IsDirect(cl, pc);
}
int __glXSwapQueryVersion(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_QueryVersion(__GLXclientState *cl, GLbyte *pc)
{
xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -192,10 +189,10 @@ int __glXSwapQueryVersion(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_INT(&req->majorVersion);
__GLX_SWAP_INT(&req->minorVersion);
return __glXQueryVersion(cl, pc);
return __glXDisp_QueryVersion(cl, pc);
}
int __glXSwapWaitGL(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_WaitGL(__GLXclientState *cl, GLbyte *pc)
{
xGLXWaitGLReq *req = (xGLXWaitGLReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -203,10 +200,10 @@ int __glXSwapWaitGL(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->contextTag);
return __glXWaitGL(cl, pc);
return __glXDisp_WaitGL(cl, pc);
}
int __glXSwapWaitX(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_WaitX(__GLXclientState *cl, GLbyte *pc)
{
xGLXWaitXReq *req = (xGLXWaitXReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -214,10 +211,10 @@ int __glXSwapWaitX(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->contextTag);
return __glXWaitX(cl, pc);
return __glXDisp_WaitX(cl, pc);
}
int __glXSwapCopyContext(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_CopyContext(__GLXclientState *cl, GLbyte *pc)
{
xGLXCopyContextReq *req = (xGLXCopyContextReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -227,10 +224,10 @@ int __glXSwapCopyContext(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_INT(&req->dest);
__GLX_SWAP_INT(&req->mask);
return __glXCopyContext(cl, pc);
return __glXDisp_CopyContext(cl, pc);
}
int __glXSwapGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_GetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
{
xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -239,7 +236,7 @@ int __glXSwapGetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
return DoGetVisualConfigs( cl, req->screen, GL_TRUE );
}
int __glXSwapGetFBConfigs(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_GetFBConfigs(__GLXclientState *cl, GLbyte *pc)
{
xGLXGetFBConfigsReq *req = (xGLXGetFBConfigsReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -248,7 +245,7 @@ int __glXSwapGetFBConfigs(__GLXclientState *cl, GLbyte *pc)
return DoGetFBConfigs( cl, req->screen, GL_TRUE );
}
int __glXSwapGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_GetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
{
xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -257,7 +254,7 @@ int __glXSwapGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
return DoGetFBConfigs( cl, req->screen, GL_TRUE );
}
int __glXSwapCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_CreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -272,7 +269,7 @@ int __glXSwapCreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
req->pixmap, req->glxpixmap );
}
int __glXSwapCreatePixmap(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_CreatePixmap(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -287,7 +284,7 @@ int __glXSwapCreatePixmap(__GLXclientState *cl, GLbyte *pc)
req->pixmap, req->glxpixmap );
}
int __glXSwapCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_CreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreateGLXPixmapWithConfigSGIXReq *req =
(xGLXCreateGLXPixmapWithConfigSGIXReq *) pc;
@ -303,7 +300,7 @@ int __glXSwapCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
req->pixmap, req->glxpixmap );
}
int __glXSwapDestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_DestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
{
xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -311,10 +308,10 @@ int __glXSwapDestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->glxpixmap);
return __glXDestroyGLXPixmap(cl, pc);
return __glXDisp_DestroyGLXPixmap(cl, pc);
}
int __glXSwapDestroyPixmap(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_DestroyPixmap(__GLXclientState *cl, GLbyte *pc)
{
xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -322,10 +319,10 @@ int __glXSwapDestroyPixmap(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->glxpixmap);
return __glXDestroyGLXPixmap(cl, pc);
return __glXDisp_DestroyGLXPixmap(cl, pc);
}
int __glXSwapQueryContext(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_QueryContext(__GLXclientState *cl, GLbyte *pc)
{
xGLXQueryContextReq *req = (xGLXQueryContextReq *) pc;
@ -334,7 +331,7 @@ int __glXSwapQueryContext(__GLXclientState *cl, GLbyte *pc)
return BadRequest;
}
int __glXSwapCreatePbuffer(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_CreatePbuffer(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *) pc;
@ -343,14 +340,14 @@ int __glXSwapCreatePbuffer(__GLXclientState *cl, GLbyte *pc)
return BadRequest;
}
int __glXSwapDestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_DestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
{
xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) req;
return BadRequest;
}
int __glXSwapChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_ChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
{
xGLXChangeDrawableAttributesReq *req =
(xGLXChangeDrawableAttributesReq *) req;
@ -358,7 +355,7 @@ int __glXSwapChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
return BadRequest;
}
int __glXSwapCreateWindow(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_CreateWindow(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
@ -367,7 +364,7 @@ int __glXSwapCreateWindow(__GLXclientState *cl, GLbyte *pc)
return BadRequest;
}
int __glXSwapDestroyWindow(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_DestroyWindow(__GLXclientState *cl, GLbyte *pc)
{
xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc;
@ -376,7 +373,7 @@ int __glXSwapDestroyWindow(__GLXclientState *cl, GLbyte *pc)
return BadRequest;
}
int __glXSwapSwapBuffers(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_SwapBuffers(__GLXclientState *cl, GLbyte *pc)
{
xGLXSwapBuffersReq *req = (xGLXSwapBuffersReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -385,10 +382,10 @@ int __glXSwapSwapBuffers(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_INT(&req->contextTag);
__GLX_SWAP_INT(&req->drawable);
return __glXSwapBuffers(cl, pc);
return __glXDisp_SwapBuffers(cl, pc);
}
int __glXSwapUseXFont(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_UseXFont(__GLXclientState *cl, GLbyte *pc)
{
xGLXUseXFontReq *req = (xGLXUseXFontReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -400,11 +397,11 @@ int __glXSwapUseXFont(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_INT(&req->count);
__GLX_SWAP_INT(&req->listBase);
return __glXUseXFont(cl, pc);
return __glXDisp_UseXFont(cl, pc);
}
int __glXSwapQueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_QueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
{
xGLXQueryExtensionsStringReq *req = (xGLXQueryExtensionsStringReq *)pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -412,10 +409,10 @@ int __glXSwapQueryExtensionsString(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->screen);
return __glXQueryExtensionsString(cl, pc);
return __glXDisp_QueryExtensionsString(cl, pc);
}
int __glXSwapQueryServerString(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_QueryServerString(__GLXclientState *cl, GLbyte *pc)
{
xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *)pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -424,10 +421,10 @@ int __glXSwapQueryServerString(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_INT(&req->screen);
__GLX_SWAP_INT(&req->name);
return __glXQueryServerString(cl, pc);
return __glXDisp_QueryServerString(cl, pc);
}
int __glXSwapClientInfo(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_ClientInfo(__GLXclientState *cl, GLbyte *pc)
{
xGLXClientInfoReq *req = (xGLXClientInfoReq *)pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -437,10 +434,10 @@ int __glXSwapClientInfo(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_INT(&req->minor);
__GLX_SWAP_INT(&req->numbytes);
return __glXClientInfo(cl, pc);
return __glXDisp_ClientInfo(cl, pc);
}
int __glXSwapQueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_QueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc)
{
xGLXQueryContextInfoEXTReq *req = (xGLXQueryContextInfoEXTReq *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -448,10 +445,10 @@ int __glXSwapQueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->context);
return __glXQueryContextInfoEXT(cl, pc);
return __glXDisp_QueryContextInfoEXT(cl, pc);
}
int __glXSwapBindTexImageEXT(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_BindTexImageEXT(__GLXclientState *cl, GLbyte *pc)
{
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
GLXDrawable *drawId;
@ -469,10 +466,10 @@ int __glXSwapBindTexImageEXT(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_INT(drawId);
__GLX_SWAP_INT(buffer);
return __glXBindTexImageEXT(cl, (GLbyte *)pc);
return __glXDisp_BindTexImageEXT(cl, (GLbyte *)pc);
}
int __glXSwapReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_ReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc)
{
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
GLXDrawable *drawId;
@ -490,10 +487,10 @@ int __glXSwapReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_INT(drawId);
__GLX_SWAP_INT(buffer);
return __glXReleaseTexImageEXT(cl, (GLbyte *)pc);
return __glXDisp_ReleaseTexImageEXT(cl, (GLbyte *)pc);
}
int __glXSwapCopySubBufferMESA(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_CopySubBufferMESA(__GLXclientState *cl, GLbyte *pc)
{
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
GLXDrawable *drawId;
@ -514,11 +511,11 @@ int __glXSwapCopySubBufferMESA(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_INT(pc + 12);
__GLX_SWAP_INT(pc + 16);
return __glXCopySubBufferMESA(cl, pc);
return __glXDisp_CopySubBufferMESA(cl, pc);
}
int __glXSwapGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_GetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc)
{
xGLXVendorPrivateWithReplyReq *req = (xGLXVendorPrivateWithReplyReq *)pc;
CARD32 *data;
@ -530,10 +527,10 @@ int __glXSwapGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_INT(&req->contextTag);
__GLX_SWAP_INT(data);
return __glXGetDrawableAttributesSGIX(cl, pc);
return __glXDisp_GetDrawableAttributesSGIX(cl, pc);
}
int __glXSwapGetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_GetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
{
xGLXGetDrawableAttributesReq *req = (xGLXGetDrawableAttributesReq *)pc;
@ -542,7 +539,7 @@ int __glXSwapGetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->drawable);
return __glXGetDrawableAttributes(cl, pc);
return __glXDisp_GetDrawableAttributes(cl, pc);
}
@ -641,325 +638,17 @@ void __glXSwapGetDrawableAttributesReply(ClientPtr client,
** client library to send batches of GL rendering commands.
*/
int __glXSwapRender(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_Render(__GLXclientState *cl, GLbyte *pc)
{
xGLXRenderReq *req;
ClientPtr client= cl->client;
int left, cmdlen, error;
int commandsDone;
CARD16 opcode;
__GLXrenderHeader *hdr;
__GLXcontext *cx;
__GLX_DECLARE_SWAP_VARIABLES;
/*
** NOTE: much of this code also appears in the nonswapping version of this
** routine, __glXRender(). Any changes made here should also be
** duplicated there.
*/
req = (xGLXRenderReq *) pc;
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->contextTag);
cx = __glXForceCurrent(cl, req->contextTag, &error);
if (!cx) {
return error;
}
commandsDone = 0;
pc += sz_xGLXRenderReq;
left = (req->length << 2) - sz_xGLXRenderReq;
while (left > 0) {
__GLXrenderSizeData *entry;
int extra;
void (* proc)(GLbyte *);
/*
** Verify that the header length and the overall length agree.
** Also, each command must be word aligned.
*/
hdr = (__GLXrenderHeader *) pc;
__GLX_SWAP_SHORT(&hdr->length);
__GLX_SWAP_SHORT(&hdr->opcode);
cmdlen = hdr->length;
opcode = hdr->opcode;
if ( (opcode >= __GLX_MIN_RENDER_OPCODE) &&
(opcode <= __GLX_MAX_RENDER_OPCODE) ) {
entry = &__glXRenderSizeTable[opcode];
proc = __glXSwapRenderTable[opcode];
#if __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT
} else if ( (opcode >= __GLX_MIN_RENDER_OPCODE_EXT) &&
(opcode <= __GLX_MAX_RENDER_OPCODE_EXT) ) {
int index = opcode - __GLX_MIN_RENDER_OPCODE_EXT;
entry = &__glXRenderSizeTable_EXT[index];
proc = __glXSwapRenderTable_EXT[index];
#endif /* __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT */
} else {
client->errorValue = commandsDone;
return __glXError(GLXBadRenderRequest);
}
if (!entry->bytes) {
/* unused opcode */
client->errorValue = commandsDone;
return __glXError(GLXBadRenderRequest);
}
if (entry->varsize) {
/* variable size command */
extra = (*entry->varsize)(pc + __GLX_RENDER_HDR_SIZE, True);
if (extra < 0) {
extra = 0;
}
if (cmdlen != __GLX_PAD(entry->bytes + extra)) {
return BadLength;
}
} else {
/* constant size command */
if (cmdlen != __GLX_PAD(entry->bytes)) {
return BadLength;
}
}
if (left < cmdlen) {
return BadLength;
}
/*
** Skip over the header and execute the command. We allow the
** caller to trash the command memory. This is useful especially
** for things that require double alignment - they can just shift
** the data towards lower memory (trashing the header) by 4 bytes
** and achieve the required alignment.
*/
(*proc)(pc + __GLX_RENDER_HDR_SIZE);
pc += cmdlen;
left -= cmdlen;
commandsDone++;
}
__GLX_NOTE_UNFLUSHED_CMDS(cx);
return Success;
return DoRender(cl, pc, True);
}
/*
** Execute a large rendering request (one that spans multiple X requests).
*/
int __glXSwapRenderLarge(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_RenderLarge(__GLXclientState *cl, GLbyte *pc)
{
xGLXRenderLargeReq *req;
ClientPtr client= cl->client;
size_t dataBytes;
void (*proc)(GLbyte *);
__GLXrenderLargeHeader *hdr;
__GLXcontext *cx;
int error;
CARD16 opcode;
__GLX_DECLARE_SWAP_VARIABLES;
/*
** NOTE: much of this code also appears in the nonswapping version of this
** routine, __glXRenderLarge(). Any changes made here should also be
** duplicated there.
*/
req = (xGLXRenderLargeReq *) pc;
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->contextTag);
__GLX_SWAP_INT(&req->dataBytes);
__GLX_SWAP_SHORT(&req->requestNumber);
__GLX_SWAP_SHORT(&req->requestTotal);
cx = __glXForceCurrent(cl, req->contextTag, &error);
if (!cx) {
/* Reset in case this isn't 1st request. */
__glXResetLargeCommandStatus(cl);
return error;
}
dataBytes = req->dataBytes;
/*
** Check the request length.
*/
if ((req->length << 2) != __GLX_PAD(dataBytes) + sz_xGLXRenderLargeReq) {
client->errorValue = req->length;
/* Reset in case this isn't 1st request. */
__glXResetLargeCommandStatus(cl);
return BadLength;
}
pc += sz_xGLXRenderLargeReq;
if (cl->largeCmdRequestsSoFar == 0) {
__GLXrenderSizeData *entry;
int extra;
size_t cmdlen;
/*
** This is the first request of a multi request command.
** Make enough space in the buffer, then copy the entire request.
*/
if (req->requestNumber != 1) {
client->errorValue = req->requestNumber;
return __glXError(GLXBadLargeRequest);
}
hdr = (__GLXrenderLargeHeader *) pc;
__GLX_SWAP_INT(&hdr->length);
__GLX_SWAP_INT(&hdr->opcode);
cmdlen = hdr->length;
opcode = hdr->opcode;
if ( (opcode >= __GLX_MIN_RENDER_OPCODE) &&
(opcode <= __GLX_MAX_RENDER_OPCODE) ) {
entry = &__glXRenderSizeTable[opcode];
proc = __glXSwapRenderTable[opcode];
#if __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT
} else if ( (opcode >= __GLX_MIN_RENDER_OPCODE_EXT) &&
(opcode <= __GLX_MAX_RENDER_OPCODE_EXT) ) {
int index = opcode - __GLX_MIN_RENDER_OPCODE_EXT;
entry = &__glXRenderSizeTable_EXT[index];
proc = __glXSwapRenderTable_EXT[index];
#endif /* __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT */
} else {
client->errorValue = opcode;
return __glXError(GLXBadLargeRequest);
}
if (!entry->bytes) {
/* unused opcode */
client->errorValue = opcode;
return __glXError(GLXBadLargeRequest);
}
if (entry->varsize) {
/*
** If it's a variable-size command (a command whose length must
** be computed from its parameters), all the parameters needed
** will be in the 1st request, so it's okay to do this.
*/
extra = (*entry->varsize)(pc + __GLX_RENDER_LARGE_HDR_SIZE, True);
if (extra < 0) {
extra = 0;
}
/* large command's header is 4 bytes longer, so add 4 */
if (cmdlen != __GLX_PAD(entry->bytes + 4 + extra)) {
return BadLength;
}
} else {
/* constant size command */
if (cmdlen != __GLX_PAD(entry->bytes + 4)) {
return BadLength;
}
}
/*
** Make enough space in the buffer, then copy the entire request.
*/
if (cl->largeCmdBufSize < cmdlen) {
if (!cl->largeCmdBuf) {
cl->largeCmdBuf = (GLbyte *) xalloc(cmdlen);
} else {
cl->largeCmdBuf = (GLbyte *) xrealloc(cl->largeCmdBuf, cmdlen);
}
if (!cl->largeCmdBuf) {
return BadAlloc;
}
cl->largeCmdBufSize = cmdlen;
}
memcpy(cl->largeCmdBuf, pc, dataBytes);
cl->largeCmdBytesSoFar = dataBytes;
cl->largeCmdBytesTotal = cmdlen;
cl->largeCmdRequestsSoFar = 1;
cl->largeCmdRequestsTotal = req->requestTotal;
return Success;
} else {
/*
** We are receiving subsequent (i.e. not the first) requests of a
** multi request command.
*/
/*
** Check the request number and the total request count.
*/
if (req->requestNumber != cl->largeCmdRequestsSoFar + 1) {
client->errorValue = req->requestNumber;
__glXResetLargeCommandStatus(cl);
return __glXError(GLXBadLargeRequest);
}
if (req->requestTotal != cl->largeCmdRequestsTotal) {
client->errorValue = req->requestTotal;
__glXResetLargeCommandStatus(cl);
return __glXError(GLXBadLargeRequest);
}
/*
** Check that we didn't get too much data.
*/
if ((cl->largeCmdBytesSoFar + dataBytes) > cl->largeCmdBytesTotal) {
client->errorValue = dataBytes;
__glXResetLargeCommandStatus(cl);
return __glXError(GLXBadLargeRequest);
}
memcpy(cl->largeCmdBuf + cl->largeCmdBytesSoFar, pc, dataBytes);
cl->largeCmdBytesSoFar += dataBytes;
cl->largeCmdRequestsSoFar++;
if (req->requestNumber == cl->largeCmdRequestsTotal) {
/*
** This is the last request; it must have enough bytes to complete
** the command.
*/
/* NOTE: the two pad macros have been added below; they are needed
** because the client library pads the total byte count, but not
** the per-request byte counts. The Protocol Encoding says the
** total byte count should not be padded, so a proposal will be
** made to the ARB to relax the padding constraint on the total
** byte count, thus preserving backward compatibility. Meanwhile,
** the padding done below fixes a bug that did not allow
** large commands of odd sizes to be accepted by the server.
*/
if (__GLX_PAD(cl->largeCmdBytesSoFar) !=
__GLX_PAD(cl->largeCmdBytesTotal)) {
client->errorValue = dataBytes;
__glXResetLargeCommandStatus(cl);
return __glXError(GLXBadLargeRequest);
}
hdr = (__GLXrenderLargeHeader *) cl->largeCmdBuf;
/*
** The opcode and length field in the header had already been
** swapped when the first request was received.
*/
/*
** Use the opcode to index into the procedure table.
*/
opcode = hdr->opcode;
if ( (opcode >= __GLX_MIN_RENDER_OPCODE) &&
(opcode <= __GLX_MAX_RENDER_OPCODE) ) {
proc = __glXSwapRenderTable[opcode];
#if __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT
} else if ( (opcode >= __GLX_MIN_RENDER_OPCODE_EXT) &&
(opcode <= __GLX_MAX_RENDER_OPCODE_EXT) ) {
int index = opcode - __GLX_MIN_RENDER_OPCODE_EXT;
proc = __glXSwapRenderTable_EXT[index];
#endif /* __GLX_MAX_RENDER_OPCODE_EXT > __GLX_MIN_RENDER_OPCODE_EXT */
} else {
client->errorValue = opcode;
return __glXError(GLXBadLargeRequest);
}
/*
** Skip over the header and execute the command.
*/
(*proc)(cl->largeCmdBuf + __GLX_RENDER_LARGE_HDR_SIZE);
__GLX_NOTE_UNFLUSHED_CMDS(cx);
/*
** Reset for the next RenderLarge series.
*/
__glXResetLargeCommandStatus(cl);
} else {
/*
** This is neither the first nor the last request.
*/
}
return Success;
}
return DoRenderLarge(cl, pc, True);
}
/************************************************************************/
@ -969,10 +658,11 @@ int __glXSwapRenderLarge(__GLXclientState *cl, GLbyte *pc)
** allocating these entry points in the dispatch table.
*/
int __glXSwapVendorPrivate(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_VendorPrivate(__GLXclientState *cl, GLbyte *pc)
{
xGLXVendorPrivateReq *req;
GLint vendorcode;
__GLXdispatchVendorPrivProcPtr proc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -982,41 +672,24 @@ int __glXSwapVendorPrivate(__GLXclientState *cl, GLbyte *pc)
vendorcode = req->vendorCode;
#ifndef __DARWIN__
switch( vendorcode ) {
case X_GLvop_SampleMaskSGIS:
__GLX_SWAP_FLOAT(pc + 4);
__GLX_SWAP_INT(pc + 8);
CALL_SampleMaskSGIS( GET_DISPATCH(),
(*(GLfloat *)(pc + 4), *(GLboolean *)(pc + 8)) );
return Success;
case X_GLvop_SamplePatternSGIS:
__GLX_SWAP_INT(pc + 4);
CALL_SamplePatternSGIS( GET_DISPATCH(), (*(GLenum *)(pc + 4)) );
return Success;
case X_GLXvop_BindTexImageEXT:
return __glXSwapBindTexImageEXT(cl, pc);
case X_GLXvop_ReleaseTexImageEXT:
return __glXSwapReleaseTexImageEXT(cl, pc);
case X_GLXvop_CopySubBufferMESA:
return __glXSwapCopySubBufferMESA(cl, pc);
}
#endif
if ((vendorcode >= __GLX_MIN_VENDPRIV_OPCODE_EXT) &&
(vendorcode <= __GLX_MAX_VENDPRIV_OPCODE_EXT)) {
(*__glXSwapVendorPrivTable_EXT[vendorcode-__GLX_MIN_VENDPRIV_OPCODE_EXT])(cl, (GLbyte*)req);
proc = (__GLXdispatchVendorPrivProcPtr)
__glXGetProtocolDecodeFunction(& VendorPriv_dispatch_info,
vendorcode, 1);
if (proc != NULL) {
(*proc)(cl, (GLbyte*)req);
return Success;
}
cl->client->errorValue = req->vendorCode;
return __glXError(GLXUnsupportedPrivateRequest);
}
int __glXSwapVendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
int __glXDispSwap_VendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
{
xGLXVendorPrivateWithReplyReq *req;
GLint vendorcode;
__GLXdispatchVendorPrivProcPtr proc;
__GLX_DECLARE_SWAP_VARIABLES;
@ -1026,42 +699,13 @@ int __glXSwapVendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc)
vendorcode = req->vendorCode;
switch (vendorcode) {
case X_GLXvop_QueryContextInfoEXT:
return __glXSwapQueryContextInfoEXT(cl, pc);
case X_GLXvop_MakeCurrentReadSGI:
return __glXSwapMakeCurrentReadSGI(cl, pc);
case X_GLXvop_GetFBConfigsSGIX:
return __glXSwapGetFBConfigsSGIX(cl, pc);
case X_GLXvop_CreateContextWithConfigSGIX:
return __glXSwapCreateContextWithConfigSGIX(cl, pc);
case X_GLXvop_CreateGLXPixmapWithConfigSGIX:
return __glXSwapCreateGLXPixmapWithConfigSGIX(cl, pc);
case X_GLXvop_GetDrawableAttributesSGIX:
return __glXSwapGetDrawableAttributesSGIX(cl, pc);
case X_GLvop_IsRenderbufferEXT:
return __glXDispSwap_IsRenderbufferEXT(cl, pc);
case X_GLvop_GenRenderbuffersEXT:
return __glXDispSwap_GenRenderbuffersEXT(cl, pc);
case X_GLvop_GetRenderbufferParameterivEXT:
return __glXDispSwap_GetRenderbufferParameterivEXT(cl, pc);
case X_GLvop_IsFramebufferEXT:
return __glXDispSwap_IsFramebufferEXT(cl, pc);
case X_GLvop_GenFramebuffersEXT:
return __glXDispSwap_GenFramebuffersEXT(cl, pc);
case X_GLvop_CheckFramebufferStatusEXT:
return __glXDispSwap_CheckFramebufferStatusEXT(cl, pc);
case X_GLvop_GetFramebufferAttachmentParameterivEXT:
return __glXDispSwap_GetFramebufferAttachmentParameterivEXT(cl, pc);
default:
break;
proc = (__GLXdispatchVendorPrivProcPtr)
__glXGetProtocolDecodeFunction(& VendorPriv_dispatch_info,
vendorcode, 1);
if (proc != NULL) {
return (*proc)(cl, (GLbyte*)req);
}
if ((vendorcode >= __GLX_MIN_VENDPRIV_OPCODE_EXT) &&
(vendorcode <= __GLX_MAX_VENDPRIV_OPCODE_EXT)) {
return (*__glXSwapVendorPrivTable_EXT[vendorcode-__GLX_MIN_VENDPRIV_OPCODE_EXT])(cl, (GLbyte*)req);
}
cl->client->errorValue = req->vendorCode;
return __glXError(GLXUnsupportedPrivateRequest);
}

84
GL/glx/glxdri.c
View File

@ -53,11 +53,11 @@
#include "glcontextmodes.h"
#include "g_disptab.h"
#include "g_disptab_EXT.h"
#include "glapitable.h"
#include "glapi.h"
#include "glthread.h"
#include "dispatch.h"
#include "extension_string.h"
#define STRINGIFY(macro_or_string) STRINGIFY_ARG (macro_or_string)
@ -72,6 +72,8 @@ struct __GLXDRIscreen {
__DRIscreen driScreen;
void *driver;
unsigned char glx_enable_bits[__GLX_EXT_BYTES];
};
struct __GLXDRIcontext {
@ -146,6 +148,22 @@ __glXDRIenterServer(void)
DRIWakeupHandler(NULL, 0, NULL);
}
/**
* \bug
* We're jumping through hoops here to get the DRIdrawable which the DRI
* driver tries to keep to it self... cf. FIXME in \c createDrawable.
*/
static void
__glXDRIdrawableFoo(__GLXDRIdrawable *draw)
{
__GLXDRIscreen * const screen =
(__GLXDRIscreen *) __glXgetActiveScreen(draw->base.pDraw->pScreen->myNum);
draw->driDrawable = (*screen->driScreen.getDrawable)(NULL,
draw->base.drawId,
screen->driScreen.private);
}
static void
__glXDRIdrawableDestroy(__GLXdrawable *private)
{
@ -170,16 +188,8 @@ static GLboolean
__glXDRIdrawableSwapBuffers(__GLXdrawable *basePrivate)
{
__GLXDRIdrawable *private = (__GLXDRIdrawable *) basePrivate;
__GLXDRIscreen *screen;
/* FIXME: We're jumping through hoops here to get the DRIdrawable
* which the dri driver tries to keep to it self... cf. FIXME in
* createDrawable. */
screen = (__GLXDRIscreen *) __glXgetActiveScreen(private->base.pDraw->pScreen->myNum);
private->driDrawable = (screen->driScreen.getDrawable)(NULL,
private->base.drawId,
screen->driScreen.private);
__glXDRIdrawableFoo(private);
(*private->driDrawable->swapBuffers)(NULL,
private->driDrawable->private);
@ -187,21 +197,26 @@ __glXDRIdrawableSwapBuffers(__GLXdrawable *basePrivate)
return TRUE;
}
static int
__glXDRIdrawableSwapInterval(__GLXdrawable *baseDrawable, int interval)
{
__GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseDrawable;
__glXDRIdrawableFoo(draw);
draw->driDrawable->swap_interval = interval;
return 0;
}
static void
__glXDRIdrawableCopySubBuffer(__GLXdrawable *basePrivate,
int x, int y, int w, int h)
{
__GLXDRIdrawable *private = (__GLXDRIdrawable *) basePrivate;
__GLXDRIscreen *screen;
/* FIXME: We're jumping through hoops here to get the DRIdrawable
* which the dri driver tries to keep to it self... cf. FIXME in
* createDrawable. */
screen = (__GLXDRIscreen *) __glXgetActiveScreen(private->base.pDraw->pScreen->myNum);
private->driDrawable = (screen->driScreen.getDrawable)(NULL,
private->base.drawId,
screen->driScreen.private);
__glXDRIdrawableFoo(private);
(*private->driDrawable->copySubBuffer)(NULL,
private->driDrawable->private,
@ -587,8 +602,21 @@ filter_modes(__GLcontextModes **server_modes,
}
static void
enable_glx_extension(void *psc, const char *ext_name)
{
__GLXDRIscreen * const screen = (__GLXDRIscreen *) psc;
__glXEnableExtension(screen->glx_enable_bits, ext_name);
}
static __DRIfuncPtr getProcAddress(const char *proc_name)
{
if (strcmp(proc_name, "glxEnableExtension") == 0) {
return (__DRIfuncPtr) enable_glx_extension;
}
return NULL;
}
@ -813,6 +841,7 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
void *dev_priv = NULL;
char filename[128];
Bool isCapable;
size_t buffer_size;
if (!xf86LoaderCheckSymbol("DRIQueryDirectRenderingCapable")) {
LogMessage(X_ERROR, "AIGLX: DRI module not loaded\n");
@ -833,8 +862,13 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
screen->base.destroy = __glXDRIscreenDestroy;
screen->base.createContext = __glXDRIscreenCreateContext;
screen->base.createDrawable = __glXDRIscreenCreateDrawable;
screen->base.swapInterval = __glXDRIdrawableSwapInterval;
screen->base.pScreen = pScreen;
__glXInitExtensionEnableBits(screen->glx_enable_bits);
screen->driScreen.screenConfigs = screen;
/* DRI protocol version. */
dri_version.major = XF86DRI_MAJOR_VERSION;
dri_version.minor = XF86DRI_MINOR_VERSION;
@ -978,6 +1012,18 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
__glXScreenInit(&screen->base, pScreen);
buffer_size = __glXGetExtensionString(screen->glx_enable_bits, NULL);
if (buffer_size > 0) {
if (screen->base.GLXextensions != NULL) {
xfree(screen->base.GLXextensions);
}
screen->base.GLXextensions = xnfalloc(buffer_size);
(void) __glXGetExtensionString(screen->glx_enable_bits,
screen->base.GLXextensions);
}
filter_modes(&screen->base.modes, driver_modes);
_gl_context_modes_destroy(driver_modes);

45
GL/glx/glxext.c
View File

@ -32,6 +32,8 @@
#include "unpack.h"
#include "glxutil.h"
#include "glxext.h"
#include "indirect_table.h"
#include "indirect_util.h"
/*
** The last context used by the server. It is the context that is current
@ -452,7 +454,7 @@ static int __glXDispatch(ClientPtr client)
{
REQUEST(xGLXSingleReq);
CARD8 opcode;
int (*proc)(__GLXclientState *cl, GLbyte *pc);
__GLXdispatchSingleProcPtr proc;
__GLXclientState *cl;
int retval;
@ -481,13 +483,6 @@ static int __glXDispatch(ClientPtr client)
cl->client = client;
}
/*
** Check for valid opcode.
*/
if (opcode >= __GLX_SINGLE_TABLE_SIZE) {
return BadRequest;
}
/*
** If we're expecting a glXRenderLarge request, this better be one.
*/
@ -499,31 +494,23 @@ static int __glXDispatch(ClientPtr client)
/*
** Use the opcode to index into the procedure table.
*/
if (client->swapped)
proc = __glXSwapSingleTable[opcode];
else
proc = __glXSingleTable[opcode];
proc = (__GLXdispatchSingleProcPtr) __glXGetProtocolDecodeFunction(& Single_dispatch_info,
opcode,
client->swapped);
if (proc != NULL) {
__glXleaveServer();
__glXleaveServer();
inDispatch = True;
inDispatch = True;
retval = (*proc)(cl, (GLbyte *) stuff);
retval = proc(cl, (GLbyte *) stuff);
inDispatch = False;
inDispatch = False;
__glXenterServer();
__glXenterServer();
}
else {
retval = BadRequest;
}
return retval;
}
int __glXNoSuchSingleOpcode(__GLXclientState *cl, GLbyte *pc)
{
return BadRequest;
}
void __glXNoSuchRenderOpcode(GLbyte *pc)
{
return;
}

5
GL/glx/glxext.h
View File

@ -66,8 +66,6 @@ typedef struct {
extern GLboolean __glXFreeContext(__GLXcontext *glxc);
extern void __glXFlushContextCache(void);
extern void __glXNoSuchRenderOpcode(GLbyte*);
extern int __glXNoSuchSingleOpcode(__GLXclientState*, GLbyte*);
extern void __glXErrorCallBack(__GLinterface *gc, GLenum code);
extern void __glXClearErrorOccured(void);
extern GLboolean __glXErrorOccured(void);
@ -90,6 +88,9 @@ extern int DoDestroyPixmap(__GLXclientState *cl, XID glxpixmapId);
extern int DoQueryContext(__GLXclientState *cl, GLXContextID gcId);
extern int DoRender(__GLXclientState *cl, GLbyte *pc, int do_swap);
extern int DoRenderLarge(__GLXclientState *cl, GLbyte *pc, int do_swap);
extern void GlxExtensionInit(void);
extern Bool __glXCoreType(void);

50
GL/glx/glxscreens.c
View File

@ -45,28 +45,36 @@
#include "glxutil.h"
#include "glxext.h"
const char GLServerVersion[] = "1.2";
const char GLServerVersion[] = "1.4";
static const char GLServerExtensions[] =
"GL_ARB_depth_texture "
"GL_ARB_draw_buffers "
"GL_ARB_fragment_program "
"GL_ARB_fragment_program_shadow "
"GL_ARB_imaging "
"GL_ARB_multisample "
"GL_ARB_multitexture "
"GL_ARB_occlusion_query "
"GL_ARB_point_parameters "
"GL_ARB_point_sprite "
"GL_ARB_shadow "
"GL_ARB_shadow_ambient "
"GL_ARB_texture_border_clamp "
"GL_ARB_texture_compression "
"GL_ARB_texture_cube_map "
"GL_ARB_texture_env_add "
"GL_ARB_texture_env_combine "
"GL_ARB_texture_env_crossbar "
"GL_ARB_texture_env_dot3 "
"GL_ARB_texture_mirrored_repeat "
"GL_ARB_transpose_matrix "
"GL_ARB_window_pos "
"GL_ARB_texture_non_power_of_two "
"GL_ARB_transpose_matrix "
"GL_ARB_vertex_program "
"GL_ARB_window_pos "
"GL_EXT_abgr "
"GL_EXT_bgra "
"GL_EXT_blend_color "
"GL_EXT_blend_equation_separate "
"GL_EXT_blend_func_separate "
"GL_EXT_blend_logic_op "
"GL_EXT_blend_minmax "
@ -75,47 +83,77 @@ static const char GLServerExtensions[] =
"GL_EXT_copy_texture "
"GL_EXT_draw_range_elements "
"GL_EXT_fog_coord "
"GL_EXT_framebuffer_object "
"GL_EXT_multi_draw_arrays "
"GL_EXT_packed_pixels "
"GL_EXT_paletted_texture "
"GL_EXT_point_parameters "
"GL_EXT_polygon_offset "
"GL_EXT_rescale_normal "
"GL_EXT_secondary_color "
"GL_EXT_separate_specular_color "
"GL_EXT_shadow_funcs "
"GL_EXT_shared_texture_palette "
"GL_EXT_stencil_two_side "
"GL_EXT_stencil_wrap "
"GL_EXT_subtexture "
"GL_EXT_texture "
"GL_EXT_texture3D "
"GL_EXT_texture_compression_dxt1 "
"GL_EXT_texture_compression_s3tc "
"GL_EXT_texture_edge_clamp "
"GL_EXT_texture_env_add "
"GL_EXT_texture_env_combine "
"GL_EXT_texture_env_dot3 "
"GL_EXT_texture_filter_ansiotropic "
"GL_EXT_texture_lod "
"GL_EXT_texture_lod_bias "
"GL_EXT_texture_mirror_clamp "
"GL_EXT_texture_object "
"GL_EXT_texture_rectangle "
"GL_EXT_vertex_array "
"GL_EXT_framebuffer_object "
"GL_3DFX_texture_compression_FXT1 "
"GL_APPLE_packed_pixels "
"GL_ATI_texture_mirror_once "
"GL_ATI_draw_buffers "
"GL_ATI_texture_env_combine3 "
"GL_ATI_texture_mirror_once "
"GL_HP_occlusion_test "
"GL_IBM_texture_mirrored_repeat "
"GL_INGR_blend_func_separate "
"GL_MESA_pack_invert "
"GL_MESA_ycbcr_texture "
"GL_NV_blend_square "
"GL_NV_depth_clamp "
"GL_NV_fog_distance "
"GL_NV_fragment_program "
"GL_NV_fragment_program_option "
"GL_NV_fragment_program2 "
"GL_NV_light_max_exponent "
"GL_NV_multisample_filter_hint "
"GL_NV_point_sprite "
"GL_NV_texgen_reflection "
"GL_NV_texture_rectangle "
"GL_NV_texture_compression_vtc "
"GL_NV_texture_env_combine4 "
"GL_NV_texture_expand_normal "
"GL_NV_texture_rectangle "
"GL_NV_vertex_program "
"GL_NV_vertex_program1_1 "
"GL_NV_vertex_program2 "
"GL_NV_vertex_program2_option "
"GL_NV_vertex_program3 "
"GL_OES_compressed_paletted_texture "
"GL_SGI_color_matrix "
"GL_SGI_color_table "
"GL_SGIS_generate_mipmap "
"GL_SGIS_multisample "
"GL_SGIS_point_parameters "
"GL_SGIS_texture_border_clamp "
"GL_SGIS_texture_edge_clamp "
"GL_SGIS_texture_lod "
"GL_SGIX_depth_texture "
"GL_SGIX_shadow "
"GL_SGIX_shadow_ambient "
"GL_SUN_slice_accum "
;
/*

2
GL/glx/glxscreens.h
View File

@ -62,6 +62,8 @@ struct __GLXscreen {
DrawablePtr pDraw,
XID drawId,
__GLcontextModes *modes);
int (*swapInterval) (__GLXdrawable *drawable,
int interval);
ScreenPtr pScreen;

8
GL/glx/glxserver.h
View File

@ -196,12 +196,12 @@ extern __GLXprocPtr __glXProcTable[];
/*
* Tables for computing the size of each rendering command.
*/
typedef int (*gl_proto_size_func)(const GLbyte *, Bool);
typedef struct {
int bytes;
int (*varsize)(const GLbyte *pc, Bool swap);
gl_proto_size_func varsize;
} __GLXrenderSizeData;
extern __GLXrenderSizeData __glXRenderSizeTable[];
extern __GLXrenderSizeData __glXRenderSizeTable_EXT[];
/************************************************************************/
@ -252,6 +252,6 @@ extern int __glXImageSize(GLenum format, GLenum type,
GLint imageHeight, GLint rowLength, GLint skipImages, GLint skipRows,
GLint alignment);
extern int __glXDrawArraysSize(const GLbyte *pc, Bool swap);
extern int __glXDrawArraysReqSize(const GLbyte *pc, Bool swap);
#endif /* !__GLX_server_h__ */

2018
GL/glx/indirect_dispatch.c
View File

File diff suppressed because it is too large Load Diff

198
GL/glx/indirect_dispatch.h
View File

@ -61,14 +61,20 @@ extern HIDDEN void __glXDisp_ActiveTextureARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ActiveTextureARB(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4ubvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4ubvNV(GLbyte * pc);
extern HIDDEN int __glXDisp_GetColorTableParameterfvSGI(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetColorTableParameterfvSGI(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetProgramNamedParameterdvNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetProgramNamedParameterdvNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Histogram(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Histogram(GLbyte * pc);
extern HIDDEN int __glXDisp_GetMapfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetMapfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_RasterPos4dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_RasterPos4dv(GLbyte * pc);
extern HIDDEN void __glXDisp_PolygonStipple(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PolygonStipple(GLbyte * pc);
extern HIDDEN void __glXDisp_BlendEquationSeparateEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_BlendEquationSeparateEXT(GLbyte * pc);
extern HIDDEN int __glXDisp_GetPixelMapfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetPixelMapfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Color3uiv(GLbyte * pc);
@ -79,16 +85,26 @@ extern HIDDEN void __glXDisp_VertexAttrib4svNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4svNV(GLbyte * pc);
extern HIDDEN void __glXDisp_EvalCoord2fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_EvalCoord2fv(GLbyte * pc);
extern HIDDEN int __glXDisp_DestroyPixmap(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_DestroyPixmap(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ProgramEnvParameter4dvARB(GLbyte * pc);
extern HIDDEN int __glXDisp_GetMapiv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetMapiv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_SwapBuffers(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_SwapBuffers(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Indexubv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Indexubv(GLbyte * pc);
extern HIDDEN int __glXDisp_Render(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_Render(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetQueryivARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetQueryivARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_TexImage3D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexImage3D(GLbyte * pc);
extern HIDDEN int __glXDisp_MakeContextCurrent(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_MakeContextCurrent(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetFBConfigs(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetFBConfigs(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Color3ubv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color3ubv(GLbyte * pc);
extern HIDDEN int __glXDisp_GetQueryObjectivARB(struct __GLXclientStateRec *, GLbyte *);
@ -105,16 +121,18 @@ extern HIDDEN void __glXDisp_VertexAttribs1dvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs1dvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_Normal3bv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Normal3bv(GLbyte * pc);
extern HIDDEN void __glXDisp_TexGeniv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexGeniv(GLbyte * pc);
extern HIDDEN int __glXDisp_VendorPrivate(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_VendorPrivate(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_CreateGLXPixmapWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_CreateGLXPixmapWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Vertex3iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Vertex3iv(GLbyte * pc);
extern HIDDEN void __glXDisp_CopyConvolutionFilter1D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CopyConvolutionFilter1D(GLbyte * pc);
extern HIDDEN void __glXDisp_BlendColor(GLbyte * pc);
extern HIDDEN void __glXDispSwap_BlendColor(GLbyte * pc);
extern HIDDEN void __glXDisp_CallLists(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CallLists(GLbyte * pc);
extern HIDDEN void __glXDisp_Scalef(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Scalef(GLbyte * pc);
extern HIDDEN void __glXDisp_Normal3iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Normal3iv(GLbyte * pc);
extern HIDDEN void __glXDisp_PassThrough(GLbyte * pc);
@ -123,8 +141,10 @@ extern HIDDEN void __glXDisp_Viewport(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Viewport(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4NusvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4NusvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_PrioritizeTextures(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PrioritizeTextures(GLbyte * pc);
extern HIDDEN void __glXDisp_CopyTexSubImage2D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CopyTexSubImage2D(GLbyte * pc);
extern HIDDEN void __glXDisp_DepthRange(GLbyte * pc);
extern HIDDEN void __glXDispSwap_DepthRange(GLbyte * pc);
extern HIDDEN void __glXDisp_ResetHistogram(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ResetHistogram(GLbyte * pc);
extern HIDDEN int __glXDisp_GetProgramNamedParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
@ -145,10 +165,14 @@ extern HIDDEN int __glXDisp_GetConvolutionParameteriv(struct __GLXclientStateRec
extern HIDDEN int __glXDispSwap_GetConvolutionParameteriv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Vertex2dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Vertex2dv(GLbyte * pc);
extern HIDDEN int __glXDisp_GetVisualConfigs(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetVisualConfigs(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_MultiTexCoord1fvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord1fvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_TexCoord3iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord3iv(GLbyte * pc);
extern HIDDEN int __glXDisp_CopyContext(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_CopyContext(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Color3fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color3fv(GLbyte * pc);
extern HIDDEN void __glXDisp_PointSize(GLbyte * pc);
@ -161,36 +185,40 @@ extern HIDDEN void __glXDisp_Vertex4sv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Vertex4sv(GLbyte * pc);
extern HIDDEN int __glXDisp_GetTexEnvfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetTexEnvfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_LineStipple(GLbyte * pc);
extern HIDDEN void __glXDispSwap_LineStipple(GLbyte * pc);
extern HIDDEN void __glXDisp_TexEnvi(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexEnvi(GLbyte * pc);
extern HIDDEN int __glXDisp_GetClipPlane(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetClipPlane(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_VertexAttribs3dvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs3dvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_LightModeli(GLbyte * pc);
extern HIDDEN void __glXDispSwap_LightModeli(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttribs4fvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs4fvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_Scaled(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Scaled(GLbyte * pc);
extern HIDDEN void __glXDisp_Scalef(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Scalef(GLbyte * pc);
extern HIDDEN void __glXDisp_CallLists(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CallLists(GLbyte * pc);
extern HIDDEN void __glXDisp_AlphaFunc(GLbyte * pc);
extern HIDDEN void __glXDispSwap_AlphaFunc(GLbyte * pc);
extern HIDDEN void __glXDisp_TexCoord2iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord2iv(GLbyte * pc);
extern HIDDEN void __glXDisp_CompressedTexImage1DARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CompressedTexImage1DARB(GLbyte * pc);
extern HIDDEN void __glXDisp_Rotated(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Rotated(GLbyte * pc);
extern HIDDEN int __glXDisp_ReadPixels(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_ReadPixels(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_EdgeFlagv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_EdgeFlagv(GLbyte * pc);
extern HIDDEN void __glXDisp_Color4iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color4iv(GLbyte * pc);
extern HIDDEN void __glXDisp_Rotatef(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Rotatef(GLbyte * pc);
extern HIDDEN void __glXDisp_TexParameterf(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexParameterf(GLbyte * pc);
extern HIDDEN void __glXDisp_TexParameteri(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexParameteri(GLbyte * pc);
extern HIDDEN int __glXDisp_DestroyContext(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_DestroyContext(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_DrawPixels(GLbyte * pc);
extern HIDDEN void __glXDispSwap_DrawPixels(GLbyte * pc);
extern HIDDEN void __glXDisp_MultiTexCoord2svARB(GLbyte * pc);
@ -215,22 +243,16 @@ extern HIDDEN void __glXDisp_Color4usv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color4usv(GLbyte * pc);
extern HIDDEN void __glXDisp_Fogi(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Fogi(GLbyte * pc);
extern HIDDEN void __glXDisp_DepthRange(GLbyte * pc);
extern HIDDEN void __glXDispSwap_DepthRange(GLbyte * pc);
extern HIDDEN void __glXDisp_RasterPos3iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_RasterPos3iv(GLbyte * pc);
extern HIDDEN void __glXDisp_PixelMapfv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PixelMapfv(GLbyte * pc);
extern HIDDEN void __glXDisp_Color3usv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color3usv(GLbyte * pc);
extern HIDDEN void __glXDisp_DrawBuffersARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_DrawBuffersARB(GLbyte * pc);
extern HIDDEN int __glXDisp_AreTexturesResident(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_AreTexturesResident(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_IsRenderbufferEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_IsRenderbufferEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_ColorTableParameteriv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ColorTableParameteriv(GLbyte * pc);
extern HIDDEN void __glXDisp_PointParameterfvEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PointParameterfvEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_Color3bv(GLbyte * pc);
@ -291,8 +313,14 @@ extern HIDDEN int __glXDisp_CheckFramebufferStatusEXT(struct __GLXclientStateRec
extern HIDDEN int __glXDispSwap_CheckFramebufferStatusEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetVertexAttribivARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetVertexAttribivARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetFBConfigsSGIX(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetFBConfigsSGIX(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_CreateNewContext(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_CreateNewContext(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetMinmax(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetMinmax(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Normal3fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Normal3fv(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4ivARB(GLbyte * pc);
@ -305,6 +333,8 @@ extern HIDDEN void __glXDisp_MultiTexCoord3fvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord3fvARB(GLbyte * pc);
extern HIDDEN int __glXDisp_GetProgramParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetProgramParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_BindTexture(GLbyte * pc);
extern HIDDEN void __glXDispSwap_BindTexture(GLbyte * pc);
extern HIDDEN void __glXDisp_TexSubImage2D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexSubImage2D(GLbyte * pc);
extern HIDDEN void __glXDisp_DeleteRenderbuffersEXT(GLbyte * pc);
@ -313,8 +343,12 @@ extern HIDDEN void __glXDisp_TexGenfv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexGenfv(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4bvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4bvARB(GLbyte * pc);
extern HIDDEN int __glXDisp_CreateContextWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_CreateContextWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_FramebufferTexture3DEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_FramebufferTexture3DEXT(GLbyte * pc);
extern HIDDEN int __glXDisp_CopySubBufferMESA(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_CopySubBufferMESA(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_BlendEquation(GLbyte * pc);
extern HIDDEN void __glXDispSwap_BlendEquation(GLbyte * pc);
extern HIDDEN int __glXDisp_GetError(struct __GLXclientStateRec *, GLbyte *);
@ -337,6 +371,8 @@ extern HIDDEN void __glXDisp_EndQueryARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_EndQueryARB(GLbyte * pc);
extern HIDDEN void __glXDisp_DepthMask(GLbyte * pc);
extern HIDDEN void __glXDispSwap_DepthMask(GLbyte * pc);
extern HIDDEN void __glXDisp_Rotated(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Rotated(GLbyte * pc);
extern HIDDEN int __glXDisp_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_StencilOp(GLbyte * pc);
@ -345,6 +381,8 @@ extern HIDDEN void __glXDisp_MultiTexCoord3svARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord3svARB(GLbyte * pc);
extern HIDDEN void __glXDisp_TexEnvfv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexEnvfv(GLbyte * pc);
extern HIDDEN int __glXDisp_QueryServerString(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_QueryServerString(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_LoadMatrixf(GLbyte * pc);
extern HIDDEN void __glXDispSwap_LoadMatrixf(GLbyte * pc);
extern HIDDEN void __glXDisp_Color4bv(GLbyte * pc);
@ -361,8 +399,10 @@ extern HIDDEN void __glXDisp_LogicOp(GLbyte * pc);
extern HIDDEN void __glXDispSwap_LogicOp(GLbyte * pc);
extern HIDDEN void __glXDisp_TexCoord4fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord4fv(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib2dvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib2dvNV(GLbyte * pc);
extern HIDDEN int __glXDisp_WaitX(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_WaitX(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_SecondaryColor3uivEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_SecondaryColor3uivEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_FramebufferRenderbufferEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_FramebufferRenderbufferEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib1dvNV(GLbyte * pc);
@ -371,6 +411,8 @@ extern HIDDEN int __glXDisp_GenTextures(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GenTextures(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_FramebufferTexture1DEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_FramebufferTexture1DEXT(GLbyte * pc);
extern HIDDEN int __glXDisp_GetDrawableAttributes(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetDrawableAttributes(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_ProgramParameter4fvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ProgramParameter4fvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_RasterPos2sv(GLbyte * pc);
@ -383,6 +425,8 @@ extern HIDDEN void __glXDisp_TexCoord2fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord2fv(GLbyte * pc);
extern HIDDEN void __glXDisp_TexCoord1sv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord1sv(GLbyte * pc);
extern HIDDEN void __glXDisp_TexGeniv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexGeniv(GLbyte * pc);
extern HIDDEN void __glXDisp_DepthFunc(GLbyte * pc);
extern HIDDEN void __glXDispSwap_DepthFunc(GLbyte * pc);
extern HIDDEN void __glXDisp_PixelMapusv(GLbyte * pc);
@ -391,6 +435,8 @@ extern HIDDEN void __glXDisp_PointParameterivNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PointParameterivNV(GLbyte * pc);
extern HIDDEN void __glXDisp_BlendFunc(GLbyte * pc);
extern HIDDEN void __glXDispSwap_BlendFunc(GLbyte * pc);
extern HIDDEN int __glXDisp_WaitGL(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_WaitGL(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_MultiTexCoord3dvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord3dvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_ProgramNamedParameter4dvNV(GLbyte * pc);
@ -407,22 +453,26 @@ extern HIDDEN void __glXDisp_PushAttrib(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PushAttrib(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4usvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4usvARB(GLbyte * pc);
extern HIDDEN int __glXDisp_DestroyPbuffer(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_DestroyPbuffer(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_TexParameteriv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexParameteriv(GLbyte * pc);
extern HIDDEN void __glXDisp_WindowPos3fvMESA(GLbyte * pc);
extern HIDDEN void __glXDispSwap_WindowPos3fvMESA(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib1svNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib1svNV(GLbyte * pc);
extern HIDDEN int __glXDisp_QueryExtensionsString(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_QueryExtensionsString(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_RasterPos3fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_RasterPos3fv(GLbyte * pc);
extern HIDDEN void __glXDisp_CopyTexSubImage3D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CopyTexSubImage3D(GLbyte * pc);
extern HIDDEN int __glXDisp_GetColorTable(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetColorTable(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_SelectBuffer(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_SelectBuffer(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Indexiv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Indexiv(GLbyte * pc);
extern HIDDEN int __glXDisp_CreateContext(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_CreateContext(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_CopyColorTable(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CopyColorTable(GLbyte * pc);
extern HIDDEN int __glXDisp_GetHistogramParameterfv(struct __GLXclientStateRec *, GLbyte *);
@ -431,8 +481,12 @@ extern HIDDEN void __glXDisp_Frustum(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Frustum(GLbyte * pc);
extern HIDDEN int __glXDisp_GetString(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetString(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_CreateGLXPixmap(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_CreateGLXPixmap(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_TexEnvf(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexEnvf(GLbyte * pc);
extern HIDDEN int __glXDisp_GetProgramStringARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetProgramStringARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_MultiTexCoord3ivARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord3ivARB(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib1dvARB(GLbyte * pc);
@ -443,16 +497,18 @@ extern HIDDEN int __glXDisp_GetTexLevelParameteriv(struct __GLXclientStateRec *,
extern HIDDEN int __glXDispSwap_GetTexLevelParameteriv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_ClearAccum(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ClearAccum(GLbyte * pc);
extern HIDDEN int __glXDisp_QueryVersion(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_QueryVersion(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetVertexAttribfvARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetVertexAttribfvARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_SecondaryColor3ivEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_SecondaryColor3ivEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_TexCoord4iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord4iv(GLbyte * pc);
extern HIDDEN void __glXDisp_PolygonOffset(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PolygonOffset(GLbyte * pc);
extern HIDDEN void __glXDisp_SampleMaskSGIS(GLbyte * pc);
extern HIDDEN void __glXDispSwap_SampleMaskSGIS(GLbyte * pc);
extern HIDDEN void __glXDisp_ColorTableParameteriv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ColorTableParameteriv(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4ubvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4ubvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_CopyTexImage2D(GLbyte * pc);
@ -467,6 +523,8 @@ extern HIDDEN void __glXDisp_Color4fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color4fv(GLbyte * pc);
extern HIDDEN void __glXDisp_MultiTexCoord4ivARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord4ivARB(GLbyte * pc);
extern HIDDEN int __glXDisp_CreatePixmap(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_CreatePixmap(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Lightiv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Lightiv(GLbyte * pc);
extern HIDDEN int __glXDisp_GetQueryObjectuivARB(struct __GLXclientStateRec *, GLbyte *);
@ -479,8 +537,6 @@ extern HIDDEN void __glXDisp_VertexAttrib2dvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib2dvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttribs2svNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs2svNV(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib2fvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib2fvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_Rectdv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Rectdv(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4NivARB(GLbyte * pc);
@ -493,10 +549,12 @@ extern HIDDEN void __glXDisp_PolygonMode(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PolygonMode(GLbyte * pc);
extern HIDDEN void __glXDisp_CompressedTexSubImage1DARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CompressedTexSubImage1DARB(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib2dvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib2dvNV(GLbyte * pc);
extern HIDDEN int __glXDisp_GetVertexAttribivNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetVertexAttribivNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetProgramStringARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetProgramStringARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_IsQueryARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_IsQueryARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_TexGeni(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexGeni(GLbyte * pc);
extern HIDDEN void __glXDisp_TexGenf(GLbyte * pc);
@ -513,6 +571,8 @@ extern HIDDEN void __glXDisp_VertexAttribs1fvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs1fvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4NuivARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4NuivARB(GLbyte * pc);
extern HIDDEN int __glXDisp_DestroyWindow(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_DestroyWindow(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Color4sv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color4sv(GLbyte * pc);
extern HIDDEN int __glXDisp_IsProgramNV(struct __GLXclientStateRec *, GLbyte *);
@ -531,14 +591,18 @@ extern HIDDEN int __glXDisp_DeleteQueriesARB(struct __GLXclientStateRec *, GLbyt
extern HIDDEN int __glXDispSwap_DeleteQueriesARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetMapdv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetMapdv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_DestroyGLXPixmap(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_DestroyGLXPixmap(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_SamplePatternSGIS(GLbyte * pc);
extern HIDDEN void __glXDispSwap_SamplePatternSGIS(GLbyte * pc);
extern HIDDEN int __glXDisp_PixelStoref(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_PixelStoref(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_IsQueryARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_IsQueryARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_PrioritizeTextures(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PrioritizeTextures(GLbyte * pc);
extern HIDDEN int __glXDisp_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Color4iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color4iv(GLbyte * pc);
extern HIDDEN void __glXDisp_EvalCoord2dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_EvalCoord2dv(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib3svARB(GLbyte * pc);
@ -563,12 +627,16 @@ extern HIDDEN void __glXDisp_TexImage1D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexImage1D(GLbyte * pc);
extern HIDDEN void __glXDisp_FrontFace(GLbyte * pc);
extern HIDDEN void __glXDispSwap_FrontFace(GLbyte * pc);
extern HIDDEN void __glXDisp_SecondaryColor3ubvEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_SecondaryColor3ubvEXT(GLbyte * pc);
extern HIDDEN int __glXDisp_RenderLarge(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_RenderLarge(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_VertexAttrib4dvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4dvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_PolygonOffset(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PolygonOffset(GLbyte * pc);
extern HIDDEN void __glXDisp_ExecuteProgramNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ExecuteProgramNV(GLbyte * pc);
extern HIDDEN int __glXDisp_GetColorTableParameterivSGI(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetColorTableParameterivSGI(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Normal3dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Normal3dv(GLbyte * pc);
extern HIDDEN void __glXDisp_Lightf(GLbyte * pc);
@ -585,6 +653,8 @@ extern HIDDEN int __glXDisp_GetFramebufferAttachmentParameterivEXT(struct __GLXc
extern HIDDEN int __glXDispSwap_GetFramebufferAttachmentParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_MultiTexCoord4dvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord4dvARB(GLbyte * pc);
extern HIDDEN int __glXDisp_CreatePbuffer(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_CreatePbuffer(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetDoublev(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetDoublev(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_MultMatrixd(GLbyte * pc);
@ -603,14 +673,16 @@ extern HIDDEN void __glXDisp_VertexAttrib3fvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib3fvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_ClearColor(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ClearColor(GLbyte * pc);
extern HIDDEN int __glXDisp_IsDirect(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_IsDirect(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_DeleteFramebuffersEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_DeleteFramebuffersEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_TexEnviv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexEnviv(GLbyte * pc);
extern HIDDEN void __glXDisp_TexSubImage3D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexSubImage3D(GLbyte * pc);
extern HIDDEN void __glXDisp_SecondaryColor3uivEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_SecondaryColor3uivEXT(GLbyte * pc);
extern HIDDEN int __glXDisp_SwapIntervalSGI(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_SwapIntervalSGI(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetColorTableParameterfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetColorTableParameterfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Bitmap(GLbyte * pc);
@ -633,6 +705,8 @@ extern HIDDEN void __glXDisp_VertexAttrib3svNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib3svNV(GLbyte * pc);
extern HIDDEN int __glXDisp_GetTexEnviv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetTexEnviv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_VendorPrivateWithReply(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_VendorPrivateWithReply(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_SeparableFilter2D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_SeparableFilter2D(GLbyte * pc);
extern HIDDEN void __glXDisp_Map1d(GLbyte * pc);
@ -647,6 +721,8 @@ extern HIDDEN void __glXDisp_ProgramParameters4fvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ProgramParameters4fvNV(GLbyte * pc);
extern HIDDEN int __glXDisp_GetProgramivNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetProgramivNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_ChangeDrawableAttributes(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_ChangeDrawableAttributes(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetMinmaxParameteriv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetMinmaxParameteriv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_PixelTransferf(GLbyte * pc);
@ -661,12 +737,10 @@ extern HIDDEN void __glXDisp_TexCoord1dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord1dv(GLbyte * pc);
extern HIDDEN void __glXDisp_PixelTransferi(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PixelTransferi(GLbyte * pc);
extern HIDDEN int __glXDisp_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_SecondaryColor3ubvEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_SecondaryColor3ubvEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib3fvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib3fvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_Rotatef(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Rotatef(GLbyte * pc);
extern HIDDEN void __glXDisp_Clear(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Clear(GLbyte * pc);
extern HIDDEN void __glXDisp_ReadBuffer(GLbyte * pc);
@ -681,8 +755,10 @@ extern HIDDEN void __glXDisp_ConvolutionParameterf(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ConvolutionParameterf(GLbyte * pc);
extern HIDDEN int __glXDisp_GetColorTableParameteriv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetColorTableParameteriv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_ShadeModel(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ShadeModel(GLbyte * pc);
extern HIDDEN int __glXDisp_ReleaseTexImageEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_ReleaseTexImageEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_CallList(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CallList(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttribs2fvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs2fvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_Rectiv(GLbyte * pc);
@ -697,6 +773,10 @@ extern HIDDEN void __glXDisp_BindRenderbufferEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_BindRenderbufferEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_Vertex3sv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Vertex3sv(GLbyte * pc);
extern HIDDEN int __glXDisp_GetColorTableSGI(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetColorTableSGI(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_BindTexImageEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_BindTexImageEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_ProgramLocalParameter4fvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ProgramLocalParameter4fvARB(GLbyte * pc);
extern HIDDEN int __glXDisp_DeleteProgramsNV(struct __GLXclientStateRec *, GLbyte *);
@ -711,6 +791,8 @@ extern HIDDEN int __glXDisp_GetProgramStringNV(struct __GLXclientStateRec *, GLb
extern HIDDEN int __glXDispSwap_GetProgramStringNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_LineWidth(GLbyte * pc);
extern HIDDEN void __glXDispSwap_LineWidth(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib2fvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib2fvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_TexGendv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexGendv(GLbyte * pc);
extern HIDDEN void __glXDisp_ResetMinmax(GLbyte * pc);
@ -723,8 +805,10 @@ extern HIDDEN void __glXDisp_VertexAttribs4dvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs4dvNV(GLbyte * pc);
extern HIDDEN int __glXDisp_GetMaterialfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetMaterialfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_CallList(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CallList(GLbyte * pc);
extern HIDDEN int __glXDisp_UseXFont(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_UseXFont(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_ShadeModel(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ShadeModel(GLbyte * pc);
extern HIDDEN void __glXDisp_Materialfv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Materialfv(GLbyte * pc);
extern HIDDEN void __glXDisp_TexCoord3fv(GLbyte * pc);
@ -735,8 +819,8 @@ extern HIDDEN void __glXDisp_MultiTexCoord1ivARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord1ivARB(GLbyte * pc);
extern HIDDEN void __glXDisp_MultiTexCoord2ivARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord2ivARB(GLbyte * pc);
extern HIDDEN void __glXDisp_CopyTexSubImage2D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CopyTexSubImage2D(GLbyte * pc);
extern HIDDEN void __glXDisp_DrawArrays(GLbyte * pc);
extern HIDDEN void __glXDispSwap_DrawArrays(GLbyte * pc);
extern HIDDEN void __glXDisp_Color3iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color3iv(GLbyte * pc);
extern HIDDEN int __glXDisp_GetProgramLocalParameterdvARB(struct __GLXclientStateRec *, GLbyte *);
@ -759,16 +843,18 @@ extern HIDDEN void __glXDisp_PopMatrix(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PopMatrix(GLbyte * pc);
extern HIDDEN int __glXDisp_AreTexturesResidentEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_AreTexturesResidentEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_MakeCurrentReadSGI(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_MakeCurrentReadSGI(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetTexGeniv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetTexGeniv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_MakeCurrent(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_MakeCurrent(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Map2d(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Map2d(GLbyte * pc);
extern HIDDEN void __glXDisp_Map2f(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Map2f(GLbyte * pc);
extern HIDDEN void __glXDisp_ProgramStringARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ProgramStringARB(GLbyte * pc);
extern HIDDEN void __glXDisp_RasterPos4dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_RasterPos4dv(GLbyte * pc);
extern HIDDEN int __glXDisp_GetCompressedTexImageARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetCompressedTexImageARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetTexGenfv(struct __GLXclientStateRec *, GLbyte *);
@ -799,12 +885,16 @@ extern HIDDEN void __glXDisp_Translatef(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Translatef(GLbyte * pc);
extern HIDDEN void __glXDisp_StencilMask(GLbyte * pc);
extern HIDDEN void __glXDispSwap_StencilMask(GLbyte * pc);
extern HIDDEN int __glXDisp_CreateWindow(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_CreateWindow(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetLightiv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetLightiv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_IsList(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_IsList(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_RenderMode(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_RenderMode(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_DrawBuffersARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_DrawBuffersARB(GLbyte * pc);
extern HIDDEN void __glXDisp_LoadName(GLbyte * pc);
extern HIDDEN void __glXDispSwap_LoadName(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttribs4ubvNV(GLbyte * pc);
@ -813,8 +903,8 @@ extern HIDDEN void __glXDisp_CopyTexSubImage1D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CopyTexSubImage1D(GLbyte * pc);
extern HIDDEN void __glXDisp_CullFace(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CullFace(GLbyte * pc);
extern HIDDEN void __glXDisp_BindTexture(GLbyte * pc);
extern HIDDEN void __glXDispSwap_BindTexture(GLbyte * pc);
extern HIDDEN int __glXDisp_QueryContextInfoEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_QueryContextInfoEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_VertexAttribs3svNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs3svNV(GLbyte * pc);
extern HIDDEN void __glXDisp_StencilFunc(GLbyte * pc);
@ -837,6 +927,8 @@ extern HIDDEN int __glXDisp_GetPixelMapuiv(struct __GLXclientStateRec *, GLbyte
extern HIDDEN int __glXDispSwap_GetPixelMapuiv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Indexfv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Indexfv(GLbyte * pc);
extern HIDDEN int __glXDisp_QueryContext(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_QueryContext(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_SecondaryColor3svEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_SecondaryColor3svEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_IndexMask(GLbyte * pc);
@ -885,8 +977,8 @@ extern HIDDEN void __glXDisp_TexCoord4dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord4dv(GLbyte * pc);
extern HIDDEN void __glXDisp_Begin(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Begin(GLbyte * pc);
extern HIDDEN void __glXDisp_LightModeli(GLbyte * pc);
extern HIDDEN void __glXDispSwap_LightModeli(GLbyte * pc);
extern HIDDEN int __glXDisp_ClientInfo(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_ClientInfo(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Rectfv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Rectfv(GLbyte * pc);
extern HIDDEN void __glXDisp_LightModelf(GLbyte * pc);
@ -901,16 +993,14 @@ extern HIDDEN void __glXDisp_MultiTexCoord2fvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord2fvARB(GLbyte * pc);
extern HIDDEN int __glXDisp_GetRenderbufferParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetRenderbufferParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_DrawArrays(GLbyte * pc);
extern HIDDEN void __glXDispSwap_DrawArrays(GLbyte * pc);
extern HIDDEN int __glXDisp_SelectBuffer(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_SelectBuffer(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_ColorMask(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ColorMask(GLbyte * pc);
extern HIDDEN void __glXDisp_RasterPos4iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_RasterPos4iv(GLbyte * pc);
extern HIDDEN void __glXDisp_Enable(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Enable(GLbyte * pc);
extern HIDDEN void __glXDisp_LineStipple(GLbyte * pc);
extern HIDDEN void __glXDispSwap_LineStipple(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttribs4svNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs4svNV(GLbyte * pc);
extern HIDDEN int __glXDisp_GetMinmaxParameterfv(struct __GLXclientStateRec *, GLbyte *);

2048
GL/glx/indirect_dispatch_swap.c
View File

File diff suppressed because it is too large Load Diff

163
GL/glx/indirect_program.c Normal file
View File

@ -0,0 +1,163 @@
/*
* (C) Copyright IBM Corporation 2005, 2006
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sub license,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
* THE COPYRIGHT HOLDERS, THE AUTHORS, AND/OR THEIR SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/**
* \file indirect_program.c
* Hand-coded routines needed to support programmable pipeline extensions.
*
* \author Ian Romanick <idr@us.ibm.com>
*/
#define NEED_REPLIES
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include "glxserver.h"
#include "glxext.h"
#include "singlesize.h"
#include "unpack.h"
#include "indirect_size_get.h"
#include "indirect_dispatch.h"
#include "glapitable.h"
#include "glapi.h"
#include "glthread.h"
#include "dispatch.h"
#include "glapioffsets.h"
#ifdef __linux__
#include <byteswap.h>
#elif defined(__OpenBSD__)
#include <sys/endian.h>
#define bswap_16 __swap16
#define bswap_32 __swap32
#define bswap_64 __swap64
#else
#include <sys/endian.h>
#define bswap_16 bswap16
#define bswap_32 bswap32
#define bswap_64 bswap64
#endif
static int DoGetProgramString(struct __GLXclientStateRec *cl, GLbyte *pc,
unsigned get_programiv_offset, unsigned get_program_string_offset,
Bool do_swap);
/**
* Handle both types of glGetProgramString calls.
*
* This single function handles both \c glGetProgramStringARB and
* \c glGetProgramStringNV. The dispatch offsets for the functions to use
* for \c glGetProgramivARB and \c glGetProgramStringARB are passed in by the
* caller. These can be the offsets of either the ARB versions or the NV
* versions.
*/
int DoGetProgramString(struct __GLXclientStateRec *cl, GLbyte *pc,
unsigned get_programiv_offset,
unsigned get_program_string_offset,
Bool do_swap)
{
xGLXVendorPrivateWithReplyReq * const req =
(xGLXVendorPrivateWithReplyReq *) pc;
int error;
__GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, & error);
ClientPtr client = cl->client;
pc += __GLX_VENDPRIV_HDR_SIZE;
if (cx != NULL) {
GLenum target;
GLenum pname;
GLint compsize = 0;
char *answer = NULL, answerBuffer[200];
if (do_swap) {
target = (GLenum) bswap_32(*(int *)(pc + 0));
pname = (GLenum) bswap_32(*(int *)(pc + 4));
}
else {
target = *(GLenum *)(pc + 0);
pname = *(GLuint *)(pc + 4);
}
/* The value of the GL_PROGRAM_LENGTH_ARB and GL_PROGRAM_LENGTH_NV
* enumerants is the same.
*/
CALL_by_offset(GET_DISPATCH(),
(void (GLAPIENTRYP)(GLuint, GLenum, GLint *)),
get_programiv_offset,
(target, GL_PROGRAM_LENGTH_ARB, &compsize));
if (compsize != 0) {
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
__glXClearErrorOccured();
CALL_by_offset(GET_DISPATCH(),
(void (GLAPIENTRYP)(GLuint, GLenum, GLubyte *)),
get_program_string_offset,
(target, pname, answer));
}
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
__GLX_SEND_HEADER();
} else {
__GLX_BEGIN_REPLY(compsize);
((xGLXGetTexImageReply *)&__glXReply)->width = compsize;
__GLX_SEND_HEADER();
__GLX_SEND_VOID_ARRAY(compsize);
}
error = Success;
}
return error;
}
int __glXDisp_GetProgramStringARB(struct __GLXclientStateRec *cl, GLbyte *pc)
{
return DoGetProgramString(cl, pc, _gloffset_GetProgramivARB,
_gloffset_GetProgramStringARB, False);
}
int __glXDispSwap_GetProgramStringARB(struct __GLXclientStateRec *cl, GLbyte *pc)
{
return DoGetProgramString(cl, pc, _gloffset_GetProgramivARB,
_gloffset_GetProgramStringARB, True);
}
int __glXDisp_GetProgramStringNV(struct __GLXclientStateRec *cl, GLbyte *pc)
{
return DoGetProgramString(cl, pc, _gloffset_GetProgramivNV,
_gloffset_GetProgramStringNV, False);
}
int __glXDispSwap_GetProgramStringNV(struct __GLXclientStateRec *cl, GLbyte *pc)
{
return DoGetProgramString(cl, pc, _gloffset_GetProgramivNV,
_gloffset_GetProgramStringNV, True);
}

113
GL/glx/indirect_size_get.c
View File

@ -609,6 +609,7 @@ __glGetBooleanv_size( GLenum e )
case GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB:
/* case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:*/
case GL_MAX_TEXTURE_LOD_BIAS:
case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
case GL_MAX_SHININESS_NV:
case GL_MAX_SPOT_EXPONENT_NV:
case GL_TEXTURE_CUBE_MAP:
@ -967,57 +968,6 @@ __glGetMinmaxParameterfv_size( GLenum e )
}
}
INTERNAL PURE FASTCALL GLint
__glPointParameterfvEXT_size( GLenum e )
{
switch( e ) {
case GL_POINT_SIZE_MIN:
/* case GL_POINT_SIZE_MIN_ARB:*/
/* case GL_POINT_SIZE_MIN_SGIS:*/
case GL_POINT_SIZE_MAX:
/* case GL_POINT_SIZE_MAX_ARB:*/
/* case GL_POINT_SIZE_MAX_SGIS:*/
case GL_POINT_FADE_THRESHOLD_SIZE:
/* case GL_POINT_FADE_THRESHOLD_SIZE_ARB:*/
/* case GL_POINT_FADE_THRESHOLD_SIZE_SGIS:*/
case GL_POINT_SPRITE_R_MODE_NV:
case GL_POINT_SPRITE_COORD_ORIGIN:
return 1;
case GL_POINT_DISTANCE_ATTENUATION:
/* case GL_POINT_DISTANCE_ATTENUATION_ARB:*/
/* case GL_POINT_DISTANCE_ATTENUATION_SGIS:*/
return 3;
default: return 0;
}
}
INTERNAL PURE FASTCALL GLint
__glGetProgramivNV_size( GLenum e )
{
switch( e ) {
case GL_PROGRAM_LENGTH_NV:
case GL_PROGRAM_TARGET_NV:
case GL_PROGRAM_RESIDENT_NV:
return 1;
default: return 0;
}
}
INTERNAL PURE FASTCALL GLint
__glGetVertexAttribdvARB_size( GLenum e )
{
switch( e ) {
case GL_VERTEX_PROGRAM_ARB:
case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB:
case GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB:
case GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB:
case GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB:
case GL_CURRENT_VERTEX_ATTRIB_ARB:
return 1;
default: return 0;
}
}
INTERNAL PURE FASTCALL GLint
__glGetProgramivARB_size( GLenum e )
{
@ -1073,11 +1023,15 @@ __glGetProgramivARB_size( GLenum e )
}
INTERNAL PURE FASTCALL GLint
__glGetQueryivARB_size( GLenum e )
__glGetVertexAttribdvARB_size( GLenum e )
{
switch( e ) {
case GL_QUERY_COUNTER_BITS_ARB:
case GL_CURRENT_QUERY_ARB:
case GL_VERTEX_PROGRAM_ARB:
case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB:
case GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB:
case GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB:
case GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB:
case GL_CURRENT_VERTEX_ATTRIB_ARB:
return 1;
default: return 0;
}
@ -1094,6 +1048,53 @@ __glGetQueryObjectivARB_size( GLenum e )
}
}
INTERNAL PURE FASTCALL GLint
__glGetQueryivARB_size( GLenum e )
{
switch( e ) {
case GL_QUERY_COUNTER_BITS_ARB:
case GL_CURRENT_QUERY_ARB:
return 1;
default: return 0;
}
}
INTERNAL PURE FASTCALL GLint
__glPointParameterfvEXT_size( GLenum e )
{
switch( e ) {
case GL_POINT_SIZE_MIN:
/* case GL_POINT_SIZE_MIN_ARB:*/
/* case GL_POINT_SIZE_MIN_SGIS:*/
case GL_POINT_SIZE_MAX:
/* case GL_POINT_SIZE_MAX_ARB:*/
/* case GL_POINT_SIZE_MAX_SGIS:*/
case GL_POINT_FADE_THRESHOLD_SIZE:
/* case GL_POINT_FADE_THRESHOLD_SIZE_ARB:*/
/* case GL_POINT_FADE_THRESHOLD_SIZE_SGIS:*/
case GL_POINT_SPRITE_R_MODE_NV:
case GL_POINT_SPRITE_COORD_ORIGIN:
return 1;
case GL_POINT_DISTANCE_ATTENUATION:
/* case GL_POINT_DISTANCE_ATTENUATION_ARB:*/
/* case GL_POINT_DISTANCE_ATTENUATION_SGIS:*/
return 3;
default: return 0;
}
}
INTERNAL PURE FASTCALL GLint
__glGetProgramivNV_size( GLenum e )
{
switch( e ) {
case GL_PROGRAM_LENGTH_NV:
case GL_PROGRAM_TARGET_NV:
case GL_PROGRAM_RESIDENT_NV:
return 1;
default: return 0;
}
}
INTERNAL PURE FASTCALL GLint
__glGetVertexAttribdvNV_size( GLenum e )
{
@ -1153,10 +1154,12 @@ ALIAS( GetHistogramParameteriv, GetHistogramParameterfv )
ALIAS( GetMinmaxParameteriv, GetMinmaxParameterfv )
ALIAS( GetVertexAttribfvARB, GetVertexAttribdvARB )
ALIAS( GetVertexAttribivARB, GetVertexAttribdvARB )
ALIAS( PointParameterivNV, PointParameterfvEXT )
ALIAS( GetQueryObjectuivARB, GetQueryObjectivARB )
ALIAS( GetColorTableParameterfvSGI, GetColorTableParameterfv )
ALIAS( GetColorTableParameterivSGI, GetColorTableParameterfv )
ALIAS( GetVertexAttribfvNV, GetVertexAttribdvNV )
ALIAS( GetVertexAttribivNV, GetVertexAttribdvNV )
ALIAS( PointParameterivNV, PointParameterfvEXT )
# undef PURE
# undef FASTCALL

8
GL/glx/indirect_size_get.h
View File

@ -79,14 +79,16 @@ extern INTERNAL PURE FASTCALL GLint __glGetHistogramParameterfv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetHistogramParameteriv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetMinmaxParameterfv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetMinmaxParameteriv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetProgramivNV_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetProgramivARB_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribdvARB_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribfvARB_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribivARB_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetProgramivARB_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetQueryivARB_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetQueryObjectivARB_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetQueryObjectuivARB_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetQueryivARB_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetColorTableParameterfvSGI_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetColorTableParameterivSGI_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetProgramivNV_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribdvNV_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribfvNV_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribivNV_size(GLenum);

1577
GL/glx/indirect_table.c Normal file
View File

File diff suppressed because it is too large Load Diff

106
GL/glx/indirect_table.h Normal file
View File

@ -0,0 +1,106 @@
/*
* (C) Copyright IBM Corporation 2005, 2006
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sub license,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
* IBM,
* AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
* \file indirect_table.h
*
* \author Ian Romanick <idr@us.ibm.com>
*/
#ifndef INDIRECT_TABLE_H
#define INDIRECT_TABLE_H
#include <inttypes.h>
/**
*/
struct __glXDispatchInfo {
/**
* Number of significant bits in the protocol opcode. Opcodes with values
* larger than ((1 << bits) - 1) are invalid.
*/
unsigned bits;
/**
*/
const int_fast16_t * dispatch_tree;
/**
* Array of protocol decode and dispatch functions index by the opcode
* search tree (i.e., \c dispatch_tree). The first element in each pair
* is the non-byte-swapped version, and the second element is the
* byte-swapped version.
*/
const void *(*dispatch_functions)[2];
/**
* Pointer to size validation data. This table is indexed with the same
* value as ::dispatch_functions.
*
* The first element in the pair is the size, in bytes, of the fixed-size
* portion of the protocol.
*
* For opcodes that have a variable-size portion, the second value is an
* index in \c size_func_table to calculate that size. If there is no
* variable-size portion, this index will be ~0.
*
* \note
* If size checking is not to be performed on this type of protocol
* data, this pointer will be \c NULL.
*/
const int_fast16_t (*size_table)[2];
/**
* Array of functions used to calculate the variable-size portion of
* protocol messages. Indexed by the second element of the entries
* in \c ::size_table.
*
* \note
* If size checking is not to be performed on this type of protocol
* data, this pointer will be \c NULL.
*/
const gl_proto_size_func *size_func_table;
};
/**
* Sentinel value for an empty leaf in the \c dispatch_tree.
*/
#define EMPTY_LEAF INT_FAST16_MIN
/**
* Declare the index \c x as a leaf index.
*/
#define LEAF(x) -x
/**
* Determine if an index is a leaf index.
*/
#define IS_LEAF_INDEX(x) ((x) <= 0)
extern const struct __glXDispatchInfo Single_dispatch_info;
extern const struct __glXDispatchInfo Render_dispatch_info;
extern const struct __glXDispatchInfo VendorPriv_dispatch_info;
#endif /* INDIRECT_TABLE_H */

133
GL/glx/indirect_texture_compression.c Normal file
View File

@ -0,0 +1,133 @@
/*
* (C) Copyright IBM Corporation 2005, 2006
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sub license,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
* IBM,
* AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#define NEED_REPLIES
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include "glxserver.h"
#include "glxext.h"
#include "singlesize.h"
#include "unpack.h"
#include "indirect_size_get.h"
#include "indirect_dispatch.h"
#include "glapitable.h"
#include "glapi.h"
#include "glthread.h"
#include "dispatch.h"
#ifdef __linux__
#include <byteswap.h>
#elif defined(__OpenBSD__)
#include <sys/endian.h>
#define bswap_16 __swap16
#define bswap_32 __swap32
#define bswap_64 __swap64
#else
#include <sys/endian.h>
#define bswap_16 bswap16
#define bswap_32 bswap32
#define bswap_64 bswap64
#endif
int __glXDisp_GetCompressedTexImageARB(struct __GLXclientStateRec *cl, GLbyte *pc)
{
xGLXSingleReq * const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext * const cx = __glXForceCurrent( cl, req->contextTag, & error );
ClientPtr client = cl->client;
pc += __GLX_SINGLE_HDR_SIZE;
if ( cx != NULL ) {
const GLenum target = *(GLenum *)(pc + 0);
const GLint level = *(GLint *)(pc + 4);
GLint compsize = 0;
char *answer, answerBuffer[200];
CALL_GetTexLevelParameteriv(GET_DISPATCH(), (target, level, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, &compsize));
if ( compsize != 0 ) {
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
__glXClearErrorOccured();
CALL_GetCompressedTexImageARB(GET_DISPATCH(), (target, level, answer));
}
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
__GLX_SEND_HEADER();
} else {
__GLX_BEGIN_REPLY(compsize);
((xGLXGetTexImageReply *)&__glXReply)->width = compsize;
__GLX_SEND_HEADER();
__GLX_SEND_VOID_ARRAY(compsize);
}
error = Success;
}
return error;
}
int __glXDispSwap_GetCompressedTexImageARB(struct __GLXclientStateRec *cl, GLbyte *pc)
{
xGLXSingleReq * const req = (xGLXSingleReq *) pc;
int error;
__GLXcontext * const cx = __glXForceCurrent( cl, bswap_32( req->contextTag ), & error );
ClientPtr client = cl->client;
pc += __GLX_SINGLE_HDR_SIZE;
if ( cx != NULL ) {
const GLenum target = (GLenum) bswap_32( *(int *)(pc + 0) );
const GLint level = (GLint ) bswap_32( *(int *)(pc + 4) );
GLint compsize = 0;
char *answer, answerBuffer[200];
CALL_GetTexLevelParameteriv(GET_DISPATCH(), (target, level, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, &compsize));
if ( compsize != 0 ) {
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
__glXClearErrorOccured();
CALL_GetCompressedTexImageARB(GET_DISPATCH(), (target, level, answer));
}
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
__GLX_SEND_HEADER();
} else {
__GLX_BEGIN_REPLY(compsize);
((xGLXGetTexImageReply *)&__glXReply)->width = compsize;
__GLX_SEND_HEADER();
__GLX_SEND_VOID_ARRAY(compsize);
}
error = Success;
}
return error;
}

112
GL/glx/indirect_util.c
View File

@ -52,6 +52,7 @@
#include "glthread.h"
#include "dispatch.h"
#include "glxext.h"
#include "indirect_table.h"
#include "indirect_util.h"
@ -204,3 +205,114 @@ __glXSendReplySwap( ClientPtr client, const void * data, size_t elements,
WriteToClient( client, reply_ints * 4, (char *) data );
}
}
static int
get_decode_index(const struct __glXDispatchInfo *dispatch_info,
unsigned opcode)
{
int remaining_bits;
int next_remain;
const int_fast16_t * const tree = dispatch_info->dispatch_tree;
int_fast16_t index;
remaining_bits = dispatch_info->bits;
if (opcode >= (1U << remaining_bits)) {
return -1;
}
index = 0;
for (/* empty */; remaining_bits > 0; remaining_bits = next_remain) {
unsigned mask;
unsigned child_index;
/* Calculate the slice of bits used by this node.
*
* If remaining_bits = 8 and tree[index] = 3, the mask of just the
* remaining bits is 0x00ff and the mask for the remaining bits after
* this node is 0x001f. By taking 0x00ff & ~0x001f, we get 0x00e0.
* This masks the 3 bits that we would want for this node.
*/
next_remain = remaining_bits - tree[index];
mask = ((1 << remaining_bits) - 1) &
~((1 << next_remain) - 1);
/* Using the mask, calculate the index of the opcode in the node.
* With that index, fetch the index of the next node.
*/
child_index = (opcode & mask) >> next_remain;
index = tree[index + 1 + child_index];
/* If the next node is an empty leaf, the opcode is for a non-existant
* function. We're done.
*
* If the next node is a non-empty leaf, look up the function pointer
* and return it.
*/
if (index == EMPTY_LEAF) {
return -1;
}
else if (IS_LEAF_INDEX(index)) {
unsigned func_index;
/* The value stored in the tree for a leaf node is the base of
* the function pointers for that leaf node. The offset for the
* function for a particular opcode is the remaining bits in the
* opcode.
*/
func_index = -index;
func_index += opcode & ((1 << next_remain) - 1);
return func_index;
}
}
/* We should *never* get here!!!
*/
return -1;
}
void *
__glXGetProtocolDecodeFunction(const struct __glXDispatchInfo *dispatch_info,
int opcode, int swapped_version)
{
const int func_index = get_decode_index(dispatch_info, opcode);
return (func_index < 0)
? NULL
: (void *) dispatch_info->dispatch_functions[func_index][swapped_version];
}
int
__glXGetProtocolSizeData(const struct __glXDispatchInfo *dispatch_info,
int opcode, __GLXrenderSizeData *data)
{
if (dispatch_info->size_table != NULL) {
const int func_index = get_decode_index(dispatch_info, opcode);
if ((func_index >= 0)
&& (dispatch_info->size_table[func_index][0] != 0)) {
const int var_offset =
dispatch_info->size_table[func_index][1];
data->bytes = dispatch_info->size_table[func_index][0];
data->varsize = (var_offset != ~0)
? dispatch_info->size_func_table[var_offset]
: NULL;
return 0;
}
}
return -1;
}

10
GL/glx/indirect_util.h
View File

@ -40,4 +40,14 @@ extern void __glXSendReplySwap( ClientPtr client, const void * data,
size_t elements, size_t element_size, GLboolean always_array,
CARD32 retval );
struct __glXDispatchInfo;
extern void *__glXGetProtocolDecodeFunction(
const struct __glXDispatchInfo *dispatch_info, int opcode,
int swapped_version);
extern int __glXGetProtocolSizeData(
const struct __glXDispatchInfo *dispatch_info, int opcode,
__GLXrenderSizeData *data);
#endif /* __GLX_INDIRECT_UTIL_H__ */

2
GL/glx/rensize.c
View File

@ -323,7 +323,7 @@ int __glXTypeSize(GLenum enm)
}
}
int __glXDrawArraysSize( const GLbyte *pc, Bool swap )
int __glXDrawArraysReqSize( const GLbyte *pc, Bool swap )
{
__GLXdispatchDrawArraysHeader *hdr = (__GLXdispatchDrawArraysHeader *) pc;
__GLXdispatchDrawArraysComponentHeader *compHeader;

2552
GL/glx/rensizetab.c
View File

File diff suppressed because it is too large Load Diff

53
GL/glx/singlepix.c
View File

@ -462,3 +462,56 @@ int __glXDisp_GetColorTable(__GLXclientState *cl, GLbyte *pc)
return Success;
}
int __glXDisp_GetColorTableSGI(__GLXclientState *cl, GLbyte *pc)
{
GLint compsize;
GLenum format, type, target;
GLboolean swapBytes;
__GLXcontext *cx;
ClientPtr client = cl->client;
int error;
char *answer, answerBuffer[200];
GLint width=0;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_VENDPRIV_HDR_SIZE;
target = *(GLenum *)(pc + 0);
format = *(GLenum *)(pc + 4);
type = *(GLenum *)(pc + 8);
swapBytes = *(GLboolean *)(pc + 12);
CALL_GetColorTableParameterivSGI( GET_DISPATCH(), (target, GL_COLOR_TABLE_WIDTH, &width) );
/*
* The one query above might fail if we're in a state where queries
* are illegal, but then width would still be zero anyway.
*/
compsize = __glGetTexImage_size(target,1,format,type,width,1,1);
if (compsize < 0) compsize = 0;
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, swapBytes) );
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
__glXClearErrorOccured();
CALL_GetColorTableSGI( GET_DISPATCH(), (
*(GLenum *)(pc + 0),
*(GLenum *)(pc + 4),
*(GLenum *)(pc + 8),
answer
) );
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
__GLX_SEND_HEADER();
} else {
__GLX_BEGIN_REPLY(compsize);
((xGLXGetColorTableReply *)&__glXReply)->width = width;
__GLX_SEND_HEADER();
__GLX_SEND_VOID_ARRAY(compsize);
}
return Success;
}

59
GL/glx/singlepixswap.c
View File

@ -517,3 +517,62 @@ int __glXDispSwap_GetColorTable(__GLXclientState *cl, GLbyte *pc)
return Success;
}
int __glXDispSwap_GetColorTableSGI(__GLXclientState *cl, GLbyte *pc)
{
GLint compsize;
GLenum format, type, target;
GLboolean swapBytes;
__GLXcontext *cx;
ClientPtr client = cl->client;
int error;
__GLX_DECLARE_SWAP_VARIABLES;
char *answer, answerBuffer[200];
GLint width=0;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_VENDPRIV_HDR_SIZE;
__GLX_SWAP_INT(pc+0);
__GLX_SWAP_INT(pc+4);
__GLX_SWAP_INT(pc+8);
format = *(GLenum *)(pc + 4);
type = *(GLenum *)(pc + 8);
target = *(GLenum *)(pc + 0);
swapBytes = *(GLboolean *)(pc + 12);
CALL_GetColorTableParameterivSGI( GET_DISPATCH(), (target, GL_COLOR_TABLE_WIDTH, &width) );
/*
* The one query above might fail if we're in a state where queries
* are illegal, but then width would still be zero anyway.
*/
compsize = __glGetTexImage_size(target,1,format,type,width,1,1);
if (compsize < 0) compsize = 0;
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) );
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
__glXClearErrorOccured();
CALL_GetColorTableSGI( GET_DISPATCH(), (
*(GLenum *)(pc + 0),
*(GLenum *)(pc + 4),
*(GLenum *)(pc + 8),
answer
) );
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
__GLX_SWAP_REPLY_HEADER();
} else {
__GLX_BEGIN_REPLY(compsize);
__GLX_SWAP_REPLY_HEADER();
__GLX_SWAP_INT(&width);
((xGLXGetColorTableReply *)&__glXReply)->width = width;
__GLX_SEND_VOID_ARRAY(compsize);
}
return Success;
}

105
GL/glx/swap_interval.c Normal file
View File

@ -0,0 +1,105 @@
/*
* (C) Copyright IBM Corporation 2006
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* on the rights to use, copy, modify, merge, publish, distribute, sub
* license, and/or sell copies of the Software, and to permit persons to whom
* the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
* THE COPYRIGHT HOLDERS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
* USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#define NEED_REPLIES
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include "glxserver.h"
#include "glxutil.h"
#include "glxext.h"
#include "singlesize.h"
#include "unpack.h"
#include "indirect_size_get.h"
#include "indirect_dispatch.h"
#include "glapitable.h"
#include "glapi.h"
#include "glthread.h"
#include "dispatch.h"
#include "glapioffsets.h"
#ifdef __linux__
#include <byteswap.h>
#elif defined(__OpenBSD__)
#include <sys/endian.h>
#define bswap_16 __swap16
#define bswap_32 __swap32
#define bswap_64 __swap64
#else
#include <sys/endian.h>
#define bswap_16 bswap16
#define bswap_32 bswap32
#define bswap_64 bswap64
#endif
static int DoSwapInterval(__GLXclientState *cl, GLbyte *pc, int do_swap);
int DoSwapInterval(__GLXclientState *cl, GLbyte *pc, int do_swap)
{
xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
ClientPtr client = cl->client;
const GLXContextTag tag = req->contextTag;
__GLXcontext *cx;
GLint interval;
cx = __glXLookupContextByTag(cl, tag);
LogMessage(X_ERROR, "%s: cx = %p, GLX screen = %p\n", __func__,
cx, (cx == NULL) ? NULL : cx->pGlxScreen);
if ((cx == NULL) || (cx->pGlxScreen == NULL)) {
client->errorValue = tag;
return __glXError(GLXBadContext);
}
if (cx->pGlxScreen->swapInterval == NULL) {
LogMessage(X_ERROR, "AIGLX: cx->pGlxScreen->swapInterval == NULL\n");
client->errorValue = tag;
return __glXError(GLXUnsupportedPrivateRequest);
}
if (cx->drawPriv == NULL) {
client->errorValue = tag;
return __glXError(GLXBadDrawable);
}
pc += __GLX_VENDPRIV_HDR_SIZE;
interval = (do_swap)
? bswap_32(*(int *)(pc + 0))
: *(int *)(pc + 0);
(void) (*cx->pGlxScreen->swapInterval)(cx->drawPriv, interval);
return Success;
}
int __glXDisp_SwapIntervalSGI(__GLXclientState *cl, GLbyte *pc)
{
return DoSwapInterval(cl, pc, 0);
}
int __glXDispSwap_SwapIntervalSGI(__GLXclientState *cl, GLbyte *pc)
{
return DoSwapInterval(cl, pc, 1);
}

3
GL/glx/xfont.c
View File

@ -47,6 +47,7 @@
#include "glapi.h"
#include "glthread.h"
#include "dispatch.h"
#include "indirect_dispatch.h"
#include <GL/gl.h>
#include <pixmapstr.h>
#include <windowstr.h>
@ -156,7 +157,7 @@ MakeBitmapsFromFont(FontPtr pFont, int first, int count, int list_base)
/************************************************************************/
int __glXUseXFont(__GLXclientState *cl, GLbyte *pc)
int __glXDisp_UseXFont(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
xGLXUseXFontReq *req;

2
GL/symlink-mesa.sh
View File

@ -468,7 +468,7 @@ symlink_mesa_shader_slang_library() {
action slang_core_gc.h
action slang_fragment_builtin_gc.h
action slang_shader_syn.h
action slang_version_syn.h
action slang_pp_version_syn.h
action slang_vertex_builtin_gc.h
}

7
Xext/Makefile.am
View File

@ -82,6 +82,12 @@ SERVERCONFIG_DATA = SecurityPolicy
AM_CFLAGS += -DDEFAULTPOLICYFILE=\"$(SERVERCONFIGdir)/SecurityPolicy\"
endif
XCALIBRATE_SRCS = xcalibrate.c
if XCALIBRATE
BUILTIN_SRCS += $(XCALIBRATE_SRCS)
# XCalibrare needs tslib
endif
# X EVent Interception Extension: allows accessibility helpers & composite
# managers to intercept events from input devices and transform as needed
# before the clients see them.
@ -158,6 +164,7 @@ EXTRA_DIST = \
$(SCREENSAVER_SRCS) \
$(XACE_SRCS) \
$(XCSECURITY_SRCS) \
$(XCALIBRATE_SRCS) \
$(XINERAMA_SRCS) \
$(XEVIE_SRCS) \
$(XPRINT_SRCS) \

262
Xext/xcalibrate.c Normal file
View File

@ -0,0 +1,262 @@
/*
* $Id: xcalibrate.c,v 3.1 2004/06/02 20:49:50 pb Exp $
*
* Copyright © 2003 Philip Blundell
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of Philip Blundell not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Philip Blundell makes no
* representations about the suitability of this software for any purpose. It
* is provided "as is" without express or implied warranty.
*
* PHILIP BLUNDELL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL PHILIP BLUNDELL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#ifdef HAVE_KDRIVE_CONFIG_H
#include <kdrive-config.h>
#endif
#define NEED_EVENTS
#define NEED_REPLIES
#include <X11/X.h>
#include <X11/Xproto.h>
#include "misc.h"
#include "os.h"
#include "dixstruct.h"
#include "extnsionst.h"
#include "swaprep.h"
#include <X11/extensions/xcalibrateproto.h>
#include <X11/extensions/xcalibratewire.h>
extern void (*tslib_raw_event_hook)(int x, int y, int pressure, void *closure);
extern void *tslib_raw_event_closure;
static CARD8 XCalibrateReqCode;
int XCalibrateEventBase;
int XCalibrateReqBase;
int XCalibrateErrorBase;
static ClientPtr xcalibrate_client;
static void
xcalibrate_event_hook (int x, int y, int pressure, void *closure)
{
ClientPtr pClient = (ClientPtr) closure;
xXCalibrateRawTouchscreenEvent ev;
ev.type = XCalibrateEventBase + X_XCalibrateRawTouchscreen;
ev.sequenceNumber = pClient->sequence;
ev.x = x;
ev.y = y;
ev.pressure = pressure;
if (!pClient->clientGone)
WriteEventsToClient (pClient, 1, (xEvent *) &ev);
}
static int
ProcXCalibrateQueryVersion (ClientPtr client)
{
REQUEST(xXCalibrateQueryVersionReq);
xXCalibrateQueryVersionReply rep;
CARD16 client_major, client_minor; /* not used */
REQUEST_SIZE_MATCH (xXCalibrateQueryVersionReq);
client_major = stuff->majorVersion;
client_minor = stuff->minorVersion;
fprintf(stderr, "%s(): called\n", __func__);
rep.type = X_Reply;
rep.length = 0;
rep.sequenceNumber = client->sequence;
rep.majorVersion = XCALIBRATE_MAJOR_VERSION;
rep.minorVersion = XCALIBRATE_MINOR_VERSION;
if (client->swapped) {
int n;
swaps(&rep.sequenceNumber, n);
swapl(&rep.length, n);
swaps(&rep.majorVersion, n);
swaps(&rep.minorVersion, n);
}
WriteToClient(client, sizeof (xXCalibrateQueryVersionReply), (char *)&rep);
return (client->noClientException);
}
static int
SProcXCalibrateQueryVersion (ClientPtr client)
{
REQUEST(xXCalibrateQueryVersionReq);
int n;
REQUEST_SIZE_MATCH (xXCalibrateQueryVersionReq);
swaps(&stuff->majorVersion,n);
swaps(&stuff->minorVersion,n);
return ProcXCalibrateQueryVersion(client);
}
static int
ProcXCalibrateSetRawMode (ClientPtr client)
{
REQUEST(xXCalibrateRawModeReq);
xXCalibrateRawModeReply rep;
REQUEST_SIZE_MATCH (xXCalibrateRawModeReq);
memset (&rep, 0, sizeof (rep));
rep.type = X_Reply;
rep.sequenceNumber = client->sequence;
if (stuff->on)
{
if (xcalibrate_client == NULL)
{
/* Start calibrating. */
xcalibrate_client = client;
tslib_raw_event_hook = xcalibrate_event_hook;
tslib_raw_event_closure = client;
rep.status = GrabSuccess;
}
else
{
rep.status = AlreadyGrabbed;
}
}
else
{
if (xcalibrate_client == client)
{
/* Stop calibrating. */
xcalibrate_client = NULL;
tslib_raw_event_hook = NULL;
tslib_raw_event_closure = NULL;
rep.status = GrabSuccess;
/* Cycle input off and on to reload configuration. */
KdDisableInput ();
KdEnableInput ();
}
else
{
rep.status = AlreadyGrabbed;
}
}
if (client->swapped)
{
int n;
swaps (&rep.sequenceNumber, n);
swaps (&rep.status, n);
}
WriteToClient(client, sizeof (rep), (char *) &rep);
return (client->noClientException);
}
static int
SProcXCalibrateSetRawMode (ClientPtr client)
{
REQUEST(xXCalibrateRawModeReq);
int n;
REQUEST_SIZE_MATCH (xXCalibrateRawModeReq);
swaps(&stuff->on, n);
return ProcXCalibrateSetRawMode(client);
}
static void
XCalibrateResetProc (ExtensionEntry *extEntry)
{
}
static int
ProcXCalibrateDispatch (ClientPtr client)
{
REQUEST(xReq);
switch (stuff->data) {
case X_XCalibrateQueryVersion:
return ProcXCalibrateQueryVersion(client);
case X_XCalibrateRawMode:
return ProcXCalibrateSetRawMode(client);
default: break;
}
return BadRequest;
}
static int
SProcXCalibrateDispatch (ClientPtr client)
{
REQUEST(xReq);
int n;
swaps(&stuff->length,n);
switch (stuff->data) {
case X_XCalibrateQueryVersion:
return SProcXCalibrateQueryVersion(client);
case X_XCalibrateRawMode:
return SProcXCalibrateSetRawMode(client);
default: break;
}
return BadRequest;
}
static void
XCalibrateClientCallback (CallbackListPtr *list,
pointer closure,
pointer data)
{
NewClientInfoRec *clientinfo = (NewClientInfoRec *) data;
ClientPtr pClient = clientinfo->client;
if (clientinfo->setup == NULL
&& xcalibrate_client != NULL
&& xcalibrate_client == pClient)
{
/* Stop calibrating. */
xcalibrate_client = NULL;
tslib_raw_event_hook = NULL;
tslib_raw_event_closure = NULL;
}
}
void
XCalibrateExtensionInit(void)
{
ExtensionEntry *extEntry;
if (!AddCallback (&ClientStateCallback, XCalibrateClientCallback, 0))
return;
extEntry = AddExtension(XCALIBRATE_NAME, XCalibrateNumberEvents, XCalibrateNumberErrors,
ProcXCalibrateDispatch, SProcXCalibrateDispatch,
XCalibrateResetProc, StandardMinorOpcode);
if (!extEntry)
return;
XCalibrateReqCode = (unsigned char)extEntry->base;
XCalibrateEventBase = extEntry->eventBase;
XCalibrateErrorBase = extEntry->errorBase;
xcalibrate_client = 0;
}

34
configure.ac
View File

@ -416,6 +416,8 @@ AC_ARG_ENABLE(xf86misc, AS_HELP_STRING([--disable-xf86misc], [Build XF86Mi
AC_ARG_ENABLE(xace, AS_HELP_STRING([--disable-xace], [Build X-ACE extension (default: enabled)]), [XACE=$enableval], [XACE=yes])
AC_ARG_ENABLE(xcsecurity, AS_HELP_STRING([--disable-xcsecurity], [Build Security extension (default: enabled)]), [XCSECURITY=$enableval], [XCSECURITY=$XACE])
AC_ARG_ENABLE(appgroup, AS_HELP_STRING([--disable-appgroup], [Build XC-APPGROUP extension (default: enabled)]), [APPGROUP=$enableval], [APPGROUP=$XCSECURITY])
AC_ARG_ENABLE(xcalibrate, AS_HELP_STRING([--enable-xcalibrate], [Build XCalibrate extension (default: disabled)]), [XCALIBRATE=$enableval], [XCALIBRATE=no])
AC_ARG_ENABLE(tslib, AS_HELP_STRING([--enable-tslib], [Build kdrive tslib touchscreen support (default: disabled)]), [TSLIB=$enableval], [TSLIB=no])
AC_ARG_ENABLE(xevie, AS_HELP_STRING([--disable-xevie], [Build XEvIE extension (default: enabled)]), [XEVIE=$enableval], [XEVIE=yes])
AC_ARG_ENABLE(cup, AS_HELP_STRING([--disable-cup], [Build TOG-CUP extension (default: enabled)]), [CUP=$enableval], [CUP=yes])
AC_ARG_ENABLE(evi, AS_HELP_STRING([--disable-evi], [Build Extended-Visual-Information extension (default: enabled)]), [EVI=$enableval], [EVI=yes])
@ -704,6 +706,14 @@ if test "x$XPRINT" = xyes; then
REQUIRED_MODULES="$REQUIRED_MODULES printproto"
fi
if test "x$XCALIBRATE" = xyes && test "$KDRIVE" = yes; then
AC_DEFINE(XCALIBRATE, 1, [Build XCalibrate extension])
REQUIRED_MODULES="$REQUIRED_MODULES xcalibrateproto"
else
XCALIBRATE=no
fi
AM_CONDITIONAL(XCALIBRATE, [test "x$XCALIBRATE" = xyes])
AC_DEFINE(RENDER, 1, [Support RENDER extension])
RENDER_LIB='$(top_builddir)/render/librender.la'
RENDER_INC='-I$(top_srcdir)/render'
@ -1424,7 +1434,6 @@ AM_CONDITIONAL(XWIN_XV, [test "x$XWIN" = xyes && test "x$XV" = xyes])
dnl kdrive DDX
dnl utterly incomplete yet
XEYPHR_LIBS=
XEPHYR_INCS=
@ -1448,6 +1457,13 @@ if test "$KDRIVE" = yes; then
fi
# tslib...
if test "x$TSLIB" = xyes; then
PKG_CHECK_MODULES([TSLIB], [tslib-0.0], [HAVE_TSLIB="yes"], [HAVE_TSLIB="no"])
if test "x$HAVE_TSLIB" = xno; then
AC_MSG_ERROR([tslib must be installed to build the tslib driver. See http://tslib.berlios.de/])
fi
AC_DEFINE(TSLIB, 1, [Have tslib support])
fi
# damage shadow extension glx (NOTYET) fb mi
KDRIVE_INC='-I$(top_srcdir)/hw/kdrive/src'
@ -1455,7 +1471,7 @@ if test "$KDRIVE" = yes; then
KDRIVE_OS_INC='-I$(top_srcdir)/hw/kdrive/linux'
KDRIVE_INCS="$KDRIVE_PURE_INCS $KDRIVE_OS_INC"
KDRIVE_CFLAGS="$XSERVER_CFLAGS -DHAVE_KDRIVE_CONFIG_H"
KDRIVE_CFLAGS="$XSERVER_CFLAGS -DHAVE_KDRIVE_CONFIG_H $TSLIB_CFLAGS"
# dix os fb mi extension glx (NOTYET) damage shadow xpstubs
#KDRIVE_PURE_LIBS="$DIX_LIB $OS_LIB $FB_LIB $XEXT_LIB $MIEXT_DAMAGE_LIB \
@ -1464,25 +1480,26 @@ if test "$KDRIVE" = yes; then
KDRIVE_LIB='$(top_builddir)/hw/kdrive/src/libkdrive.a'
KDRIVE_OS_LIB='$(top_builddir)/hw/kdrive/linux/liblinux.a'
KDRIVE_STUB_LIB='$(top_builddir)/hw/kdrive/src/libkdrivestubs.a'
KDRIVE_LIBS="$DIX_LIB $KDRIVE_LIB $KDRIVE_OS_LIB $KDRIVE_PURE_LIBS $KDRIVE_STUB_LIB"
KDRIVE_LIBS="$DIX_LIB $KDRIVE_LIB $KDRIVE_OS_LIB $KDRIVE_PURE_LIBS $KDRIVE_STUB_LIB $TSLIB_LIBS"
# check if we can build Xephyr
PKG_CHECK_MODULES(XEPHYR, x11 xext xfont xau xdmcp, [xephyr="yes"], [xephyr="no"])
# check for SDL SDK
AC_CHECK_HEADERS([SDL/SDL.h])
if test "x$XSDL" = xauto; then
XSDL="$ac_cv_header_SDL_SDL_h"
fi
fi
AC_SUBST(KDRIVE_INCS)
AC_SUBST(KDRIVE_PURE_INCS)
AC_SUBST(KDRIVE_CFLAGS)
AC_SUBST(KDRIVE_PURE_LIBS)
AC_SUBST(KDRIVE_LIBS)
AM_CONDITIONAL(TSLIB, false)
AM_CONDITIONAL(TSLIB, [test "x$HAVE_TSLIB" = xyes])
AM_CONDITIONAL(H3600_TS, false)
AM_CONDITIONAL(KDRIVEVESA, [test x"$ac_cv_header_sys_vm86_h" = xyes])
AM_CONDITIONAL(KDRIVEFBDEV, [test x"$ac_cv_header_linux_fb_h" = xyes])
#AM_CONDITIONAL(KDRIVEVESA, false)
#AM_CONDITIONAL(KDRIVEFBDEV, false)
# Xephyr needs nanosleep() which is in librt on Solaris
AC_CHECK_FUNC([nanosleep], [],
@ -1493,13 +1510,12 @@ XEPHYR_LIBS="$XEPHYR_LIBS $XSERVER_LIBS"
AC_SUBST([XEPHYR_LIBS])
AC_SUBST([XEPHYR_INCS])
AM_CONDITIONAL(XSDLSERVER, [test x"$ac_cv_header_SDL_SDL_h" = xyes])
if test x"$ac_cv_header_SDL_SDL_h" = xyes -o x"$XSDL" = xyes; then
# PKG_CHECK_MODULES(XSDL_EXTRA, Xfont xau $XDMCP_MODULES)
if test x"$XSDL" = xyes; then
AC_DEFINE(XSDLSERVER,,[Build Xsdl server])
XSDL_LIBS="`sdl-config --libs` $XSERVER_LIBS"
XSDL_INCS="`sdl-config --cflags` $XSERVER_CFLAGS"
fi
AM_CONDITIONAL(XSDLSERVER, [test x"$XSDL" = xyes])
AC_SUBST([XSDL_LIBS])
AC_SUBST([XSDL_INCS])

14
hw/kdrive/ati/Makefile.am
View File

@ -31,10 +31,6 @@ INCLUDES = \
bin_PROGRAMS = Xati
if TSLIB
TSLIB_FLAG = -lts
endif
noinst_LIBRARIES = libati.a
libati_a_SOURCES = \
@ -65,8 +61,12 @@ ATI_LIBS = \
Xati_LDADD = \
$(ATI_LIBS) \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@ \
$(TSLIB_FLAG)
@XSERVER_LIBS@
Xati_DEPENDENCIES = $(ATI_LIBS)
Xati_DEPENDENCIES = \
libati.a \
$(FBDEV_LIBS) \
$(VESA_LIBS) \
$(DRI_LIBS)

17
hw/kdrive/chips/Makefile.am
View File

@ -5,10 +5,6 @@ INCLUDES = \
bin_PROGRAMS = Xchips
if TSLIB
TSLIB_FLAG = -lts
endif
noinst_LIBRARIES = libchips.a
libchips_a_SOURCES = \
@ -19,15 +15,16 @@ libchips_a_SOURCES = \
Xchips_SOURCES = \
chipsstub.c
CHIPS_LIBS = \
libchips.a \
CHIPS_LIBS = \
libchips.a \
$(top_builddir)/hw/kdrive/vesa/libvesa.a \
@KDRIVE_LIBS@
Xchips_LDADD = \
$(CHIPS_LIBS) \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@ \
$(TSLIB_FLAG)
@KDRIVE_LIBS@ \
@XSERVER_LIBS@
Xchips_DEPENDENCIES = $(CHIPS_LIBS) @KDRIVE_LIBS@
Xchips_DEPENDENCIES = \
libchips.a \
$(top_builddir)/hw/kdrive/vesa/libvesa.a

10
hw/kdrive/ephyr/Makefile.am
View File

@ -5,11 +5,6 @@ INCLUDES = \
noinst_LIBRARIES = libxephyr.a libxephyr-hostx.a
if TSLIB
TSLIB_LIBS = -lts
endif
bin_PROGRAMS = Xephyr
libxephyr_a_SOURCES = \
@ -34,11 +29,8 @@ Xephyr_LDADD = \
../../../exa/libexa.la \
@KDRIVE_LIBS@ \
@KDRIVE_LIBS@ \
$(TSLIB_LIBS) \
@XEPHYR_LIBS@
Xephyr_DEPENDENCIES = \
libxephyr.a \
libxephyr-hostx.a \
@KDRIVE_LIBS@ \
../../../exa/libexa.la
libxephyr-hostx.a

11
hw/kdrive/epson/Makefile.am
View File

@ -4,10 +4,6 @@ INCLUDES = \
bin_PROGRAMS = Xepson
if TSLIB
TSLIB_FLAG = -lts
endif
noinst_LIBRARIES = libepson.a
libepson_a_SOURCES = \
@ -25,9 +21,8 @@ EPSON_LIBS = \
@KDRIVE_LIBS@
Xepson_LDADD = \
$(EPSON_LIBS) \
$(EPSON_LIBS) \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@ \
$(TSLIB_FLAG)
@XSERVER_LIBS@
Xepson_DEPENDENCIES = $(EPSON_LIBS) @KDRIVE_LIBS@
Xepson_DEPENDENCIES = libepson.a

4
hw/kdrive/fake/Makefile.am
View File

@ -28,6 +28,4 @@ Xfake_LDADD = \
@XSERVER_LIBS@
Xfake_DEPENDENCIES = \
libfake.a \
@KDRIVE_LIBS@
libfake.a

11
hw/kdrive/fbdev/Makefile.am
View File

@ -6,10 +6,6 @@ noinst_LIBRARIES = libfbdev.a
bin_PROGRAMS = Xfbdev
if TSLIB
TSLIB_FLAG = -lts
endif
libfbdev_a_SOURCES = \
fbdev.c \
fbdev.h
@ -20,10 +16,7 @@ Xfbdev_SOURCES = \
Xfbdev_LDADD = \
libfbdev.a \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@ \
$(TSLIB_FLAG)
@XSERVER_LIBS@
Xfbdev_DEPENDENCIES = \
libfbdev.a \
@KDRIVE_LIBS@
libfbdev.a

18
hw/kdrive/fbdev/fbdev.c
View File

@ -33,16 +33,24 @@
extern int KdTsPhyScreen;
char *fbdevDevicePath = NULL;
Bool
fbdevInitialize (KdCardInfo *card, FbdevPriv *priv)
{
int k;
unsigned long off;
if ((priv->fd = open("/dev/fb0", O_RDWR)) < 0 && \
(priv->fd = open("/dev/fb/0", O_RDWR)) < 0) {
perror("Error opening /dev/fb0");
return FALSE;
}
if (fbdevDevicePath == NULL)
fbdevDevicePath = "/dev/fb0";
if ((priv->fd = open(fbdevDevicePath, O_RDWR)) < 0)
{
ErrorF("Error opening framebuffer %s: %s\n",
fbdevDevicePath, strerror(errno));
return FALSE;
}
/* quiet valgrind */
memset (&priv->fix, '\0', sizeof (priv->fix));
if ((k=ioctl(priv->fd, FBIOGET_FSCREENINFO, &priv->fix)) < 0) {

1
hw/kdrive/fbdev/fbdev.h
View File

@ -53,6 +53,7 @@ typedef struct _fbdevScrPriv {
} FbdevScrPriv;
extern KdCardFuncs fbdevFuncs;
extern char* fbdevDevicePath;
Bool
fbdevInitialize (KdCardInfo *card, FbdevPriv *priv);

19
hw/kdrive/fbdev/fbinit.c
View File

@ -54,15 +54,28 @@ InitInput (int argc, char **argv)
void
ddxUseMsg (void)
{
KdUseMsg();
KdUseMsg();
ErrorF("\nXfbdev Device Usage:\n");
ErrorF("-fb path Framebuffer device to use. Defaults to /dev/fb0\n");
ErrorF("\n");
}
int
ddxProcessArgument (int argc, char **argv, int i)
{
return KdProcessArgument (argc, argv, i);
}
if (!strcmp (argv[i], "-fb"))
{
if (i+1 < argc)
{
fbdevDevicePath = argv[i+1];
return 2;
}
UseMsg();
exit(1);
}
return KdProcessArgument (argc, argv, i);
}
KdCardFuncs fbdevFuncs = {

8
hw/kdrive/i810/Makefile.am
View File

@ -6,9 +6,6 @@ bin_PROGRAMS = Xi810
noinst_LIBRARIES = libi810.a
if TSLIB
TSLIB_FLAG = -lts
endif
libi810_a_SOURCES = \
i810_cursor.c \
@ -29,7 +26,6 @@ I810_LIBS = \
Xi810_LDADD = \
$(I810_LIBS) \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@ \
$(TSLIB_FLAG)
@XSERVER_LIBS@
Xi810_DEPENDENCIES = $(I810_LIBS) @KDRIVE_LIBS@
Xi810_DEPENDENCIES = libi810.a

2
hw/kdrive/mach64/Makefile.am
View File

@ -34,4 +34,4 @@ Xmach64_LDADD = \
$(TSLIB_FLAG)
Xmach64_DEPENDENCIES = $(MACH64_LIBS) @KDRIVE_LIBS@
Xmach64_DEPENDENCIES = $(MACH64_LIBS)

4
hw/kdrive/mga/Makefile.am
View File

@ -32,4 +32,6 @@ Xmga_LDADD = \
@XSERVER_LIBS@ \
$(TSLIB_FLAG)
Xmga_DEPENDENCIES = $(MGA_LIBS) @KDRIVE_LIBS@
Xmga_DEPENDENCIES = \
libmga.a \
$(top_builddir)/hw/kdrive/vesa/libvesa.a

13
hw/kdrive/neomagic/Makefile.am
View File

@ -16,10 +16,6 @@ INCLUDES = \
bin_PROGRAMS = Xneomagic
if TSLIB
TSLIB_FLAG = -lts
endif
noinst_LIBRARIES = libneomagic.a
libneomagic_a_SOURCES = \
@ -41,7 +37,10 @@ NEOMAGIC_LIBS = \
Xneomagic_LDADD = \
$(NEOMAGIC_LIBS) \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@ \
$(TSLIB_FLAG)
@XSERVER_LIBS@
Xneomagic_DEPENDENCIES = $(NEOMAGIC_LIBS) @KDRIVE_LIBS@
Xneomagic_DEPENDENCIES = \
libneomagic.a \
${FBDEV_LIBS} \
${VESA_LIBS}

7
hw/kdrive/nvidia/Makefile.am
View File

@ -30,7 +30,8 @@ NVIDIA_LIBS = \
Xnvidia_LDADD = \
$(NVIDIA_LIBS) \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@ \
$(TSLIB_FLAG)
@XSERVER_LIBS@
Xnvidia_DEPENDENCIES = $(NVIDIA_LIBS) @KDRIVE_LIBS@
Xnvidia_DEPENDENCIES = \
libnvidia.a \
$(top_builddir)/hw/kdrive/vesa/libvesa.a

12
hw/kdrive/pm2/Makefile.am
View File

@ -5,10 +5,6 @@ INCLUDES = \
bin_PROGRAMS = Xpm2
if TSLIB
TSLIB_FLAG = -lts
endif
noinst_LIBRARIES = libpm2.a
libpm2_a_SOURCES = \
@ -28,7 +24,9 @@ PM2_LIBS = \
Xpm2_LDADD = \
$(PM2_LIBS) \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@ \
$(TSLIB_FLAG)
@XSERVER_LIBS@
Xpm2_DEPENDENCIES = $(PM2_LIBS) @KDRIVE_LIBS@
Xpm2_DEPENDENCIES = \
libpm2.a \
$(top_builddir)/hw/kdrive/vesa/libvesa.a

12
hw/kdrive/r128/Makefile.am
View File

@ -5,10 +5,6 @@ INCLUDES = \
bin_PROGRAMS = Xr128
if TSLIB
TSLIB_FLAG = -lts
endif
noinst_LIBRARIES = libr128.a
libr128_a_SOURCES = \
@ -27,7 +23,9 @@ R128_LIBS = \
Xr128_LDADD = \
$(R128_LIBS) \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@ \
$(TSLIB_FLAG)
@XSERVER_LIBS@
Xr128_DEPENDENCIES = $(R128_LIBS) @KDRIVE_LIBS@
Xr128_DEPENDENCIES = \
libr128.a \
$(top_builddir)/hw/kdrive/vesa/libvesa.a

2
hw/kdrive/sdl/Makefile.am
View File

@ -16,5 +16,3 @@ Xsdl_LDADD = @KDRIVE_PURE_LIBS@ \
@XSERVER_LIBS@ \
$(TSLIB_FLAG) \
@XSDL_LIBS@
Xsdl_DEPENDENCIES = @KDRIVE_LIBS@

2
hw/kdrive/sis300/Makefile.am
View File

@ -43,4 +43,4 @@ Xsis_LDADD = \
@KDRIVE_LIBS@ \
$(TSLIB_FLAG)
Xsis_DEPENDENCIES = $(SIS_LIBS) @KDRIVE_LIBS@
Xsis_DEPENDENCIES = $(SIS_LIBS)

13
hw/kdrive/smi/Makefile.am
View File

@ -6,10 +6,6 @@ INCLUDES = \
bin_PROGRAMS = Xsmi
if TSLIB
TSLIB_FLAG = -lts
endif
noinst_LIBRARIES = libsmi.a
# smivideo.c # not ready yet
@ -32,7 +28,10 @@ SMI_LIBS = \
Xsmi_LDADD = \
$(SMI_LIBS) \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@ \
$(TSLIB_FLAG)
@XSERVER_LIBS@
Xsmi_DEPENDENCIES = $(SMI_LIBS) @KDRIVE_LIBS@
Xsmi_DEPENDENCIES = \
libsmi.a \
$(top_builddir)/hw/kdrive/fbdev/libfbdev.a \
$(top_builddir)/hw/kdrive/vesa/libvesa.a

9
hw/kdrive/vesa/Makefile.am
View File

@ -6,11 +6,6 @@ noinst_LIBRARIES = libvesa.a
bin_PROGRAMS = Xvesa
if TSLIB
TSLIB_FLAG = -lts
endif
libvesa_a_SOURCES = \
vesa.c \
vesa.h \
@ -28,9 +23,7 @@ Xvesa_LDADD = \
libvesa.a \
@KDRIVE_LIBS@ \
@KDRIVE_LIBS@ \
$(TSLIB_FLAG) \
@XSERVER_LIBS@
Xvesa_DEPENDENCIES = \
libvesa.a \
@KDRIVE_LIBS@
libvesa.a

2
hw/kdrive/via/Makefile.am
View File

@ -31,4 +31,4 @@ Xvia_LDADD = \
@XSERVER_LIBS@ \
$(TSLIB_FLAG)
Xvia_DEPENDENCIES = $(VIA_LIBS) @KDRIVE_LIBS@
Xvia_DEPENDENCIES = $(VIA_LIBS)

3
hw/vfb/InitOutput.c
View File

@ -364,6 +364,9 @@ ddxProcessArgument(int argc, char *argv[], int i)
if (strcmp (argv[i], "-render") == 0) /* -render */
{
Render = FALSE;
#ifdef COMPOSITE
noCompositeExtension = TRUE;
#endif
return 1;
}

9
hw/xfree86/common/xf86Config.c
View File

@ -761,7 +761,8 @@ typedef enum {
FLAG_RENDER_COLORMAP_MODE,
FLAG_HANDLE_SPECIAL_KEYS,
FLAG_RANDR,
FLAG_AIGLX
FLAG_AIGLX,
FLAG_IGNORE_ABI
} FlagValues;
static OptionInfoRec FlagOptions[] = {
@ -833,6 +834,8 @@ static OptionInfoRec FlagOptions[] = {
{0}, FALSE },
{ FLAG_AIGLX, "AIGLX", OPTV_BOOLEAN,
{0}, FALSE },
{ FLAG_IGNORE_ABI, "IgnoreABI", OPTV_BOOLEAN,
{0}, FALSE },
{ -1, NULL, OPTV_NONE,
{0}, FALSE },
};
@ -891,6 +894,10 @@ configServerFlags(XF86ConfFlagsPtr flagsconf, XF86OptionPtr layoutopts)
&(xf86Info.grabInfo.allowDeactivate));
xf86GetOptValBool(FlagOptions, FLAG_ALLOW_CLOSEDOWN_GRABS,
&(xf86Info.grabInfo.allowClosedown));
xf86GetOptValBool(FlagOptions, FLAG_IGNORE_ABI, &xf86Info.ignoreABI);
if (&xf86Info.ignoreABI) {
xf86Msg(X_CONFIG, "Ignoring ABI Version\n");
}
/*
* Set things up based on the config file information. Some of these

36
hw/xfree86/common/xf86Cursor.c
View File

@ -576,24 +576,40 @@ xf86InitOrigins(void)
/* force edge lists */
if(screen->left) {
ref = screen->left->screennum;
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
ErrorF("Referenced uninitialized screen in Layout!\n");
break;
}
pLayout->left = AddEdge(pLayout->left,
0, xf86Screens[i]->pScreen->height,
xf86Screens[ref]->pScreen->width, 0, ref);
}
if(screen->right) {
ref = screen->right->screennum;
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
ErrorF("Referenced uninitialized screen in Layout!\n");
break;
}
pScreen = xf86Screens[i]->pScreen;
pLayout->right = AddEdge(pLayout->right,
0, pScreen->height, -pScreen->width, 0, ref);
}
if(screen->top) {
ref = screen->top->screennum;
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
ErrorF("Referenced uninitialized screen in Layout!\n");
break;
}
pLayout->up = AddEdge(pLayout->up,
0, xf86Screens[i]->pScreen->width,
0, xf86Screens[ref]->pScreen->height, ref);
}
if(screen->bottom) {
ref = screen->bottom->screennum;
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
ErrorF("Referenced uninitialized screen in Layout!\n");
break;
}
pScreen = xf86Screens[i]->pScreen;
pLayout->down = AddEdge(pLayout->down,
0, pScreen->width, 0, -pScreen->height, ref);
@ -609,6 +625,10 @@ xf86InitOrigins(void)
break;
case PosRelative:
ref = screen->refscreen->screennum;
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
ErrorF("Referenced uninitialized screen in Layout!\n");
break;
}
if(screensLeft & (1 << ref)) break;
dixScreenOrigins[i].x = dixScreenOrigins[ref].x + screen->x;
dixScreenOrigins[i].y = dixScreenOrigins[ref].y + screen->y;
@ -616,6 +636,10 @@ xf86InitOrigins(void)
break;
case PosRightOf:
ref = screen->refscreen->screennum;
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
ErrorF("Referenced uninitialized screen in Layout!\n");
break;
}
if(screensLeft & (1 << ref)) break;
pScreen = xf86Screens[ref]->pScreen;
dixScreenOrigins[i].x =
@ -625,6 +649,10 @@ xf86InitOrigins(void)
break;
case PosLeftOf:
ref = screen->refscreen->screennum;
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
ErrorF("Referenced uninitialized screen in Layout!\n");
break;
}
if(screensLeft & (1 << ref)) break;
pScreen = xf86Screens[i]->pScreen;
dixScreenOrigins[i].x =
@ -634,6 +662,10 @@ xf86InitOrigins(void)
break;
case PosBelow:
ref = screen->refscreen->screennum;
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
ErrorF("Referenced uninitialized screen in Layout!\n");
break;
}
if(screensLeft & (1 << ref)) break;
pScreen = xf86Screens[ref]->pScreen;
dixScreenOrigins[i].x = dixScreenOrigins[ref].x;
@ -643,6 +675,10 @@ xf86InitOrigins(void)
break;
case PosAbove:
ref = screen->refscreen->screennum;
if (! xf86Screens[ref] || ! xf86Screens[ref]->pScreen) {
ErrorF("Referenced uninitialized screen in Layout!\n");
break;
}
if(screensLeft & (1 << ref)) break;
pScreen = xf86Screens[i]->pScreen;
dixScreenOrigins[i].x = dixScreenOrigins[ref].x;

4
hw/xfree86/common/xf86DoScanPci.c
View File

@ -100,10 +100,6 @@ void DoScanPci(int argc, char **argv, int i)
LoaderErrorMsg(NULL, "scanpci", errmaj, errmin);
exit(1);
}
if (LoaderCheckUnresolved(LD_RESOLV_IFDONE)) {
/* For now, just a warning */
xf86Msg(X_WARNING, "Some symbols could not be resolved!\n");
}
PciSetup = (ScanPciSetupProcPtr)LoaderSymbol("ScanPciSetupPciIds");
DisplayPCICardInfo =
(ScanPciDisplayCardInfoProcPtr)LoaderSymbol("ScanPciDisplayPCICardInfo");

13
hw/xfree86/common/xf86Init.c
View File

@ -135,7 +135,8 @@ static int numFormats = 6;
#endif
static Bool formatsDone = FALSE;
InputDriverRec XF86KEYBOARD = {
#ifdef USE_DEPRECATED_KEYBOARD_DRIVER
static InputDriverRec XF86KEYBOARD = {
1,
"keyboard",
NULL,
@ -144,6 +145,7 @@ InputDriverRec XF86KEYBOARD = {
NULL,
0
};
#endif
static Bool
xf86CreateRootWindow(WindowPtr pWin)
@ -331,6 +333,10 @@ InitOutput(ScreenInfo *pScreenInfo, int argc, char **argv)
/* Tell the loader the default module search path */
LoaderSetPath(xf86ModulePath);
if (xf86Info.ignoreABI) {
LoaderSetOptions(LDR_OPT_ABI_MISMATCH_NONFATAL);
}
#ifdef TESTING
{
char **list, **l;
@ -967,11 +973,6 @@ InitOutput(ScreenInfo *pScreenInfo, int argc, char **argv)
#endif
}
if ((serverGeneration == 1) && LoaderCheckUnresolved(LD_RESOLV_IFDONE)) {
/* For now, just a warning */
xf86Msg(X_WARNING, "Some symbols could not be resolved!\n");
}
xf86PostScreenInit();
xf86InitOrigins();

1
hw/xfree86/common/xf86Privstr.h
View File

@ -166,6 +166,7 @@ typedef struct {
MessageType randRFrom;
Bool aiglx;
MessageType aiglxFrom;
Bool ignoreABI;
struct {
Bool disabled; /* enable/disable deactivating
* grabs or closing the

4
hw/xfree86/doc/man/xorg.conf.man.pre
View File

@ -605,6 +605,10 @@ the builtin handler will be used.
.TP 7
.BI "Option \*qAIGLX\*q \*q" boolean \*q
enable or disable AIGLX. AIGLX is enabled by default.
.TP 7
.BI "Option \*qIgnoreABI\*q \*q" boolean \*q
Allow modules built for a different, potentially incompatible version of
the X server to load. Disabled by default.
.SH MODULE SECTION
The
.B Module

7
hw/xnest/Args.c
View File

@ -58,6 +58,13 @@ void ddxInitGlobals(void)
int
ddxProcessArgument (int argc, char *argv[], int i)
{
#ifdef COMPOSITE
/* XXX terrible hack */
extern Bool noCompositeExtension;
noCompositeExtension = TRUE;
#endif
if (!strcmp(argv[i], "-display")) {
if (++i < argc) {
xnestDisplayName = argv[i];

20
hw/xwin/winmultiwindowwndproc.c
View File

@ -304,7 +304,6 @@ winTopLevelWindowProc (HWND hwnd, UINT message,
winScreenInfo *s_pScreenInfo = NULL;
HWND hwndScreen = NULL;
DrawablePtr pDraw = NULL;
int iX, iY, iWidth, iHeight, iBorder;
winWMMessageRec wmMsg;
Bool fWMMsgInitialized = FALSE;
static Bool s_fTracking = FALSE;
@ -442,20 +441,19 @@ winTopLevelWindowProc (HWND hwnd, UINT message,
/* BeginPaint gives us an hdc that clips to the invalidated region */
hdcUpdate = BeginPaint (hwnd, &ps);
/* Get the position and dimensions of the window */
iBorder = wBorderWidth (pWin);
iX = pWin->drawable.x;
iY = pWin->drawable.y;
iWidth = pWin->drawable.width;
iHeight = pWin->drawable.height;
/* Avoid the BitBlt's if the PAINTSTRUCT is bogus */
if (ps.rcPaint.right==0 && ps.rcPaint.bottom==0 && ps.rcPaint.left==0 && ps.rcPaint.top==0)
{
EndPaint (hwndScreen, &ps);
return 0;
}
/* Try to copy from the shadow buffer */
if (!BitBlt (hdcUpdate,
0, 0,
iWidth, iHeight,
ps.rcPaint.left, ps.rcPaint.top,
ps.rcPaint.right - ps.rcPaint.left, ps.rcPaint.bottom - ps.rcPaint.top,
s_pScreenPriv->hdcShadow,
iX, iY,
ps.rcPaint.left + pWin->drawable.x, ps.rcPaint.top + pWin->drawable.y,
SRCCOPY))
{
LPVOID lpMsgBuf;

7
hw/xwin/winshadgdi.c
View File

@ -540,8 +540,9 @@ winShadowUpdateGDI (ScreenPtr pScreen,
* handle large regions by creating a clipping region and
* doing a single blit constrained to that clipping region.
*/
if (pScreenInfo->dwClipUpdatesNBoxes == 0
|| dwBox < pScreenInfo->dwClipUpdatesNBoxes)
if (!pScreenInfo->fMultiWindow &&
(pScreenInfo->dwClipUpdatesNBoxes == 0 ||
dwBox < pScreenInfo->dwClipUpdatesNBoxes))
{
/* Loop through all boxes in the damaged region */
while (dwBox--)
@ -566,7 +567,7 @@ winShadowUpdateGDI (ScreenPtr pScreen,
++pBox;
}
}
else
else if (!pScreenInfo->fMultiWindow)
{
/* Compute a GDI region from the damaged region */
hrgnCombined = CreateRectRgn (pBox->x1, pBox->y1, pBox->x2, pBox->y2);

3
include/dix-config.h.in
View File

@ -222,6 +222,9 @@
/* Support IPv6 for TCP connections */
#undef IPv6
/* Support os-specific local connections */
#undef LOCALCONN
/* Support MIT Misc extension */
#undef MITMISC