egl: eglGetError should return the status of the last call.

Use macros to record the status of the function call before returning.
This is the only way that eglGetError can return the status of the most
recent function call.

1 files changed, 226 insertions, 123 deletions

diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c
index 7889147c7b2..66fbbe219f3 100644
--- a/src/egl/main/eglapi.c
+++ b/src/egl/main/eglapi.c
@@ -79,6 +79,9 @@
          _eglError(err, __FUNCTION__);          \
       ret;                                      \
    })
+#define _EGL_SUCCESS(disp, ret)  _EGL_ERROR(disp, EGL_SUCCESS, ret)
+/* record EGL_SUCCESS only when ret evaluates to true */
+#define _EGL_EVAL(disp, ret)  _EGL_ERROR(disp, (ret) ? EGL_SUCCESS : 0, ret)
 
 
 /**
@@ -232,7 +235,7 @@ eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
    EGLint major_int, minor_int;
 
    if (!disp)
-      return _eglError(EGL_BAD_DISPLAY, __FUNCTION__);
+      return _EGL_ERROR(NULL, EGL_BAD_DISPLAY, EGL_FALSE);
 
    if (!disp->Initialized) {
       _EGLDriver *drv = disp->Driver;
@@ -241,12 +244,12 @@ eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
          _eglPreloadDrivers();
          drv = _eglMatchDriver(disp);
          if (!drv)
-            return _eglError(EGL_NOT_INITIALIZED, __FUNCTION__);
+            return _EGL_ERROR(disp, EGL_NOT_INITIALIZED, EGL_FALSE);
       }
 
       /* Initialize the particular display now */
       if (!drv->API.Initialize(drv, disp, &major_int, &minor_int))
-         return _eglError(EGL_NOT_INITIALIZED, __FUNCTION__);
+         return _EGL_ERROR(disp, EGL_NOT_INITIALIZED, EGL_FALSE);
 
       disp->APImajor = major_int;
       disp->APIminor = minor_int;
@@ -269,7 +272,7 @@ eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
       *minor = minor_int;
    }
 
-   return EGL_TRUE;
+   return _EGL_SUCCESS(disp, EGL_TRUE);
 }
 
 
@@ -279,7 +282,7 @@ eglTerminate(EGLDisplay dpy)
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
 
    if (!disp)
-      return _eglError(EGL_BAD_DISPLAY, __FUNCTION__);
+      return _EGL_ERROR(NULL, EGL_BAD_DISPLAY, EGL_FALSE);
 
    if (disp->Initialized) {
       _EGLDriver *drv = disp->Driver;
@@ -289,7 +292,7 @@ eglTerminate(EGLDisplay dpy)
       disp->Initialized = EGL_FALSE;
    }
 
-   return EGL_TRUE;
+   return _EGL_SUCCESS(disp, EGL_TRUE);
 }
 
 
@@ -298,9 +301,12 @@ eglQueryString(EGLDisplay dpy, EGLint name)
 {
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLDriver *drv;
+   const char *ret;
 
    drv = _EGL_CHECK_DISPLAY(disp, NULL);
-   return drv->API.QueryString(drv, disp, name);
+   ret = drv->API.QueryString(drv, disp, name);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -310,9 +316,12 @@ eglGetConfigs(EGLDisplay dpy, EGLConfig *configs,
 {
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
-   return drv->API.GetConfigs(drv, disp, configs, config_size, num_config);
+   ret = drv->API.GetConfigs(drv, disp, configs, config_size, num_config);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -322,10 +331,13 @@ eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs,
 {
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
-   return drv->API.ChooseConfig(drv, disp, attrib_list, configs,
+   ret = drv->API.ChooseConfig(drv, disp, attrib_list, configs,
                                 config_size, num_config);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -336,9 +348,12 @@ eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLConfig *conf = _eglLookupConfig(config, disp);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_CONFIG(disp, conf, EGL_FALSE);
-   return drv->API.GetConfigAttrib(drv, disp, conf, attribute, value);
+   ret = drv->API.GetConfigAttrib(drv, disp, conf, attribute, value);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -351,18 +366,16 @@ eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_list,
    _EGLContext *share = _eglLookupContext(share_list, disp);
    _EGLDriver *drv;
    _EGLContext *context;
+   EGLContext ret;
 
    drv = _EGL_CHECK_CONFIG(disp, conf, EGL_NO_CONTEXT);
-   if (!share && share_list != EGL_NO_CONTEXT) {
-      _eglError(EGL_BAD_CONTEXT, __FUNCTION__);
-      return EGL_NO_CONTEXT;
-   }
+   if (!share && share_list != EGL_NO_CONTEXT)
+      return _EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_NO_CONTEXT);
 
    context = drv->API.CreateContext(drv, disp, conf, share, attrib_list);
-   if (context)
-      return _eglLinkContext(context, disp);
-   else
-      return EGL_NO_CONTEXT;
+   ret = (context) ? _eglLinkContext(context, disp) : EGL_NO_CONTEXT;
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -372,10 +385,13 @@ eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLContext *context = _eglLookupContext(ctx, disp);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_CONTEXT(disp, context, EGL_FALSE);
    _eglUnlinkContext(context);
-   return drv->API.DestroyContext(drv, disp, context);
+   ret = drv->API.DestroyContext(drv, disp, context);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -388,27 +404,30 @@ eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read,
    _EGLSurface *draw_surf = _eglLookupSurface(draw, disp);
    _EGLSurface *read_surf = _eglLookupSurface(read, disp);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    if (!disp)
-      return _eglError(EGL_BAD_DISPLAY, __FUNCTION__);
+      return _EGL_ERROR(disp, EGL_BAD_DISPLAY, EGL_FALSE);
    drv = disp->Driver;
 
    /* display is allowed to be uninitialized under certain condition */
    if (!disp->Initialized) {
       if (draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE ||
           ctx != EGL_NO_CONTEXT)
-         return _eglError(EGL_BAD_DISPLAY, __FUNCTION__);
+         return _EGL_ERROR(disp, EGL_BAD_DISPLAY, EGL_FALSE);
    }
    if (!drv)
-      return EGL_TRUE;
+      return _EGL_SUCCESS(disp, EGL_TRUE);
 
    if (!context && ctx != EGL_NO_CONTEXT)
-      return _eglError(EGL_BAD_CONTEXT, __FUNCTION__);
+      return _EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_FALSE);
    if ((!draw_surf && draw != EGL_NO_SURFACE) ||
        (!read_surf && read != EGL_NO_SURFACE))
-      return _eglError(EGL_BAD_SURFACE, __FUNCTION__);
+      return _EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
 
-   return drv->API.MakeCurrent(drv, disp, draw_surf, read_surf, context);
+   ret = drv->API.MakeCurrent(drv, disp, draw_surf, read_surf, context);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -419,9 +438,12 @@ eglQueryContext(EGLDisplay dpy, EGLContext ctx,
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLContext *context = _eglLookupContext(ctx, disp);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_CONTEXT(disp, context, EGL_FALSE);
-   return drv->API.QueryContext(drv, disp, context, attribute, value);
+   ret = drv->API.QueryContext(drv, disp, context, attribute, value);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -433,14 +455,14 @@ eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,
    _EGLConfig *conf = _eglLookupConfig(config, disp);
    _EGLDriver *drv;
    _EGLSurface *surf;
+   EGLSurface ret;
 
    drv = _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE);
 
    surf = drv->API.CreateWindowSurface(drv, disp, conf, window, attrib_list);
-   if (surf)
-      return _eglLinkSurface(surf, disp);
-   else
-      return EGL_NO_SURFACE;
+   ret = (surf) ? _eglLinkSurface(surf, disp) : EGL_NO_SURFACE;
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -452,14 +474,14 @@ eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,
    _EGLConfig *conf = _eglLookupConfig(config, disp);
    _EGLDriver *drv;
    _EGLSurface *surf;
+   EGLSurface ret;
 
    drv = _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE);
 
    surf = drv->API.CreatePixmapSurface(drv, disp, conf, pixmap, attrib_list);
-   if (surf)
-      return _eglLinkSurface(surf, disp);
-   else
-      return EGL_NO_SURFACE;
+   ret = (surf) ? _eglLinkSurface(surf, disp) : EGL_NO_SURFACE;
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -471,14 +493,14 @@ eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config,
    _EGLConfig *conf = _eglLookupConfig(config, disp);
    _EGLDriver *drv;
    _EGLSurface *surf;
+   EGLSurface ret;
 
    drv = _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE);
 
    surf = drv->API.CreatePbufferSurface(drv, disp, conf, attrib_list);
-   if (surf)
-      return _eglLinkSurface(surf, disp);
-   else
-      return EGL_NO_SURFACE;
+   ret = (surf) ? _eglLinkSurface(surf, disp) : EGL_NO_SURFACE;
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -488,10 +510,13 @@ eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLSurface *surf = _eglLookupSurface(surface, disp);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
    _eglUnlinkSurface(surf);
-   return drv->API.DestroySurface(drv, disp, surf);
+   ret = drv->API.DestroySurface(drv, disp, surf);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 EGLBoolean EGLAPIENTRY
@@ -501,9 +526,12 @@ eglQuerySurface(EGLDisplay dpy, EGLSurface surface,
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLSurface *surf = _eglLookupSurface(surface, disp);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
-   return drv->API.QuerySurface(drv, disp, surf, attribute, value);
+   ret = drv->API.QuerySurface(drv, disp, surf, attribute, value);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 EGLBoolean EGLAPIENTRY
@@ -513,9 +541,12 @@ eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface,
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLSurface *surf = _eglLookupSurface(surface, disp);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
-   return drv->API.SurfaceAttrib(drv, disp, surf, attribute, value);
+   ret = drv->API.SurfaceAttrib(drv, disp, surf, attribute, value);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -525,9 +556,12 @@ eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLSurface *surf = _eglLookupSurface(surface, disp);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
-   return drv->API.BindTexImage(drv, disp, surf, buffer);
+   ret = drv->API.BindTexImage(drv, disp, surf, buffer);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -537,9 +571,12 @@ eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLSurface *surf = _eglLookupSurface(surface, disp);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
-   return drv->API.ReleaseTexImage(drv, disp, surf, buffer);
+   ret = drv->API.ReleaseTexImage(drv, disp, surf, buffer);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -550,17 +587,20 @@ eglSwapInterval(EGLDisplay dpy, EGLint interval)
    _EGLContext *ctx = _eglGetCurrentContext();
    _EGLSurface *surf;
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
 
    if (!ctx || !_eglIsContextLinked(ctx) || ctx->Resource.Display != disp)
-      return _eglError(EGL_BAD_CONTEXT, __FUNCTION__);
+      return _EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_FALSE);
 
    surf = ctx->DrawSurface;
    if (!_eglIsSurfaceLinked(surf))
-      return _eglError(EGL_BAD_SURFACE, __FUNCTION__);
+      return _EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
 
-   return drv->API.SwapInterval(drv, disp, surf, interval);
+   ret = drv->API.SwapInterval(drv, disp, surf, interval);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -571,14 +611,17 @@ eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLSurface *surf = _eglLookupSurface(surface, disp);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
 
    /* surface must be bound to current context in EGL 1.4 */
    if (!ctx || !_eglIsContextLinked(ctx) || surf != ctx->DrawSurface)
-      return _eglError(EGL_BAD_SURFACE, __FUNCTION__);
+      return _EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
+
+   ret = drv->API.SwapBuffers(drv, disp, surf);
 
-   return drv->API.SwapBuffers(drv, disp, surf);
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -588,9 +631,12 @@ eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLSurface *surf = _eglLookupSurface(surface, disp);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
-   return drv->API.CopyBuffers(drv, disp, surf, target);
+   ret = drv->API.CopyBuffers(drv, disp, surf, target);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -600,19 +646,22 @@ eglWaitClient(void)
    _EGLContext *ctx = _eglGetCurrentContext();
    _EGLDisplay *disp;
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    if (!ctx)
-      return EGL_TRUE;
+      return _EGL_SUCCESS(NULL, EGL_TRUE);
    /* let bad current context imply bad current surface */
    if (!_eglIsContextLinked(ctx) || !_eglIsSurfaceLinked(ctx->DrawSurface))
-      return _eglError(EGL_BAD_CURRENT_SURFACE, __FUNCTION__);
+      return _EGL_ERROR(NULL, EGL_BAD_CURRENT_SURFACE, EGL_FALSE);
 
-   /* a valid current context implies an initialized current display */
    disp = ctx->Resource.Display;
+
+   /* a valid current context implies an initialized current display */
    assert(disp->Initialized);
    drv = disp->Driver;
+   ret = drv->API.WaitClient(drv, disp, ctx);
 
-   return drv->API.WaitClient(drv, disp, ctx);
+   return _EGL_EVAL(NULL, ret);
 }
 
 
@@ -626,7 +675,7 @@ eglWaitGL(void)
    EGLBoolean ret;
 
    if (api_index != es_index && _eglIsCurrentThreadDummy())
-      return _eglError(EGL_BAD_ALLOC, "eglWaitGL");
+      return _EGL_ERROR(NULL, EGL_BAD_ALLOC, EGL_FALSE);
 
    t->CurrentAPIIndex = es_index;
    ret = eglWaitClient();
@@ -644,19 +693,23 @@ eglWaitNative(EGLint engine)
    _EGLContext *ctx = _eglGetCurrentContext();
    _EGLDisplay *disp;
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    if (!ctx)
-      return EGL_TRUE;
+      return _EGL_SUCCESS(NULL, EGL_TRUE);
+
    /* let bad current context imply bad current surface */
    if (!_eglIsContextLinked(ctx) || !_eglIsSurfaceLinked(ctx->DrawSurface))
-      return _eglError(EGL_BAD_CURRENT_SURFACE, __FUNCTION__);
+      return _EGL_ERROR(NULL, EGL_BAD_CURRENT_SURFACE, EGL_FALSE);
 
-   /* a valid current context implies an initialized current display */
    disp = ctx->Resource.Display;
+
+   /* a valid current context implies an initialized current display */
    assert(disp->Initialized);
    drv = disp->Driver;
+   ret = drv->API.WaitNative(drv, disp, engine);
 
-   return drv->API.WaitNative(drv, disp, engine);
+   return _EGL_EVAL(NULL, ret);
 }
 
 
@@ -664,7 +717,11 @@ EGLDisplay EGLAPIENTRY
 eglGetCurrentDisplay(void)
 {
    _EGLContext *ctx = _eglGetCurrentContext();
-   return (ctx) ? _eglGetDisplayHandle(ctx->Resource.Display) : EGL_NO_DISPLAY;
+   EGLDisplay ret;
+
+   ret = (ctx) ? _eglGetDisplayHandle(ctx->Resource.Display) : EGL_NO_DISPLAY;
+
+   return _EGL_SUCCESS(NULL, ret);
 }
 
 
@@ -672,7 +729,11 @@ EGLContext EGLAPIENTRY
 eglGetCurrentContext(void)
 {
    _EGLContext *ctx = _eglGetCurrentContext();
-   return _eglGetContextHandle(ctx);
+   EGLContext ret;
+
+   ret = _eglGetContextHandle(ctx);
+
+   return _EGL_SUCCESS(NULL, ret);
 }
 
 
@@ -680,10 +741,12 @@ EGLSurface EGLAPIENTRY
 eglGetCurrentSurface(EGLint readdraw)
 {
    _EGLContext *ctx = _eglGetCurrentContext();
+   EGLint err = EGL_SUCCESS;
    _EGLSurface *surf;
+   EGLSurface ret;
 
    if (!ctx)
-      return EGL_NO_SURFACE;
+      return _EGL_SUCCESS(NULL, EGL_NO_SURFACE);
 
    switch (readdraw) {
    case EGL_DRAW:
@@ -693,12 +756,14 @@ eglGetCurrentSurface(EGLint readdraw)
       surf = ctx->ReadSurface;
       break;
    default:
-      _eglError(EGL_BAD_PARAMETER, __FUNCTION__);
       surf = NULL;
+      err = EGL_BAD_PARAMETER;
       break;
    }
 
-   return _eglGetSurfaceHandle(surf);
+   ret = _eglGetSurfaceHandle(surf);
+
+   return _EGL_ERROR(NULL, err, ret);
 }
 
 
@@ -742,27 +807,34 @@ eglGetProcAddress(const char *procname)
       { NULL, NULL }
    };
    EGLint i;
+   _EGLProc ret;
 
    if (!procname)
-      return NULL;
+      return _EGL_SUCCESS(NULL, NULL);
+
+   ret = NULL;
    if (strncmp(procname, "egl", 3) == 0) {
       for (i = 0; egl_functions[i].name; i++) {
-         if (strcmp(egl_functions[i].name, procname) == 0)
-            return egl_functions[i].function;
+         if (strcmp(egl_functions[i].name, procname) == 0) {
+            ret = egl_functions[i].function;
+            break;
+         }
       }
    }
+   if (ret)
+      return _EGL_SUCCESS(NULL, ret);
 
    _eglPreloadDrivers();
 
    /* now loop over drivers to query their procs */
    for (i = 0; i < _eglGlobal.NumDrivers; i++) {
       _EGLDriver *drv = _eglGlobal.Drivers[i];
-      _EGLProc p = drv->API.GetProcAddress(drv, procname);
-      if (p)
-         return p;
+      ret = drv->API.GetProcAddress(drv, procname);
+      if (ret)
+         break;
    }
 
-   return NULL;
+   return _EGL_SUCCESS(NULL, ret);
 }
 
 
@@ -781,10 +853,13 @@ eglChooseModeMESA(EGLDisplay dpy, EGLScreenMESA screen,
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLScreen *scrn = _eglLookupScreen(screen, disp);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE);
-   return drv->API.ChooseModeMESA(drv, disp, scrn, attrib_list,
-                                  modes, modes_size, num_modes);
+   ret = drv->API.ChooseModeMESA(drv, disp, scrn, attrib_list,
+         modes, modes_size, num_modes);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -795,9 +870,12 @@ eglGetModesMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLModeMESA *modes,
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLScreen *scrn = _eglLookupScreen(screen, disp);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE);
-   return drv->API.GetModesMESA(drv, disp, scrn, modes, mode_size, num_mode);
+   ret = drv->API.GetModesMESA(drv, disp, scrn, modes, mode_size, num_mode);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -808,9 +886,12 @@ eglGetModeAttribMESA(EGLDisplay dpy, EGLModeMESA mode,
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLMode *m = _eglLookupMode(mode, disp);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_MODE(disp, m, EGL_FALSE);
-   return drv->API.GetModeAttribMESA(drv, disp, m, attribute, value);
+   ret = drv->API.GetModeAttribMESA(drv, disp, m, attribute, value);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -822,15 +903,16 @@ eglCopyContextMESA(EGLDisplay dpy, EGLContext source, EGLContext dest,
    _EGLContext *source_context = _eglLookupContext(source, disp);
    _EGLContext *dest_context = _eglLookupContext(dest, disp);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_CONTEXT(disp, source_context, EGL_FALSE);
-   if (!dest_context) {
-      _eglError(EGL_BAD_CONTEXT, __FUNCTION__);
-      return EGL_FALSE;
-   }
+   if (!dest_context)
+      return _EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_FALSE);
 
-   return drv->API.CopyContextMESA(drv, disp, source_context, dest_context,
-                                   mask);
+   ret = drv->API.CopyContextMESA(drv, disp,
+         source_context, dest_context, mask);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -840,10 +922,12 @@ eglGetScreensMESA(EGLDisplay dpy, EGLScreenMESA *screens,
 {
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
-   return drv->API.GetScreensMESA(drv, disp, screens,
-                                  max_screens, num_screens);
+   ret = drv->API.GetScreensMESA(drv, disp, screens, max_screens, num_screens);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -855,14 +939,14 @@ eglCreateScreenSurfaceMESA(EGLDisplay dpy, EGLConfig config,
    _EGLConfig *conf = _eglLookupConfig(config, disp);
    _EGLDriver *drv;
    _EGLSurface *surf;
+   EGLSurface ret;
 
    drv = _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE);
 
    surf = drv->API.CreateScreenSurfaceMESA(drv, disp, conf, attrib_list);
-   if (surf)
-      return _eglLinkSurface(surf, disp);
-   else
-      return EGL_NO_SURFACE;
+   ret = (surf) ? _eglLinkSurface(surf, disp) : EGL_NO_SURFACE;
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -875,14 +959,17 @@ eglShowScreenSurfaceMESA(EGLDisplay dpy, EGLint screen,
    _EGLSurface *surf = _eglLookupSurface(surface, disp);
    _EGLMode *m = _eglLookupMode(mode, disp);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE);
    if (!surf && surface != EGL_NO_SURFACE)
-      return _eglError(EGL_BAD_SURFACE, __FUNCTION__);
+      return _EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
    if (!m && mode != EGL_NO_MODE_MESA)
-      return _eglError(EGL_BAD_MODE_MESA, __FUNCTION__);
+      return _EGL_ERROR(disp, EGL_BAD_MODE_MESA, EGL_FALSE);
+
+   ret = drv->API.ShowScreenSurfaceMESA(drv, disp, scrn, surf, m);
 
-   return drv->API.ShowScreenSurfaceMESA(drv, disp, scrn, surf, m);
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -892,9 +979,12 @@ eglScreenPositionMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLint x, EGLint y)
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLScreen *scrn = _eglLookupScreen(screen, disp);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE);
-   return drv->API.ScreenPositionMESA(drv, disp, scrn, x, y);
+   ret = drv->API.ScreenPositionMESA(drv, disp, scrn, x, y);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -905,9 +995,12 @@ eglQueryScreenMESA(EGLDisplay dpy, EGLScreenMESA screen,
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLScreen *scrn = _eglLookupScreen(screen, disp);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE);
-   return drv->API.QueryScreenMESA(drv, disp, scrn, attribute, value);
+   ret = drv->API.QueryScreenMESA(drv, disp, scrn, attribute, value);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -919,14 +1012,14 @@ eglQueryScreenSurfaceMESA(EGLDisplay dpy, EGLScreenMESA screen,
    _EGLScreen *scrn = _eglLookupScreen((EGLScreenMESA) screen, disp);
    _EGLDriver *drv;
    _EGLSurface *surf;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE);
-
-   if (drv->API.QueryScreenSurfaceMESA(drv, disp, scrn, &surf) != EGL_TRUE)
-      surf = NULL;
-   if (surface)
+   ret = drv->API.QueryScreenSurfaceMESA(drv, disp, scrn, &surf);
+   if (ret && surface)
       *surface = _eglGetSurfaceHandle(surf);
-   return (surf != NULL);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -937,15 +1030,14 @@ eglQueryScreenModeMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLModeMESA *mode)
    _EGLScreen *scrn = _eglLookupScreen((EGLScreenMESA) screen, disp);
    _EGLDriver *drv;
    _EGLMode *m;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE);
-
-   if (drv->API.QueryScreenModeMESA(drv, disp, scrn, &m) != EGL_TRUE)
-      m = NULL;
-   if (mode)
+   ret = drv->API.QueryScreenModeMESA(drv, disp, scrn, &m);
+   if (ret && mode)
       *mode = m->Handle;
 
-   return (m != NULL);
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -955,9 +1047,12 @@ eglQueryModeStringMESA(EGLDisplay dpy, EGLModeMESA mode)
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLMode *m = _eglLookupMode(mode, disp);
    _EGLDriver *drv;
+   const char *ret;
 
    drv = _EGL_CHECK_MODE(disp, m, NULL);
-   return drv->API.QueryModeStringMESA(drv, disp, m);
+   ret = drv->API.QueryModeStringMESA(drv, disp, m);
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -988,13 +1083,14 @@ eglBindAPI(EGLenum api)
    _EGLThreadInfo *t = _eglGetCurrentThread();
 
    if (_eglIsCurrentThreadDummy())
-      return _eglError(EGL_BAD_ALLOC, "eglBindAPI");
+      return _EGL_ERROR(NULL, EGL_BAD_ALLOC, EGL_FALSE);
 
    if (!_eglIsApiValid(api))
-      return _eglError(EGL_BAD_PARAMETER, "eglBindAPI");
+      return _EGL_ERROR(NULL, EGL_BAD_PARAMETER, EGL_FALSE);
 
    t->CurrentAPIIndex = _eglConvertApiToIndex(api);
-   return EGL_TRUE;
+
+   return _EGL_SUCCESS(NULL, EGL_TRUE);
 }
 
 
@@ -1004,9 +1100,13 @@ eglBindAPI(EGLenum api)
 EGLenum
 eglQueryAPI(void)
 {
-   /* returns one of EGL_OPENGL_API, EGL_OPENGL_ES_API or EGL_OPENVG_API */
    _EGLThreadInfo *t = _eglGetCurrentThread();
-   return _eglConvertApiFromIndex(t->CurrentAPIIndex);
+   EGLenum ret;
+
+   /* returns one of EGL_OPENGL_API, EGL_OPENGL_ES_API or EGL_OPENVG_API */
+   ret = _eglConvertApiFromIndex(t->CurrentAPIIndex);
+
+   return _EGL_SUCCESS(NULL, ret);
 }
 
 
@@ -1019,15 +1119,15 @@ eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype,
    _EGLConfig *conf = _eglLookupConfig(config, disp);
    _EGLDriver *drv;
    _EGLSurface *surf;
+   EGLSurface ret;
 
    drv = _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE);
 
    surf = drv->API.CreatePbufferFromClientBuffer(drv, disp, buftype, buffer,
                                                  conf, attrib_list);
-   if (surf)
-      return _eglLinkSurface(surf, disp);
-   else
-      return EGL_NO_SURFACE;
+   ret = (surf) ? _eglLinkSurface(surf, disp) : EGL_NO_SURFACE;
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
@@ -1054,7 +1154,8 @@ eglReleaseThread(void)
    }
 
    _eglDestroyCurrentThread();
-   return EGL_TRUE;
+
+   return _EGL_SUCCESS(NULL, EGL_TRUE);
 }
 
 
@@ -1072,34 +1173,36 @@ eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target,
    _EGLContext *context = _eglLookupContext(ctx, disp);
    _EGLDriver *drv;
    _EGLImage *img;
+   EGLImageKHR ret;
 
    drv = _EGL_CHECK_DISPLAY(disp, EGL_NO_IMAGE_KHR);
-   if (!context && ctx != EGL_NO_CONTEXT) {
-      _eglError(EGL_BAD_CONTEXT, __FUNCTION__);
-      return EGL_NO_IMAGE_KHR;
-   }
+   if (!context && ctx != EGL_NO_CONTEXT)
+      return _EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_NO_IMAGE_KHR);
 
    img = drv->API.CreateImageKHR(drv,
          disp, context, target, buffer, attr_list);
-   if (img)
-      return _eglLinkImage(img, disp);
-   else
-      return EGL_NO_IMAGE_KHR;
+   ret = (img) ? _eglLinkImage(img, disp) : EGL_NO_IMAGE_KHR;
+
+   return _EGL_EVAL(disp, ret);
 }
 
 
-EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
+EGLBoolean
+eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
 {
    _EGLDisplay *disp = _eglLookupDisplay(dpy);
    _EGLImage *img = _eglLookupImage(image, disp);
    _EGLDriver *drv;
+   EGLBoolean ret;
 
    drv = _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
    if (!img)
-      return _eglError(EGL_BAD_PARAMETER, __FUNCTION__);
+      return _EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
 
    _eglUnlinkImage(img);
-   return drv->API.DestroyImageKHR(drv, disp, img);
+   ret = drv->API.DestroyImageKHR(drv, disp, img);
+
+   return _EGL_EVAL(disp, ret);
 }