Use _X_HIDDEN to hide a bunch of leaked symbols.

diff --git a/src/glx/x11/dri_glx.c b/src/glx/x11/dri_glx.c
index 853940bb679437956e015558dbe4afe0aa4b20c3..fc1c91d31f3cd79d3a514adffcb819efaf077124 100644 (file)
--- a/src/glx/x11/dri_glx.c
+++ b/src/glx/x11/dri_glx.c
@@ -845,7 +845,7 @@ static void driDestroyDisplay(__GLXDRIdisplay *dpy)
  * This is called from __glXInitialize() when we are given a new
  * display pointer.
  */
-__GLXDRIdisplay *driCreateDisplay(Display *dpy)
+_X_HIDDEN __GLXDRIdisplay *driCreateDisplay(Display *dpy)
 {
     __GLXDRIdisplayPrivate *pdpyp;
     int eventBase, errorBase;

diff --git a/src/glx/x11/glxcmds.c b/src/glx/x11/glxcmds.c
index 73641282421a98ab5a660e9e45ae63c2c6b1cfb9..c761ddf29ffa57b221690524666face272605f56 100644 (file)
--- a/src/glx/x11/glxcmds.c
+++ b/src/glx/x11/glxcmds.c
@@ -474,7 +474,7 @@ PUBLIC GLXContext glXCreateContext(Display *dpy, XVisualInfo *vis,
                        False, 0);
 }
 
-void __glXFreeContext(__GLXcontext *gc)
+_X_HIDDEN void __glXFreeContext(__GLXcontext *gc)
 {
     if (gc->vendor) XFree((char *) gc->vendor);
     if (gc->renderer) XFree((char *) gc->renderer);
@@ -2138,7 +2138,7 @@ static Bool __glXGetSyncValuesOML(Display *dpy, GLXDrawable drawable,
 }
 
 #ifdef GLX_DIRECT_RENDERING
-GLboolean
+_X_HIDDEN GLboolean
 __driGetMscRateOML(__DRIdrawable *draw, int32_t *numerator, int32_t *denominator)
 {
 #ifdef XF86VIDMODE
@@ -2216,8 +2216,9 @@ __driGetMscRateOML(__DRIdrawable *draw, int32_t *numerator, int32_t *denominator
  *       when GLX_OML_sync_control appears in the client extension string.
  */
 
-GLboolean __glXGetMscRateOML(Display * dpy, GLXDrawable drawable,
-                            int32_t * numerator, int32_t * denominator)
+_X_HIDDEN GLboolean __glXGetMscRateOML(Display * dpy, GLXDrawable drawable,
+                                      int32_t * numerator,
+                                      int32_t * denominator)
 {
 #if defined( GLX_DIRECT_RENDERING ) && defined( XF86VIDMODE )
     __DRIdrawable *driDraw = GetDRIDrawable(dpy, drawable, NULL);
@@ -2641,7 +2642,7 @@ static void __glXReleaseTexImageEXT(Display *dpy,
  * 
  * \sa strdup
  */
-char *
+_X_HIDDEN char *
 __glXstrdup(const char *str)
 {
    char *copy;
@@ -2882,7 +2883,7 @@ PUBLIC void (*glXGetProcAddress(const GLubyte *procName))( void )
  *
  * \since Internal API version 20030317.
  */
-int __glXGetUST( int64_t * ust )
+_X_HIDDEN int __glXGetUST( int64_t * ust )
 {
     struct timeval  tv;
     

diff --git a/src/glx/x11/glxext.c b/src/glx/x11/glxext.c
index 012a910a4444326bfb667dab0a3b716f8ee861d2..f4c38b5f63ea0b2ea5a0299595c990be31be7853 100644 (file)
--- a/src/glx/x11/glxext.c
+++ b/src/glx/x11/glxext.c
@@ -149,7 +149,7 @@ static __GLapi *IndirectAPI = NULL;
 static GLboolean TSDinitialized = GL_FALSE;
 static xthread_key_t ContextTSD;
 
-__GLXcontext *__glXGetCurrentContext(void)
+_X_HIDDEN __GLXcontext *__glXGetCurrentContext(void)
 {
    if (!TSDinitialized) {
       xthread_key_create(&ContextTSD, NULL);
@@ -166,7 +166,7 @@ __GLXcontext *__glXGetCurrentContext(void)
    }
 }
 
-void __glXSetCurrentContext(__GLXcontext *c)
+_X_HIDDEN void __glXSetCurrentContext(__GLXcontext *c)
 {
    if (!TSDinitialized) {
       xthread_key_create(&ContextTSD, NULL);
@@ -177,11 +177,11 @@ void __glXSetCurrentContext(__GLXcontext *c)
 
 
 /* Used by the __glXLock() and __glXUnlock() macros */
-xmutex_rec __glXmutex;
+_X_HIDDEN xmutex_rec __glXmutex;
 
 #elif defined( PTHREADS )
 
-pthread_mutex_t __glXmutex = PTHREAD_MUTEX_INITIALIZER;
+_X_HIDDEN pthread_mutex_t __glXmutex = PTHREAD_MUTEX_INITIALIZER;
 
 # if defined( GLX_USE_TLS )
 
@@ -195,7 +195,7 @@ pthread_mutex_t __glXmutex = PTHREAD_MUTEX_INITIALIZER;
 __thread void * __glX_tls_Context __attribute__((tls_model("initial-exec")))
     = &dummyContext;
 
-void __glXSetCurrentContext( __GLXcontext * c )
+_X_HIDDEN void __glXSetCurrentContext( __GLXcontext * c )
 {
     __glX_tls_Context = (c != NULL) ? c : &dummyContext;
 }
@@ -228,13 +228,13 @@ static void init_thread_data( void )
     }
 }
 
-void __glXSetCurrentContext( __GLXcontext * c )
+_X_HIDDEN void __glXSetCurrentContext( __GLXcontext * c )
 {
     pthread_once( & once_control, init_thread_data );
     pthread_setspecific( ContextTSD, c );
 }
 
-__GLXcontext * __glXGetCurrentContext( void )
+_X_HIDDEN __GLXcontext * __glXGetCurrentContext( void )
 {
     void * v;
 
@@ -253,7 +253,7 @@ __GLXcontext * __glXGetCurrentContext( void )
 #else
 
 /* not thread safe */
-__GLXcontext *__glXcurrentContext = &dummyContext;
+_X_HIDDEN __GLXcontext *__glXcurrentContext = &dummyContext;
 
 #endif
 
@@ -262,7 +262,7 @@ __GLXcontext *__glXcurrentContext = &dummyContext;
 ** You can set this cell to 1 to force the gl drawing stuff to be
 ** one command per packet
 */
-int __glXDebug = 0;
+_X_HIDDEN int __glXDebug = 0;
 
 /* Extension required boiler plate */
 
@@ -420,7 +420,7 @@ static Bool QueryVersion(Display *dpy, int opcode, int *major, int *minor)
 }
 
 
-void 
+_X_HIDDEN void 
 __glXInitializeVisualConfigFromTags( __GLcontextModes *config, int count, 
                                     const INT32 *bp, Bool tagged_only,
                                     Bool fbconfig_style_tags )
@@ -782,7 +782,7 @@ static Bool AllocAndFetchScreenConfigs(Display *dpy, __GLXdisplayPrivate *priv)
 /*
 ** Initialize the client side extension code.
 */
-__GLXdisplayPrivate *__glXInitialize(Display* dpy)
+_X_HIDDEN __GLXdisplayPrivate *__glXInitialize(Display* dpy)
 {
     XExtDisplayInfo *info = __glXFindDisplay(dpy);
     XExtData **privList, *private, *found;
@@ -896,7 +896,7 @@ __GLXdisplayPrivate *__glXInitialize(Display* dpy)
 ** Setup for sending a GLX command on dpy.  Make sure the extension is
 ** initialized.  Try to avoid calling __glXInitialize as its kinda slow.
 */
-CARD8 __glXSetupForCommand(Display *dpy)
+_X_HIDDEN CARD8 __glXSetupForCommand(Display *dpy)
 {
     GLXContext gc;
     __GLXdisplayPrivate *priv;
@@ -937,7 +937,7 @@ CARD8 __glXSetupForCommand(Display *dpy)
  * Modify this function to use \c ctx->pc instead of the explicit
  * \c pc parameter.
  */
-GLubyte *__glXFlushRenderBuffer(__GLXcontext *ctx, GLubyte *pc)
+_X_HIDDEN GLubyte *__glXFlushRenderBuffer(__GLXcontext *ctx, GLubyte *pc)
 {
     Display * const dpy = ctx->currentDpy;
 #ifdef USE_XCB
@@ -987,9 +987,9 @@ GLubyte *__glXFlushRenderBuffer(__GLXcontext *ctx, GLubyte *pc)
  * \param data           Command data.
  * \param dataLen        Size, in bytes, of the command data.
  */
-void __glXSendLargeChunk(__GLXcontext *gc, GLint requestNumber, 
-                        GLint totalRequests,
-                        const GLvoid * data, GLint dataLen)
+_X_HIDDEN void __glXSendLargeChunk(__GLXcontext *gc, GLint requestNumber, 
+                                  GLint totalRequests,
+                                  const GLvoid * data, GLint dataLen)
 {
     Display *dpy = gc->currentDpy;
 #ifdef USE_XCB
@@ -1035,9 +1035,9 @@ void __glXSendLargeChunk(__GLXcontext *gc, GLint requestNumber,
  * \param data       Command data.
  * \param dataLen    Size, in bytes, of the command data.
  */
-void __glXSendLargeCommand(__GLXcontext *ctx,
-                          const GLvoid *header, GLint headerLen,
-                          const GLvoid *data, GLint dataLen)
+_X_HIDDEN void __glXSendLargeCommand(__GLXcontext *ctx,
+                                    const GLvoid *header, GLint headerLen,
+                                    const GLvoid *data, GLint dataLen)
 {
     GLint maxSize;
     GLint totalRequests, requestNumber;
@@ -1201,8 +1201,8 @@ FetchDRIDrawable(Display *dpy, GLXDrawable drawable, GLXContext gc)
  * 
  * \note This is in this file so that it can access dummyContext.
  */
-USED static Bool MakeContextCurrent(Display *dpy, GLXDrawable draw,
-                                    GLXDrawable read, GLXContext gc)
+static Bool MakeContextCurrent(Display *dpy, GLXDrawable draw,
+                              GLXDrawable read, GLXContext gc)
 {
     xGLXMakeCurrentReply reply;
     const GLXContext oldGC = __glXGetCurrentContext();
@@ -1365,7 +1365,7 @@ PUBLIC GLX_ALIAS(Bool, glXMakeContextCurrent,
 
 
 #ifdef DEBUG
-void __glXDumpDrawBuffer(__GLXcontext *ctx)
+_X_HIDDEN void __glXDumpDrawBuffer(__GLXcontext *ctx)
 {
     GLubyte *p = ctx->buf;
     GLubyte *end = ctx->pc;

diff --git a/src/glx/x11/glxhash.c b/src/glx/x11/glxhash.c
index 1b284c5f4513a039eb9fc623ae9bc65f26e9f4d8..9ed042903296c41f1908ea0f537c897afbcf0b81 100644 (file)
--- a/src/glx/x11/glxhash.c
+++ b/src/glx/x11/glxhash.c
@@ -71,6 +71,7 @@
  */
 
 #include "glxhash.h"
+#include <X11/Xfuncproto.h>
 
 #define HASH_MAIN 0
 
@@ -137,7 +138,7 @@ static unsigned long HashHash(unsigned long key)
     return hash;
 }
 
-__glxHashTable *__glxHashCreate(void)
+_X_HIDDEN __glxHashTable *__glxHashCreate(void)
 {
     __glxHashTablePtr table;
     int          i;
@@ -154,7 +155,7 @@ __glxHashTable *__glxHashCreate(void)
     return table;
 }
 
-int __glxHashDestroy(__glxHashTable *t)
+_X_HIDDEN int __glxHashDestroy(__glxHashTable *t)
 {
     __glxHashTablePtr  table = (__glxHashTablePtr)t;
     __glxHashBucketPtr bucket;
@@ -205,7 +206,8 @@ static __glxHashBucketPtr HashFind(__glxHashTablePtr table,
     return NULL;
 }
 
-int __glxHashLookup(__glxHashTable *t, unsigned long key, void **value)
+_X_HIDDEN int __glxHashLookup(__glxHashTable *t,
+                             unsigned long key, void **value)
 {
     __glxHashTablePtr  table = (__glxHashTablePtr)t;
     __glxHashBucketPtr bucket;
@@ -218,7 +220,8 @@ int __glxHashLookup(__glxHashTable *t, unsigned long key, void **value)
     return 0;                  /* Found */
 }
 
-int __glxHashInsert(__glxHashTable *t, unsigned long key, void *value)
+_X_HIDDEN int __glxHashInsert(__glxHashTable *t,
+                             unsigned long key, void *value)
 {
     __glxHashTablePtr  table = (__glxHashTablePtr)t;
     __glxHashBucketPtr bucket;
@@ -240,7 +243,7 @@ int __glxHashInsert(__glxHashTable *t, unsigned long key, void *value)
     return 0;                  /* Added to table */
 }
 
-int __glxHashDelete(__glxHashTable *t, unsigned long key)
+_X_HIDDEN int __glxHashDelete(__glxHashTable *t, unsigned long key)
 {
     __glxHashTablePtr  table = (__glxHashTablePtr)t;
     unsigned long hash;
@@ -257,7 +260,8 @@ int __glxHashDelete(__glxHashTable *t, unsigned long key)
     return 0;
 }
 
-int __glxHashNext(__glxHashTable *t, unsigned long *key, void **value)
+_X_HIDDEN int __glxHashNext(__glxHashTable *t,
+                           unsigned long *key, void **value)
 {
     __glxHashTablePtr  table = (__glxHashTablePtr)t;
 
@@ -274,7 +278,8 @@ int __glxHashNext(__glxHashTable *t, unsigned long *key, void **value)
     return 0;
 }
 
-int __glxHashFirst(__glxHashTable *t, unsigned long *key, void **value)
+_X_HIDDEN int __glxHashFirst(__glxHashTable *t,
+                            unsigned long *key, void **value)
 {
     __glxHashTablePtr  table = (__glxHashTablePtr)t;
 

diff --git a/src/glx/x11/xfont.c b/src/glx/x11/xfont.c
index 843a2298b2479b2c2078666476a29f98e335fe71..b650c17c551d7741e0c04469a141c862b6814369 100644 (file)
--- a/src/glx/x11/xfont.c
+++ b/src/glx/x11/xfont.c
@@ -210,7 +210,7 @@ static XCharStruct *isvalid(XFontStruct *fs, int which)
   return(NULL);
 }
 
-void DRI_glXUseXFont( Font font, int first, int count, int listbase )
+_X_HIDDEN void DRI_glXUseXFont( Font font, int first, int count, int listbase )
 {
   GLXContext CC;
   Display *dpy;