add a utility function to print a message to stderr and then quit

diff --git a/eglbackend.cpp b/eglbackend.cpp
index 0d765e9cb64116d3a5455d0f8050e05548a8a38b..2717b8648e648d1a270b85d889aa6f04fd4172b2 100644 (file)
--- a/eglbackend.cpp
+++ b/eglbackend.cpp
@@ -19,7 +19,6 @@
 #include "eglbackend.h"
 #include "glutil.h"
 
 #include "eglbackend.h"
 #include "glutil.h"
 

-#include <stdlib.h>

 #include <stdio.h>
 #include <assert.h>
 
 #include <stdio.h>
 #include <assert.h>
 


@@ -47,11 +46,10 @@ static const char *eglErrorToString(EGLint e)
 #undef CASE
 }
 
 #undef CASE
 }
 

-static void exitEglError(const char *what)
+static void dieEgl(const char *what)

 {
        EGLint e = eglGetError();
 {
        EGLint e = eglGetError();

-       fprintf(stderr, "EGL error %d (%s): %s\n", e, eglErrorToString(e), what);
-       exit(1);
+       die("EGL error %d (%s): %s\n", e, eglErrorToString(e), what);

 }
 
 static const EGLint configAttribs[] = {
 }
 
 static const EGLint configAttribs[] = {


@@ -79,30 +77,28 @@ VisualID EGLBackend::initialize(Display *xDisplay)
                EGLint eglMajor, eglMinor;
                display = eglGetDisplay(xDisplay);
                if (display == EGL_NO_DISPLAY)
                EGLint eglMajor, eglMinor;
                display = eglGetDisplay(xDisplay);
                if (display == EGL_NO_DISPLAY)

-                       exitEglError("Failed to get EGL display");
+                       dieEgl("Failed to get EGL display");

                if (eglInitialize(display, &eglMajor, &eglMinor) == EGL_FALSE)
                if (eglInitialize(display, &eglMajor, &eglMinor) == EGL_FALSE)

-                       exitEglError("Failed to initialize EGL");
+                       dieEgl("Failed to initialize EGL");

                printf("Using EGL version: %d.%d\n", eglMajor, eglMinor);
                if (eglMajor == 1 && eglMinor < 3) {
                        // Choosing the GL context version requires EGL 1.3
                printf("Using EGL version: %d.%d\n", eglMajor, eglMinor);
                if (eglMajor == 1 && eglMinor < 3) {
                        // Choosing the GL context version requires EGL 1.3

-                       fprintf(stderr, "Need at least EGL 1.3 to function properly\n");
-                       exit(1);
+                       die("Need at least EGL 1.3 to function properly\n");

                }
 #ifdef CON_GLES2
                if (eglBindAPI(EGL_OPENGL_ES_API) == EGL_FALSE)
 #else
                if (eglBindAPI(EGL_OPENGL_API) == EGL_FALSE)
 #endif
                }
 #ifdef CON_GLES2
                if (eglBindAPI(EGL_OPENGL_ES_API) == EGL_FALSE)
 #else
                if (eglBindAPI(EGL_OPENGL_API) == EGL_FALSE)
 #endif

-                       exitEglError("Failed to bind API");
+                       dieEgl("Failed to bind API");

                // get an appropriate config
                EGLConfig configs[1];
                EGLint count;
                if (eglChooseConfig(display, configAttribs, configs, 1, &count) == EGL_FALSE){
                // get an appropriate config
                EGLConfig configs[1];
                EGLint count;
                if (eglChooseConfig(display, configAttribs, configs, 1, &count) == EGL_FALSE){

-                       exitEglError("Failed to choose framebuffer configuration");
+                       dieEgl("Failed to choose framebuffer configuration");

                }
                if (count == 0) {
                }
                if (count == 0) {

-                       fprintf(stderr, "Found no matching framebuffer configuration\n");
-                       exit(1);
+                       die("Found no matching framebuffer configuration\n");

                }
                config = configs[0];
        }
                }
                config = configs[0];
        }


@@ -119,9 +115,9 @@ void EGLBackend::createContext(Window window)
        // create an EGL context and use it with the surface
        context = eglCreateContext(display, config, EGL_NO_CONTEXT, contextAttribs);
        if (context == EGL_NO_CONTEXT)
        // create an EGL context and use it with the surface
        context = eglCreateContext(display, config, EGL_NO_CONTEXT, contextAttribs);
        if (context == EGL_NO_CONTEXT)

-               exitEglError("Failed to create context");
+               dieEgl("Failed to create context");

        if (eglMakeCurrent(display, surface, surface, context) == EGL_FALSE)
        if (eglMakeCurrent(display, surface, surface, context) == EGL_FALSE)

-               exitEglError("Failed to make context current");
+               dieEgl("Failed to make context current");

        printf("Using GL version: %s\n", glGetString(GL_VERSION));
        // initialise GL utilities
        resolveFunctionPointers(eglGetProcAddress);
        printf("Using GL version: %s\n", glGetString(GL_VERSION));
        // initialise GL utilities
        resolveFunctionPointers(eglGetProcAddress);


@@ -144,7 +140,7 @@ void EGLBackend::swapBuffers() const
 {
        assert(context != EGL_NO_CONTEXT); // this implies the display is also initialized
        if (eglSwapBuffers(display, surface) == EGL_FALSE)
 {
        assert(context != EGL_NO_CONTEXT); // this implies the display is also initialized
        if (eglSwapBuffers(display, surface) == EGL_FALSE)

-               exitEglError("Failed to swap buffers");
+               dieEgl("Failed to swap buffers");

 }
 
 void EGLBackend::setSwapInterval(int i) const
 }
 
 void EGLBackend::setSwapInterval(int i) const


@@ -152,16 +148,14 @@ void EGLBackend::setSwapInterval(int i) const
        assert(context != EGL_NO_CONTEXT);
        // check if swap interval value is supported
        if (i < 0) {
        assert(context != EGL_NO_CONTEXT);
        // check if swap interval value is supported
        if (i < 0) {

-               fprintf(stderr, "Cannot set swap interval to %d, must not be negative\n", i);
-               exit(1);
+               die("Cannot set swap interval to %d, must not be negative\n", i);

        }
        EGLint val;
        eglGetConfigAttrib(display, config, EGL_MAX_SWAP_INTERVAL, &val);
        if (i > val) {
        }
        EGLint val;
        eglGetConfigAttrib(display, config, EGL_MAX_SWAP_INTERVAL, &val);
        if (i > val) {

-               fprintf(stderr, "Cannot set swap interval to %d, maximum supported value is %d\n", i, val);
-               exit(1);
+               die("Cannot set swap interval to %d, maximum supported value is %d\n", i, val);

        }
        // use it
        if (eglSwapInterval(display, i) == EGL_FALSE)
        }
        // use it
        if (eglSwapInterval(display, i) == EGL_FALSE)

-               exitEglError("Failed to set swap interval");
+               dieEgl("Failed to set swap interval");

 }
 }

diff --git a/glutil.cpp b/glutil.cpp
index 0da85d527472b31c7b64f2ab43163993760dc035..325c131733d9263aad025375541d3c8b9d7083e2 100644 (file)
--- a/glutil.cpp
+++ b/glutil.cpp
@@ -20,6 +20,16 @@
 
 #include <stdio.h>
 #include <stdlib.h>
 
 #include <stdio.h>
 #include <stdlib.h>

+#include <stdarg.h>
+
+void die(const char *msg, ...)
+{
+       va_list ap;
+       va_start(ap, msg);
+       vfprintf(stderr, msg, ap);
+       va_end(ap);
+       exit(1);
+}

 
 static const char *glErrorToString(GLenum e)
 {
 
 static const char *glErrorToString(GLenum e)
 {


@@ -43,6 +53,5 @@ void checkGlError(const char *what)
 {
        GLenum e = glGetError();
        if (e == GL_NO_ERROR) return;
 {
        GLenum e = glGetError();
        if (e == GL_NO_ERROR) return;

-       fprintf(stderr, "GL error %d (%s): %s\n", e, glErrorToString(e), what);
-       exit(1);
+       die("GL error %d (%s): %s\n", e, glErrorToString(e), what);

 }
 }

diff --git a/glutil.h b/glutil.h
index 3c1a6d2058f5b0565285dec3e02cbd97f20a708c..dd1051e26c66eb1c0f27ab76008e5195d475596a 100644 (file)
--- a/glutil.h
+++ b/glutil.h
@@ -23,12 +23,24 @@
 #include <GL/gl.h>
 #endif
 
 #include <GL/gl.h>
 #endif
 

+/**
+ * GNUC has the ability to check format strings that follow the syntax used in printf and others.
+Hide the differences between different compilers in this GNUC_FORMAT_CHECK macro.
+Copied from Wireshark sources.
+*/
+#if __GNUC__ >= 2
+       #define GNUC_FORMAT_CHECK(archetype, string_index, first_to_check) __attribute__((format (archetype, string_index, first_to_check)))
+#else
+       #define GNUC_FORMAT_CHECK(archetype, string_index, first_to_check)
+#endif
+

 /* Function name resolving: Call this after initialising the context, but before any utility function is called */
 typedef void (*T_proc)(void);
 typedef T_proc (*T_glGetProcAddress)(char const *  procname);
 void resolveFunctionPointers(T_glGetProcAddress p_glGetProcAddress);
 
 /* The actual utility functions */
 /* Function name resolving: Call this after initialising the context, but before any utility function is called */
 typedef void (*T_proc)(void);
 typedef T_proc (*T_glGetProcAddress)(char const *  procname);
 void resolveFunctionPointers(T_glGetProcAddress p_glGetProcAddress);
 
 /* The actual utility functions */

+void die(const char *msg, ...) GNUC_FORMAT_CHECK(printf, 1, 2);

 void checkGlError(const char *what);
 void initialise2dProjection();
 void drawQuad(GLfloat red, GLfloat green, GLfloat blue, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
 void checkGlError(const char *what);
 void initialise2dProjection();
 void drawQuad(GLfloat red, GLfloat green, GLfloat blue, GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);

diff --git a/glutil_gl2.cpp b/glutil_gl2.cpp
index 68a789b661ce65d8af5cc410482729c1700938d0..8e55b9311d0fd64e74fc14bd4f46c6c8ed5114ba 100644 (file)
--- a/glutil_gl2.cpp
+++ b/glutil_gl2.cpp
@@ -78,8 +78,7 @@ static T_proc resolveFunctionPointer(T_glGetProcAddress p_glGetProcAddress, cons
 {
        T_proc proc = p_glGetProcAddress(name);
        if (proc == NULL) {
 {
        T_proc proc = p_glGetProcAddress(name);
        if (proc == NULL) {

-               fprintf(stderr, "Error resolvung function %s\n", name);
-               exit(1);
+               die("Error resolvung function %s\n", name);

        }
        return proc;
 }
        }
        return proc;
 }


@@ -96,8 +95,7 @@ void resolveFunctionPointers(T_glGetProcAddress p_glGetProcAddress)
        int majorVersion;
        ssm >> majorVersion;
        if (majorVersion < 2) {
        int majorVersion;
        ssm >> majorVersion;
        if (majorVersion < 2) {

-               fprintf(stderr, "Need at least GL 2.0 to function properly, but detected version %d\n", majorVersion);
-               exit(1);
+               die("Need at least GL 2.0 to function properly, but detected version %d\n", majorVersion);

        }
 #endif
        
        }
 #endif
        

diff --git a/glxbackend.cpp b/glxbackend.cpp
index e40e90c5ba99dd23ad193a3e715f1e5e19c08d7b..2023954b242feb0c1dd786637619d28a748c17fd 100644 (file)
--- a/glxbackend.cpp
+++ b/glxbackend.cpp
@@ -21,7 +21,6 @@
 
 #include <stdio.h>
 #include <assert.h>
 
 #include <stdio.h>
 #include <assert.h>

-#include <stdlib.h>

 #include <GL/glxext.h>
 #include <string>
 
 #include <GL/glxext.h>
 #include <string>
 


@@ -61,8 +60,7 @@ VisualID GLXBackend::initialize(Display *display)
                printf("Using GLX version: %d.%d\n", glxMajor, glxMinor);
                if (glxMajor < 1 || (glxMajor == 1 && glxMinor < 3)) {
                        // glXChooseFBConfig and glXCreateNewContext require GLX 1.3
                printf("Using GLX version: %d.%d\n", glxMajor, glxMinor);
                if (glxMajor < 1 || (glxMajor == 1 && glxMinor < 3)) {
                        // glXChooseFBConfig and glXCreateNewContext require GLX 1.3

-                       fprintf(stderr, "Need at least GLX 1.3 to function properly\n");
-                       exit(1);
+                       die("Need at least GLX 1.3 to function properly\n");

                }
                // check for extension-based functions
                funSwapIntervalMesa = (PFNGLXSWAPINTERVALMESAPROC)resolveGLXFunction("GLX_MESA_swap_control", "glXSwapIntervalMESA");
                }
                // check for extension-based functions
                funSwapIntervalMesa = (PFNGLXSWAPINTERVALMESAPROC)resolveGLXFunction("GLX_MESA_swap_control", "glXSwapIntervalMESA");


@@ -72,8 +70,7 @@ VisualID GLXBackend::initialize(Display *display)
                int count = 0;
                GLXFBConfig *configs = glXChooseFBConfig(display, DefaultScreen(display), configAttribs, &count);
                if (count < 1) {
                int count = 0;
                GLXFBConfig *configs = glXChooseFBConfig(display, DefaultScreen(display), configAttribs, &count);
                if (count < 1) {

-                       fprintf(stderr, "Failed to choose framebuffer configuration\n");
-                       exit(1);
+                       die("Failed to choose framebuffer configuration\n");

                }
                config = configs[0];
                XFree(configs);
                }
                config = configs[0];
                XFree(configs);


@@ -110,14 +107,12 @@ void GLXBackend::createContext(Window window)
        context = glXCreateNewContext(display, config, GLX_RGBA_TYPE, NULL, GL_TRUE);
 #else
        if (!funCreateContextAttribsARB) {
        context = glXCreateNewContext(display, config, GLX_RGBA_TYPE, NULL, GL_TRUE);
 #else
        if (!funCreateContextAttribsARB) {

-               fprintf(stderr, "Cannot create GL3 context: GLX_ARB_create_context not supported\n");
-               exit(1);
+               die("Cannot create GL3 context: GLX_ARB_create_context not supported\n");

        }
        context = funCreateContextAttribsARB(display, config, NULL, GL_TRUE, contextAttribs);
 #endif
        if (!context) {
        }
        context = funCreateContextAttribsARB(display, config, NULL, GL_TRUE, contextAttribs);
 #endif
        if (!context) {

-               fprintf(stderr, "Error creating context\n");
-               exit(1);
+               die("Error creating context\n");

        }
        glXMakeCurrent(display, window, context);                                      
        assert(glXIsDirect(display, context));
        }
        glXMakeCurrent(display, window, context);                                      
        assert(glXIsDirect(display, context));


@@ -147,8 +142,7 @@ void GLXBackend::setSwapInterval(int i) const
        assert(context != None);
        // check if swap interval value is supported
        if (i < 0) {
        assert(context != None);
        // check if swap interval value is supported
        if (i < 0) {

-               fprintf(stderr, "Cannot set swap interval to %d, must not be negative\n", i);
-               exit(1);
+               die("Cannot set swap interval to %d, must not be negative\n", i);

        }
        // set it
        if (funSwapIntervalExt)
        }
        // set it
        if (funSwapIntervalExt)


@@ -156,7 +150,6 @@ void GLXBackend::setSwapInterval(int i) const
        else if (funSwapIntervalMesa)
                funSwapIntervalMesa(i);
        else {
        else if (funSwapIntervalMesa)
                funSwapIntervalMesa(i);
        else {

-               fprintf(stderr, "At least one of GLX_EXT_swap_control, GLX_MESA_swap_control must be supported by the system\n");
-               abort();
+               die("At least one of GLX_EXT_swap_control, GLX_MESA_swap_control must be supported by the system\n");

        }
 }
        }
 }