From 65892e28812cc06cceba26c22caca6e6b83960e0 Mon Sep 17 00:00:00 2001
From: Carl Worth <cworth@cworth.org>
Date: Mon, 10 Jun 2013 14:40:43 -0700
Subject: [PATCH] Add a new GLWRAP_DEFER_WITH_RETURN macro.

This allows for the elimination of some code duplication from our
implementation of glXGetPrcAddressARB. The previous implementation
duplicated code from glwrap_lookup simply because the GLWRAP_DEFER
macro did not provide access to the return value of the wrapped
function.

With the new macro, (very much like GLWRAP_DEFER but accepting a
parameter for a variable to accept the return value), we can eliminate
this code duplication.

Of course, our symbol-extraction script is now a bit more complicated
since it has to find occurrences of DEFER_WITH_RETURN in addition to
occurrences of DEFER, and pull out the function name as the second
argument rather than the first.
---
 extract-wrapped-symbols | 11 ++++++++---
 glwrap.h                |  8 ++++++++
 glxwrap.c               | 23 +++++++----------------
 3 files changed, 23 insertions(+), 19 deletions(-)

diff --git a/extract-wrapped-symbols b/extract-wrapped-symbols
index 2b9f76a..8cdd035 100755
--- a/extract-wrapped-symbols
+++ b/extract-wrapped-symbols
@@ -8,12 +8,16 @@
 # libfips, while all other symbols are private.
 
 # We have two different patterns for identifying wrapped
-# functions. The first is a call to a macro ending in "DEFER" (such as
-# DEFER or TIMED_DEFER). In this case, the first argument to the macro
-# is the name of the wrapped function.
+# functions. The first is a call to one of the DEFER macros
+# (GLWRAP_DEFER, TIMED_DEFER, WGLWRAP_DEFER_WITH_RETURN, etc.). In
+# this case, the name of the wrapped function appears as the first or
+# second argument to the macro, (second for the case of of
+# _WITH_RETURN macro).
 
 deferred=`grep 'DEFER[ (]*e*gl' $@ | sed -s 's/.*DEFER *(\([^,)]*\).*/\1/'`
 
+deferred_return=`grep 'DEFER_WITH_RETURN *([^,]*, *e*gl' $@ | sed -s 's/.*DEFER_WITH_RETURN *([^,]*, *\([^,)]*\).*/\1/'`
+
 # The second-case is functions for which we either implement or call
 # the underlying "real" function. In these cases, the code uses the
 # convention of having a function or a function-pointer with a name of
@@ -32,6 +36,7 @@ global:
 EOF
 
 echo "$deferred
+$deferred_return
 $wrapped" | sort | uniq | sed -e 's/\(.*\)/	\1;/'
 
 cat <<EOF
diff --git a/glwrap.h b/glwrap.h
index 9195007..bd2e265 100644
--- a/glwrap.h
+++ b/glwrap.h
@@ -37,4 +37,12 @@ glwrap_lookup (char *name);
 	real_ ## function(__VA_ARGS__); 			\
 } while (0);
 
+/* As GLWRAP_DEFER, but also set 'ret' to the return value */
+#define GLWRAP_DEFER_WITH_RETURN(ret, function,...) do {	\
+	static typeof(&function) real_ ## function;		\
+	if (! real_ ## function)				\
+		real_ ## function = glwrap_lookup (#function);	\
+	(ret) = real_ ## function(__VA_ARGS__); 		\
+} while (0);
+
 #endif
diff --git a/glxwrap.c b/glxwrap.c
index 6da42e6..84bf485 100644
--- a/glxwrap.c
+++ b/glxwrap.c
@@ -45,24 +45,15 @@ glXSwapBuffers (Display *dpy, GLXDrawable drawable)
  */
 void (*glXGetProcAddressARB (const GLubyte *func))(void)
 {
-	void *ptr;
-	static typeof(&glXGetProcAddressARB) glxwrap_real_glXGetProcAddressARB = NULL;
-	char *name = "glXGetProcAddressARB";
-
-	if (! glxwrap_real_glXGetProcAddressARB) {
-		glxwrap_real_glXGetProcAddressARB = glwrap_lookup (name);
-		if (! glxwrap_real_glXGetProcAddressARB) {
-			fprintf (stderr, "Error: Failed to find function %s.\n",
-				 name);
-			return NULL;
-		}
-	}
+	void *ret;
 
 	/* If our library has this symbol, that's what we want to give. */
-	ptr = dlwrap_real_dlsym (NULL, (const char *) func);
-	if (ptr)
-		return ptr;
+	ret = dlwrap_real_dlsym (NULL, (const char *) func);
+	if (ret)
+		return ret;
 
 	/* Otherwise, just defer to the real glXGetProcAddressARB. */
-	return glxwrap_real_glXGetProcAddressARB (func);
+	GLWRAP_DEFER_WITH_RETURN (ret, glXGetProcAddressARB, func);
+
+	return ret;
 }
-- 
2.43.0