Is there a standard way to query EGL error string?

Question

Currently my function to convert result of eglGetError() looks like this:

std::string eglErrorString(EGLint error)
{
    switch(error)
    {
    case EGL_SUCCESS: return "No error";
    case EGL_NOT_INITIALIZED: return "EGL not initialized or failed to initialize";
    case EGL_BAD_ACCESS: return "Resource inaccessible";
    case EGL_BAD_ALLOC: return "Cannot allocate resources";
    case EGL_BAD_ATTRIBUTE: return "Unrecognized attribute or attribute value";
    case EGL_BAD_CONTEXT: return "Invalid EGL context";
    case EGL_BAD_CONFIG: return "Invalid EGL frame buffer configuration";
    case EGL_BAD_CURRENT_SURFACE: return "Current surface is no longer valid";
    case EGL_BAD_DISPLAY: return "Invalid EGL display";
    case EGL_BAD_SURFACE: return "Invalid surface";
    case EGL_BAD_MATCH: return "Inconsistent arguments";
    case EGL_BAD_PARAMETER: return "Invalid argument";
    case EGL_BAD_NATIVE_PIXMAP: return "Invalid native pixmap";
    case EGL_BAD_NATIVE_WINDOW: return "Invalid native window";
    case EGL_CONTEXT_LOST: return "Context lost";
    }
    return "Unknown error "+to_hex_string(int(error));
}

But for e.g. OpenGL itself there's gluErrorString(), which saves us from having to manually maintain the list of errors.

Is there something like gluErrorString() for EGL?

`gluErrorString` is only available if you're using GLU. It's not really relevant to modern code. In fact, it doesn't handle some of the more recent errors that `glGetError` can return, like invalid framebuffers or lost contexts. So it's better to just maintain errors manually. — Nicol Bolas, Jun 30 '16 at 15:11
@NicolBolas if you're sure of correctness of your words, why not put them into an answer? — Ruslan, Jun 30 '16 at 15:23
Your question was about whether there is a function like `gluErrorString` for EGL. My comment was to say that you shouldn't bother and just maintain your own. While that solves your problem, it doesn't really answer the question you asked. For all I know, there could be some standard `egluErrorString` function out there. That would be an answer to your question. — Nicol Bolas, Jun 30 '16 at 15:32

score 2 · Accepted Answer · answered Jul 01 '16 at 08:26

Definitely not as part of EGL itself. And I don't think it should be there. EGL is a low level window system interface. Producing user readable strings is really not its job.

You may think that having a function that produces a few strings is trivial and harmless. But since this would be user readable strings, you would almost have to think about internationalization. Meaning that you could get the strings in various languages, including ones that use different character sets. So what looked simple suddenly becomes much more complex. And at least in my opinion, supporting only English strings would be very arbitrary.

Even more importantly, translating error codes to strings is not conceptually part of an API that provides an interface to a window system. IMHO, these kinds of APIs should be minimal. In this case, it should provide exactly the functionality needed to interface with the window system, and nothing more.

Of course nobody stops you (or anybody else) from implementing a higher level library that provides this kind of functionality. That's exactly what GLU (which is where gluErrorString() came from) was for OpenGL. It provided some commonly used functionality layered on top of OpenGL.

The use of past tense when talking about GLU in the previous paragraph was deliberate. It's built on top of OpenGL functionality from a previous millennium.

Actually, I don't usually expect APIs to return localized strings. Most of them are useless for users anyway -- like what's a user to do if he knows that an "EGL_BAD_ATTRIBUTE" has happened? Instead, I use them for the log output -- and I don't need localization there. For APIs that use such enumerated values (which has diminished a but since C++ was invented), I usually add a function to turn them into strings for exactly that reason -- makes it easier for users (of the API) to put these values into logs, without having to maintain the string table themselves. — Christian Stieber, Feb 04 '19 at 11:17

genpfault · Answer 2 · 2019-12-17T02:29:40.043

Macro stringification can save you some typing:

#define CASE_STR( value ) case value: return #value; 
const char* eglGetErrorString( EGLint error )
{
    switch( error )
    {
    CASE_STR( EGL_SUCCESS             )
    CASE_STR( EGL_NOT_INITIALIZED     )
    CASE_STR( EGL_BAD_ACCESS          )
    CASE_STR( EGL_BAD_ALLOC           )
    CASE_STR( EGL_BAD_ATTRIBUTE       )
    CASE_STR( EGL_BAD_CONTEXT         )
    CASE_STR( EGL_BAD_CONFIG          )
    CASE_STR( EGL_BAD_CURRENT_SURFACE )
    CASE_STR( EGL_BAD_DISPLAY         )
    CASE_STR( EGL_BAD_SURFACE         )
    CASE_STR( EGL_BAD_MATCH           )
    CASE_STR( EGL_BAD_PARAMETER       )
    CASE_STR( EGL_BAD_NATIVE_PIXMAP   )
    CASE_STR( EGL_BAD_NATIVE_WINDOW   )
    CASE_STR( EGL_CONTEXT_LOST        )
    default: return "Unknown";
    }
}
#undef CASE_STR

Is there a standard way to query EGL error string?

2 Answers2

Linked