PUT_ALIASES(TYPE, FUNCNAME, __VA_ARGS__) \
HANDLER_WRAPPERS(graphics_feature, TYPE, FUNCNAME, __VA_ARGS__)
+#define FUNC_DECLAR_VOID(TYPE, FUNCNAME, ...) \
+ PUT_ALIASES(TYPE, FUNCNAME, __VA_ARGS__) \
+ HANDLER_WRAPPERS_VOID(graphics_feature, TYPE, FUNCNAME, __VA_ARGS__)
+
#define FUNC_DECLAR_NOARGS(TYPE, FUNCNAME) \
PUT_ALIASES(TYPE, FUNCNAME) \
HANDLER_WRAPPERS(graphics_feature, TYPE, FUNCNAME)
+#define FUNC_DECLAR_NOARGS_VOID(TYPE, FUNCNAME) \
+ PUT_ALIASES(TYPE, FUNCNAME) \
+ HANDLER_WRAPPERS_VOID(graphics_feature, TYPE, FUNCNAME)
+
#define BEFORE_EVAS_GL(FUNCNAME) \
DECLARE_VARIABLE_STANDARD_NORET; \
/* Evas open gl API functions */
-HANDLER_WRAPPERS(graphics_feature, void , evas_gl_free, Evas_GL *, evas_gl)
+HANDLER_WRAPPERS_VOID(graphics_feature, void , evas_gl_free, Evas_GL *, evas_gl)
{
typedef void (*methodType)(Evas_GL *evas_gl);
BEFORE_EVAS_GL(evas_gl_free);
voidp_to_uint64(evas_gl));
}
-HANDLER_WRAPPERS(graphics_feature, void , evas_gl_config_free, Evas_GL_Config *, cfg)
+HANDLER_WRAPPERS_VOID(graphics_feature, void , evas_gl_config_free,
+ Evas_GL_Config *, cfg)
{
typedef void (*methodType)(Evas_GL_Config *cfg);
BEFORE_EVAS_GL(evas_gl_config_free);
voidp_to_uint64(cfg));
}
-HANDLER_WRAPPERS(graphics_feature, void , evas_gl_surface_destroy, Evas_GL *, evas_gl,
- Evas_GL_Surface *, surf)
+HANDLER_WRAPPERS_VOID(graphics_feature, void , evas_gl_surface_destroy,
+ Evas_GL *, evas_gl, Evas_GL_Surface *, surf)
{
typedef void (*methodType)(Evas_GL *evas_gl, Evas_GL_Surface *surf);
BEFORE_EVAS_GL(evas_gl_surface_destroy);
voidp_to_uint64(evas_gl), voidp_to_uint64(surf));
}
-HANDLER_WRAPPERS(graphics_feature, void , evas_gl_context_destroy, Evas_GL *, evas_gl,
- Evas_GL_Context *, ctx)
+HANDLER_WRAPPERS_VOID(graphics_feature, void , evas_gl_context_destroy,
+ Evas_GL *, evas_gl, Evas_GL_Context *, ctx)
{
typedef void (*methodType)(Evas_GL *evas_gl, Evas_GL_Context *ctx);
BEFORE_EVAS_GL(evas_gl_context_destroy);
return ret;
}
-DECLARE(void, glActiveTexture, GLenum, texture)
+DECLARE_VOID(void, glActiveTexture, GLenum, texture)
{
TYPEDEF(void (*methodType)(GLenum));
BEFORE(glActiveTexture);
(uint64_t)(texture));
}
-DECLARE(void, glAttachShader, GLuint, program, GLuint, shader)
+DECLARE_VOID(void, glAttachShader, GLuint, program, GLuint, shader)
{
TYPEDEF(void (*methodType)(GLuint, GLuint));
BEFORE(glAttachShader);
// B 12
// ==================================================================
-DECLARE(void, glBindAttribLocation, GLuint, program, GLuint, index, const char *, name)
+DECLARE_VOID(void, glBindAttribLocation, GLuint, program, GLuint, index, const char *, name)
{
TYPEDEF(void (*methodType)(GLuint, GLuint, const char *));
BEFORE(glBindAttribLocation);
program, index, name);
}
-DECLARE(void, glBindBuffer, GLenum, target, GLuint, buffer)
+DECLARE_VOID(void, glBindBuffer, GLenum, target, GLuint, buffer)
{
char context_value[MAX_GL_CONTEXT_VALUE_SIZE] = {0,};
(uint64_t)(target), buffer);
}
-DECLARE(void, glBindFramebuffer, GLenum, target, GLuint, framebuffer)
+DECLARE_VOID(void, glBindFramebuffer, GLenum, target, GLuint, framebuffer)
{
TYPEDEF(void (*methodType)(GLenum, GLuint));
BEFORE(glBindFramebuffer);
(uint64_t)(target), framebuffer);
}
-DECLARE(void, glBindRenderbuffer, GLenum, target, GLuint, renderbuffer)
+DECLARE_VOID(void, glBindRenderbuffer, GLenum, target, GLuint, renderbuffer)
{
TYPEDEF(void (*methodType)(GLenum, GLuint));
BEFORE(glBindRenderbuffer);
(uint64_t)(target), renderbuffer);
}
-DECLARE(void, glBindTexture, GLenum, target, GLuint, texture)
+DECLARE_VOID(void, glBindTexture, GLenum, target, GLuint, texture)
{
TYPEDEF(void (*methodType)(GLenum, GLuint));
BEFORE(glBindTexture);
(uint64_t)(target), texture);
}
-DECLARE(void, glBlendColor, GLclampf, red, GLclampf, green, GLclampf, blue, GLclampf, alpha)
+DECLARE_VOID(void, glBlendColor, GLclampf, red, GLclampf, green, GLclampf, blue, GLclampf, alpha)
{
TYPEDEF(void (*methodType)(GLclampf, GLclampf, GLclampf, GLclampf));
BEFORE(glBlendColor);
red, green, blue, alpha);
}
-DECLARE(void, glBlendEquation, GLenum, mode)
+DECLARE_VOID(void, glBlendEquation, GLenum, mode)
{
TYPEDEF(void (*methodType)(GLenum));
BEFORE(glBlendEquation);
(uint64_t)(mode));
}
-DECLARE(void, glBlendEquationSeparate, GLenum, modeRGB, GLenum, modeAlpha)
+DECLARE_VOID(void, glBlendEquationSeparate, GLenum, modeRGB, GLenum, modeAlpha)
{
TYPEDEF(void (*methodType)(GLenum, GLenum));
BEFORE(glBlendEquationSeparate);
(uint64_t)(modeRGB), (uint64_t)(modeAlpha));
}
-DECLARE(void, glBlendFunc, GLenum, sfactor, GLenum, dfactor)
+DECLARE_VOID(void, glBlendFunc, GLenum, sfactor, GLenum, dfactor)
{
TYPEDEF(void (*methodType)(GLenum, GLenum));
BEFORE(glBlendFunc);
(uint64_t)(sfactor), (uint64_t)(dfactor));
}
-DECLARE(void, glBlendFuncSeparate, GLenum, srcRGB, GLenum, dstRGB, GLenum, srcAlpha,
+DECLARE_VOID(void, glBlendFuncSeparate, GLenum, srcRGB, GLenum, dstRGB, GLenum, srcAlpha,
GLenum, dstAlpha)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLenum, GLenum));
(uint64_t)(srcAlpha), (uint64_t)(dstAlpha));
}
-DECLARE(void, glBufferData, GLenum, target, GLsizeiptr, size, const GLvoid *, data,
+DECLARE_VOID(void, glBufferData, GLenum, target, GLsizeiptr, size, const GLvoid *, data,
GLenum, usage)
{
TYPEDEF(void (*methodType)(GLenum, GLsizeiptr, const GLvoid *, GLenum));
voidp_to_uint64(data), (uint64_t)(usage));
}
-DECLARE(void, glBufferSubData, GLenum, target, GLintptr, offset, GLsizeiptr, size,
+DECLARE_VOID(void, glBufferSubData, GLenum, target, GLintptr, offset, GLsizeiptr, size,
const GLvoid *, data)
{
TYPEDEF(void (*methodType)(GLenum, GLintptr, GLsizeiptr,
return ret;
}
-DECLARE(void, glClear, GLbitfield, mask)
+DECLARE_VOID(void, glClear, GLbitfield, mask)
{
TYPEDEF(void (*methodType)(GLbitfield));
BEFORE(glClear);
(uint64_t)(mask));
}
-DECLARE(void, glClearColor, GLclampf, red, GLclampf, green, GLclampf, blue, GLclampf, alpha)
+DECLARE_VOID(void, glClearColor, GLclampf, red, GLclampf, green, GLclampf, blue, GLclampf, alpha)
{
TYPEDEF(void (*methodType)(GLclampf, GLclampf, GLclampf, GLclampf));
BEFORE(glClearColor);
red, green, blue, alpha);
}
-DECLARE(void, glClearDepthf, GLclampf, depth)
+DECLARE_VOID(void, glClearDepthf, GLclampf, depth)
{
TYPEDEF(void (*methodType)(GLclampf));
BEFORE(glClearDepthf);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "f", depth);
}
-DECLARE(void, glClearStencil, GLint, s)
+DECLARE_VOID(void, glClearStencil, GLint, s)
{
TYPEDEF(void (*methodType)(GLint));
BEFORE(glClearStencil);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", s);
}
-DECLARE(void, glColorMask, GLboolean, red, GLboolean, green, GLboolean, blue,
+DECLARE_VOID(void, glColorMask, GLboolean, red, GLboolean, green, GLboolean, blue,
GLboolean, alpha)
{
TYPEDEF(void (*methodType)(GLboolean, GLboolean, GLboolean, GLboolean));
red, green, blue, alpha);
}
-DECLARE(void, glCompileShader, GLuint, shader)
+DECLARE_VOID(void, glCompileShader, GLuint, shader)
{
TYPEDEF(void (*methodType)(GLuint));
BEFORE(glCompileShader);
(uint64_t)(shader));
}
-DECLARE(void, glCompressedTexImage2D, GLenum, target, GLint, level, GLenum, internalformat,
+DECLARE_VOID(void, glCompressedTexImage2D, GLenum, target, GLint, level, GLenum, internalformat,
GLsizei, width, GLsizei, height, GLint, border,
GLsizei, imageSize, const GLvoid *, data)
{
voidp_to_uint64(data));
}
-DECLARE(void, glCompressedTexSubImage2D, GLenum, target, GLint, level, GLint, xoffset,
+DECLARE_VOID(void, glCompressedTexSubImage2D, GLenum, target, GLint, level, GLint, xoffset,
GLint, yoffset, GLsizei, width, GLsizei, height,
GLenum, format, GLsizei, imageSize,
const GLvoid *, data)
(uint64_t)(format), imageSize, voidp_to_uint64(data));
}
-DECLARE(void, glCopyTexImage2D, GLenum, target, GLint, level, GLenum, internalformat,
+DECLARE_VOID(void, glCopyTexImage2D, GLenum, target, GLint, level, GLenum, internalformat,
GLint, x, GLint, y, GLsizei, width, GLsizei, height,
GLint, border)
{
(uint64_t)(internalformat), x, y, width, height, border);
}
-DECLARE(void, glCopyTexSubImage2D, GLenum, target, GLint, level, GLint, xoffset,
+DECLARE_VOID(void, glCopyTexSubImage2D, GLenum, target, GLint, level, GLint, xoffset,
GLint, yoffset, GLint, x, GLint, y, GLsizei, width,
GLsizei, height)
{
return ret;
}
-DECLARE(void, glCullFace, GLenum, mode)
+DECLARE_VOID(void, glCullFace, GLenum, mode)
{
TYPEDEF(void (*methodType)(GLenum));
BEFORE(glCullFace);
// D 14
// ==================================================================
-DECLARE(void, glDeleteBuffers, GLsizei, n, const GLuint *, buffers)
+DECLARE_VOID(void, glDeleteBuffers, GLsizei, n, const GLuint *, buffers)
{
TYPEDEF(void (*methodType)(GLsizei, const GLuint *));
BEFORE(glDeleteBuffers);
n, voidp_to_uint64(buffers));
}
-DECLARE(void, glDeleteFramebuffers, GLsizei, n, const GLuint *, framebuffers)
+DECLARE_VOID(void, glDeleteFramebuffers, GLsizei, n, const GLuint *, framebuffers)
{
TYPEDEF(void (*methodType)(GLsizei, const GLuint *));
BEFORE(glDeleteFramebuffers);
n, voidp_to_uint64(framebuffers));
}
-DECLARE(void, glDeleteProgram, GLuint, program)
+DECLARE_VOID(void, glDeleteProgram, GLuint, program)
{
TYPEDEF(void (*methodType)(GLuint));
BEFORE(glDeleteProgram);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", program);
}
-DECLARE(void, glDeleteRenderbuffers, GLsizei, n, const GLuint *, renderbuffers)
+DECLARE_VOID(void, glDeleteRenderbuffers, GLsizei, n, const GLuint *, renderbuffers)
{
TYPEDEF(void (*methodType)(GLsizei, const GLuint *));
BEFORE(glDeleteRenderbuffers);
n, voidp_to_uint64(renderbuffers));
}
-DECLARE(void, glDeleteShader, GLuint, shader)
+DECLARE_VOID(void, glDeleteShader, GLuint, shader)
{
TYPEDEF(void (*methodType)(GLuint));
BEFORE(glDeleteShader);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", shader);
}
-DECLARE(void, glDeleteTextures, GLsizei, n, const GLuint *, textures)
+DECLARE_VOID(void, glDeleteTextures, GLsizei, n, const GLuint *, textures)
{
TYPEDEF(void (*methodType)(GLsizei, const GLuint *));
char buf[128] = "";
n, voidp_to_uint64(textures));
}
-DECLARE(void, glDepthFunc, GLenum, func)
+DECLARE_VOID(void, glDepthFunc, GLenum, func)
{
TYPEDEF(void (*methodType)(GLenum));
BEFORE(glDepthFunc);
(uint64_t)(func));
}
-DECLARE(void, glDepthMask, GLboolean, flag)
+DECLARE_VOID(void, glDepthMask, GLboolean, flag)
{
TYPEDEF(void (*methodType)(GLboolean));
BEFORE(glDepthMask);
(uint64_t)(flag));
}
-DECLARE(void, glDepthRangef, GLclampf, nearVal, GLclampf, farVal)
+DECLARE_VOID(void, glDepthRangef, GLclampf, nearVal, GLclampf, farVal)
{
TYPEDEF(void (*methodType)(GLclampf, GLclampf));
BEFORE(glDepthRangef);
nearVal, farVal);
}
-DECLARE(void, glDetachShader, GLuint, program, GLuint, shader)
+DECLARE_VOID(void, glDetachShader, GLuint, program, GLuint, shader)
{
TYPEDEF(void (*methodType)(GLuint, GLuint));
BEFORE(glDetachShader);
program, shader);
}
-DECLARE(void, glDisable, GLenum, cap)
+DECLARE_VOID(void, glDisable, GLenum, cap)
{
TYPEDEF(void (*methodType)(GLenum));
BEFORE(glDisable);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(cap));
}
-DECLARE(void, glDisableVertexAttribArray, GLuint, index)
+DECLARE_VOID(void, glDisableVertexAttribArray, GLuint, index)
{
TYPEDEF(void (*methodType)(GLuint));
BEFORE(glDisableVertexAttribArray);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", index);
}
-DECLARE(void, glDrawArrays, GLenum, mode, GLint, first, GLsizei, count)
+DECLARE_VOID(void, glDrawArrays, GLenum, mode, GLint, first, GLsizei, count)
{
TYPEDEF(void (*methodType)(GLenum, GLint, GLsizei));
BEFORE(glDrawArrays);
(uint64_t)(mode), first, count);
}
-DECLARE(void, glDrawElements, GLenum, mode, GLsizei, count, GLenum, type,
+DECLARE_VOID(void, glDrawElements, GLenum, mode, GLsizei, count, GLenum, type,
const GLvoid *, indices)
{
TYPEDEF(void (*methodType)(GLenum, GLsizei, GLenum, const GLvoid *));
// E 2
// ==================================================================
-DECLARE(void, glEnable, GLenum, cap)
+DECLARE_VOID(void, glEnable, GLenum, cap)
{
TYPEDEF(void (*methodType)(GLenum));
BEFORE(glEnable);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(cap));
}
-DECLARE(void, glEnableVertexAttribArray, GLuint, index)
+DECLARE_VOID(void, glEnableVertexAttribArray, GLuint, index)
{
TYPEDEF(void (*methodType)(GLuint));
BEFORE(glEnableVertexAttribArray);
// F 5
// ==================================================================
-DECLARE_NOARGS(void, glFinish)
+DECLARE_NOARGS_VOID(void, glFinish)
{
TYPEDEF(void (*methodType)(void));
BEFORE(glFinish);
AFTER_NO_PARAM('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "");
}
-DECLARE_NOARGS(void, glFlush)
+DECLARE_NOARGS_VOID(void, glFlush)
{
TYPEDEF(void (*methodType)(void));
BEFORE(glFlush);
AFTER_NO_PARAM('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "");
}
-DECLARE(void, glFramebufferRenderbuffer, GLenum, target, GLenum, attachment,
+DECLARE_VOID(void, glFramebufferRenderbuffer, GLenum, target, GLenum, attachment,
GLenum, renderbuffertarget, GLuint, renderbuffer)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLenum, GLuint));
(uint64_t)(renderbuffertarget), renderbuffer);
}
-DECLARE(void, glFramebufferTexture2D, GLenum, target, GLenum, attachment, GLenum, textarget,
+DECLARE_VOID(void, glFramebufferTexture2D, GLenum, target, GLenum, attachment, GLenum, textarget,
GLuint, texture, GLint, level)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLenum, GLuint, GLint));
(uint64_t)(textarget), texture, level);
}
-DECLARE(void, glFrontFace, GLenum, mode)
+DECLARE_VOID(void, glFrontFace, GLenum, mode)
{
TYPEDEF(void (*methodType)(GLenum));
BEFORE(glFrontFace);
// G 31
// ==================================================================
-DECLARE(void, glGenBuffers, GLsizei, n, GLuint *, buffers)
+DECLARE_VOID(void, glGenBuffers, GLsizei, n, GLuint *, buffers)
{
TYPEDEF(void (*methodType)(GLsizei, GLuint *));
char buf[128] = "";
n, voidp_to_uint64(buffers));
}
-DECLARE(void, glGenFramebuffers, GLsizei, n, GLuint *, framebuffers)
+DECLARE_VOID(void, glGenFramebuffers, GLsizei, n, GLuint *, framebuffers)
{
TYPEDEF(void (*methodType)(GLsizei, GLuint *));
BEFORE(glGenFramebuffers);
n, voidp_to_uint64(framebuffers));
}
-DECLARE(void, glGenRenderbuffers, GLsizei, n, GLuint *, renderbuffers)
+DECLARE_VOID(void, glGenRenderbuffers, GLsizei, n, GLuint *, renderbuffers)
{
TYPEDEF(void (*methodType)(GLsizei, GLuint *));
BEFORE(glGenRenderbuffers);
n, voidp_to_uint64(renderbuffers));
}
-DECLARE(void, glGenTextures, GLsizei, n, GLuint *, textures)
+DECLARE_VOID(void, glGenTextures, GLsizei, n, GLuint *, textures)
{
TYPEDEF(void (*methodType)(GLsizei, GLuint *));
char buf[128] = "";
n, voidp_to_uint64(textures));
}
-DECLARE(void, glGenerateMipmap, GLenum, target)
+DECLARE_VOID(void, glGenerateMipmap, GLenum, target)
{
TYPEDEF(void (*methodType)(GLenum));
BEFORE(glGenerateMipmap);
}
//lsh_get
-DECLARE(void, glGetBooleanv, GLenum, pname, GLboolean *, params)
+DECLARE_VOID(void, glGetBooleanv, GLenum, pname, GLboolean *, params)
{
TYPEDEF(void (*methodType)(GLenum, GLboolean *));
BEFORE(glGetBooleanv);
}
//lsh_get
-DECLARE(void, glGetFloatv, GLenum, pname, GLfloat *, params)
+DECLARE_VOID(void, glGetFloatv, GLenum, pname, GLfloat *, params)
{
TYPEDEF(void (*methodType)(GLenum, GLfloat *));
BEFORE(glGetFloatv);
}
//lsh_get
-DECLARE(void, glGetIntegerv, GLenum, pname, GLint *, params)
+DECLARE_VOID(void, glGetIntegerv, GLenum, pname, GLint *, params)
{
TYPEDEF(void (*methodType)(GLenum, GLint *));
BEFORE(glGetIntegerv);
}
//lsh_get
-DECLARE(void, glGetActiveAttrib, GLuint, program, GLuint, index, GLsizei, bufSize,
+DECLARE_VOID(void, glGetActiveAttrib, GLuint, program, GLuint, index, GLsizei, bufSize,
GLsizei *, length, GLint *, size, GLenum *, type, char *, name)
{
TYPEDEF(void (*methodType)(GLuint, GLuint, GLsizei, GLsizei *, GLint *,
}
//lsh_get
-DECLARE(void, glGetActiveUniform, GLuint, program, GLuint, index, GLsizei, bufSize,
+DECLARE_VOID(void, glGetActiveUniform, GLuint, program, GLuint, index, GLsizei, bufSize,
GLsizei *, length, GLint *, size, GLenum *, type, char *, name)
{
TYPEDEF(void (*methodType)(GLuint, GLuint, GLsizei, GLsizei *, GLint *,
}
//lsh_get
-DECLARE(void, glGetAttachedShaders, GLuint, program, GLsizei, maxCount, GLsizei *, count,
+DECLARE_VOID(void, glGetAttachedShaders, GLuint, program, GLsizei, maxCount, GLsizei *, count,
GLuint *, shaders)
{
TYPEDEF(void (*methodType)(GLuint, GLsizei, GLsizei *, GLuint *));
}
//lsh_get
-DECLARE(void, glGetBufferParameteriv, GLenum, target, GLenum, value, GLint *, data)
+DECLARE_VOID(void, glGetBufferParameteriv, GLenum, target, GLenum, value, GLint *, data)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLint *));
BEFORE(glGetBufferParameteriv);
}
//lsh_get
-DECLARE(void, glGetFramebufferAttachmentParameteriv, GLenum, target, GLenum, attachment,
+DECLARE_VOID(void, glGetFramebufferAttachmentParameteriv, GLenum, target, GLenum, attachment,
GLenum, pname, GLint *, params)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLenum, GLint *));
}
//lsh_get
-DECLARE(void, glGetProgramInfoLog, GLuint, program, GLsizei, maxLength, GLsizei *, length,
+DECLARE_VOID(void, glGetProgramInfoLog, GLuint, program, GLsizei, maxLength, GLsizei *, length,
char *, infoLog)
{
TYPEDEF(void (*methodType)(GLuint, GLsizei, GLsizei *, char *));
}
//lsh_get
-DECLARE(void, glGetProgramiv, GLuint, program, GLenum, pname, GLint *, params)
+DECLARE_VOID(void, glGetProgramiv, GLuint, program, GLenum, pname, GLint *, params)
{
TYPEDEF(void (*methodType)(GLuint, GLenum, GLint *));
BEFORE(glGetProgramiv);
}
//lsh_get
-DECLARE(void, glGetRenderbufferParameteriv, GLenum, target, GLenum, pname, GLint *, params)
+DECLARE_VOID(void, glGetRenderbufferParameteriv, GLenum, target, GLenum, pname, GLint *, params)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLint *));
BEFORE(glGetRenderbufferParameteriv);
}
//lsh_get
-DECLARE(void, glGetShaderInfoLog, GLuint, shader, GLsizei, maxLength, GLsizei *, length,
+DECLARE_VOID(void, glGetShaderInfoLog, GLuint, shader, GLsizei, maxLength, GLsizei *, length,
char *, infoLog)
{
TYPEDEF(void (*methodType)(GLuint, GLsizei, GLsizei *, char *));
}
//lsh_get
-DECLARE(void, glGetShaderPrecisionFormat, GLenum, shaderType, GLenum, precisionType,
+DECLARE_VOID(void, glGetShaderPrecisionFormat, GLenum, shaderType, GLenum, precisionType,
GLint *, range, GLint *, precision)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLint *, GLint *));
}
//lsh_get
-DECLARE(void, glGetShaderSource, GLuint, shader, GLsizei, bufSize, GLsizei *, length,
+DECLARE_VOID(void, glGetShaderSource, GLuint, shader, GLsizei, bufSize, GLsizei *, length,
char *, source)
{
TYPEDEF(void (*methodType)(GLuint, GLsizei, GLsizei *, char *));
}
//lsh_get
-DECLARE(void, glGetShaderiv, GLuint, shader, GLenum, pname, GLint *, params)
+DECLARE_VOID(void, glGetShaderiv, GLuint, shader, GLenum, pname, GLint *, params)
{
TYPEDEF(void (*methodType)(GLuint, GLenum, GLint *));
BEFORE(glGetShaderiv);
}
//lsh_get
-DECLARE(void, glGetTexParameterfv, GLenum, target, GLenum, pname, GLfloat *, params)
+DECLARE_VOID(void, glGetTexParameterfv, GLenum, target, GLenum, pname, GLfloat *, params)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLfloat *));
BEFORE(glGetTexParameterfv);
}
//lsh_get
-DECLARE(void, glGetTexParameteriv, GLenum, target, GLenum, pname, GLint *, params)
+DECLARE_VOID(void, glGetTexParameteriv, GLenum, target, GLenum, pname, GLint *, params)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLint *));
BEFORE(glGetTexParameteriv);
}
//lsh_get
-DECLARE(void, glGetUniformfv, GLuint, program, GLint, location, GLfloat *, params)
+DECLARE_VOID(void, glGetUniformfv, GLuint, program, GLint, location, GLfloat *, params)
{
TYPEDEF(void (*methodType)(GLuint, GLuint, GLfloat *));
BEFORE(glGetUniformfv);
}
//lsh_get
-DECLARE(void, glGetUniformiv, GLuint, program, GLint, location, GLint *, params)
+DECLARE_VOID(void, glGetUniformiv, GLuint, program, GLint, location, GLint *, params)
{
TYPEDEF(void (*methodType)(GLuint, GLuint, GLint *));
BEFORE(glGetUniformiv);
}
//lsh_get
-DECLARE(void, glGetVertexAttribfv, GLuint, index, GLenum, pname, GLfloat *, params)
+DECLARE_VOID(void, glGetVertexAttribfv, GLuint, index, GLenum, pname, GLfloat *, params)
{
TYPEDEF(void (*methodType)(GLuint, GLenum, GLfloat *));
BEFORE(glGetVertexAttribfv);
}
//lsh_get
-DECLARE(void, glGetVertexAttribiv, GLuint, index, GLenum, pname, GLint *, params)
+DECLARE_VOID(void, glGetVertexAttribiv, GLuint, index, GLenum, pname, GLint *, params)
{
TYPEDEF(void (*methodType)(GLuint, GLenum, GLint *));
BEFORE(glGetVertexAttribiv);
}
//lsh_get
-DECLARE(void, glGetVertexAttribPointerv, GLuint, index, GLenum, pname, GLvoid **, pointer)
+DECLARE_VOID(void, glGetVertexAttribPointerv, GLuint, index, GLenum, pname, GLvoid **, pointer)
{
TYPEDEF(void (*methodType)(GLuint, GLenum, GLvoid **));
BEFORE(glGetVertexAttribPointerv);
// H 1
// ==================================================================
-DECLARE(void, glHint, GLenum, target, GLenum, mode)
+DECLARE_VOID(void, glHint, GLenum, target, GLenum, mode)
{
TYPEDEF(void (*methodType)(GLenum, GLenum));
BEFORE(glHint);
// L 2
// ==================================================================
-DECLARE(void, glLineWidth, GLfloat, width)
+DECLARE_VOID(void, glLineWidth, GLfloat, width)
{
TYPEDEF(void (*methodType)(GLfloat));
BEFORE(glLineWidth);
}
/* TODO refactor snprintf check*/
-DECLARE(void, glLinkProgram, GLuint, program)
+DECLARE_VOID(void, glLinkProgram, GLuint, program)
{
TYPEDEF(void (*methodType)(GLuint));
BEFORE(glLinkProgram);
// P 2
// ==================================================================
-DECLARE(void, glPixelStorei, GLenum, pname, GLint, param)
+DECLARE_VOID(void, glPixelStorei, GLenum, pname, GLint, param)
{
TYPEDEF(void (*methodType)(GLenum, GLint));
BEFORE(glPixelStorei);
(uint64_t)(pname), param);
}
-DECLARE(void, glPolygonOffset, GLfloat, factor, GLfloat, units)
+DECLARE_VOID(void, glPolygonOffset, GLfloat, factor, GLfloat, units)
{
TYPEDEF(void (*methodType)(GLfloat, GLfloat));
BEFORE(glPolygonOffset);
// ==================================================================
//lsh_get
-DECLARE(void, glReadPixels, GLint, x, GLint, y, GLsizei, width, GLsizei, height,
+DECLARE_VOID(void, glReadPixels, GLint, x, GLint, y, GLsizei, width, GLsizei, height,
GLenum, format, GLenum, type, GLvoid *, data)
{
TYPEDEF(void (*methodType)(GLint, GLint, GLsizei, GLsizei, GLenum,
(uint64_t)(format), (uint64_t)(type));
}
-DECLARE_NOARGS(void, glReleaseShaderCompiler)
+DECLARE_NOARGS_VOID(void, glReleaseShaderCompiler)
{
TYPEDEF(void (*methodType)(void));
BEFORE(glReleaseShaderCompiler);
AFTER_NO_PARAM('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "");
}
-DECLARE(void, glRenderbufferStorage, GLenum, target, GLenum, internalformat, GLsizei, width,
+DECLARE_VOID(void, glRenderbufferStorage, GLenum, target, GLenum, internalformat, GLsizei, width,
GLsizei, height)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLsizei, GLsizei));
// S 10
// ==================================================================
-DECLARE(void, glSampleCoverage, GLclampf, value, GLboolean, invert)
+DECLARE_VOID(void, glSampleCoverage, GLclampf, value, GLboolean, invert)
{
TYPEDEF(void (*methodType)(GLclampf, GLboolean));
BEFORE(glSampleCoverage);
value, (uint64_t)(invert));
}
-DECLARE(void, glScissor, GLint, x, GLint, y, GLsizei, width, GLsizei, height)
+DECLARE_VOID(void, glScissor, GLint, x, GLint, y, GLsizei, width, GLsizei, height)
{
TYPEDEF(void (*methodType)(GLint, GLint, GLsizei, GLsizei));
BEFORE(glScissor);
}
//lsh_param
-DECLARE(void, glShaderBinary, GLsizei, n, const GLuint *, shaders, GLenum, binaryformat,
+DECLARE_VOID(void, glShaderBinary, GLsizei, n, const GLuint *, shaders, GLenum, binaryformat,
const void *, binary, GLsizei, length)
{
TYPEDEF(void (*methodType)(GLsizei, const GLuint *, GLenum,
}
//lsh_param
-DECLARE(void, glShaderSource, GLuint, shader, GLsizei, count, const char **, string,
+DECLARE_VOID(void, glShaderSource, GLuint, shader, GLsizei, count, const char **, string,
const GLint *, length)
{
TYPEDEF(void (*methodType)(GLuint, GLsizei, const char **,
}
}
-DECLARE(void, glStencilFunc, GLenum, func, GLint, ref, GLuint, mask)
+DECLARE_VOID(void, glStencilFunc, GLenum, func, GLint, ref, GLuint, mask)
{
TYPEDEF(void (*methodType)(GLenum, GLint, GLint));
BEFORE(glStencilFunc);
(uint64_t)(func), ref, mask);
}
-DECLARE(void, glStencilFuncSeparate, GLenum, face, GLenum, func, GLint, ref, GLuint, mask)
+DECLARE_VOID(void, glStencilFuncSeparate, GLenum, face, GLenum, func, GLint, ref, GLuint, mask)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLint, GLuint));
BEFORE(glStencilFuncSeparate);
(uint64_t)(face), (uint64_t)(func), ref, mask);
}
-DECLARE(void, glStencilMask, GLuint, mask)
+DECLARE_VOID(void, glStencilMask, GLuint, mask)
{
TYPEDEF(void (*methodType)(GLuint));
BEFORE(glStencilMask);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", mask);
}
-DECLARE(void, glStencilMaskSeparate, GLenum, face, GLuint, mask)
+DECLARE_VOID(void, glStencilMaskSeparate, GLenum, face, GLuint, mask)
{
TYPEDEF(void (*methodType)(GLenum, GLuint));
BEFORE(glStencilMaskSeparate);
(uint64_t)(face), mask);
}
-DECLARE(void, glStencilOp, GLenum, sfail, GLenum, dpfail, GLenum, dppass)
+DECLARE_VOID(void, glStencilOp, GLenum, sfail, GLenum, dpfail, GLenum, dppass)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLenum));
BEFORE(glStencilOp);
(uint64_t)(dppass));
}
-DECLARE(void, glStencilOpSeparate, GLenum, face, GLenum, sfail, GLenum, dpfail,
+DECLARE_VOID(void, glStencilOpSeparate, GLenum, face, GLenum, sfail, GLenum, dpfail,
GLenum, dppass)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLenum, GLenum));
// T 6
// ==================================================================
-DECLARE(void, glTexImage2D, GLenum, target, GLint, level, GLenum, internalformat,
+DECLARE_VOID(void, glTexImage2D, GLenum, target, GLint, level, GLenum, internalformat,
GLsizei, width, GLsizei, height, GLint, border, GLenum, format,
GLenum, type, const GLvoid *, data)
{
voidp_to_uint64(data));
}
-DECLARE(void, glTexParameterf, GLenum, target, GLenum, pname, GLfloat, param)
+DECLARE_VOID(void, glTexParameterf, GLenum, target, GLenum, pname, GLfloat, param)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLfloat));
BEFORE(glTexParameterf);
(uint64_t)(target), (uint64_t)(pname), param);
}
-DECLARE(void, glTexParameterfv, GLenum, target, GLenum, pname, const GLfloat *, params)
+DECLARE_VOID(void, glTexParameterfv, GLenum, target, GLenum, pname, const GLfloat *, params)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, const GLfloat *));
BEFORE(glTexParameterfv);
}
}
-DECLARE(void, glTexParameteri, GLenum, target, GLenum, pname, GLint, param)
+DECLARE_VOID(void, glTexParameteri, GLenum, target, GLenum, pname, GLint, param)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLint));
BEFORE(glTexParameteri);
(uint64_t)(param));
}
-DECLARE(void, glTexParameteriv, GLenum, target, GLenum, pname, const GLint *, params)
+DECLARE_VOID(void, glTexParameteriv, GLenum, target, GLenum, pname, const GLint *, params)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, const GLint *));
BEFORE(glTexParameteriv);
}
}
-DECLARE(void, glTexSubImage2D, GLenum, target, GLint, level, GLint, xoffset, GLint, yoffset,
+DECLARE_VOID(void, glTexSubImage2D, GLenum, target, GLint, level, GLint, xoffset, GLint, yoffset,
GLsizei, width, GLsizei, height, GLenum, format, GLenum, type,
const GLvoid *, data)
{
// U 20
// ==================================================================
-DECLARE(void, glUniform1f, GLint, location, GLfloat, v0)
+DECLARE_VOID(void, glUniform1f, GLint, location, GLfloat, v0)
{
TYPEDEF(void (*methodType)(GLint, GLfloat));
BEFORE(glUniform1f);
location, v0);
}
-DECLARE(void, glUniform2f, GLint, location, GLfloat, v0, GLfloat, v1)
+DECLARE_VOID(void, glUniform2f, GLint, location, GLfloat, v0, GLfloat, v1)
{
TYPEDEF(void (*methodType)(GLint, GLfloat, GLfloat));
BEFORE(glUniform2f);
location, v0, v1);
}
-DECLARE(void, glUniform3f, GLint, location, GLfloat, v0, GLfloat, v1, GLfloat, v2)
+DECLARE_VOID(void, glUniform3f, GLint, location, GLfloat, v0, GLfloat, v1, GLfloat, v2)
{
TYPEDEF(void (*methodType)(GLint, GLfloat, GLfloat, GLfloat));
BEFORE(glUniform3f);
location, v0, v1, v2);
}
-DECLARE(void, glUniform4f, GLint, location, GLfloat, v0, GLfloat, v1, GLfloat, v2, GLfloat, v3)
+DECLARE_VOID(void, glUniform4f, GLint, location, GLfloat, v0, GLfloat, v1, GLfloat, v2, GLfloat, v3)
{
TYPEDEF(void (*methodType)(GLint, GLfloat, GLfloat, GLfloat, GLfloat));
BEFORE(glUniform4f);
location, v0, v1, v2, v3);
}
-DECLARE(void, glUniform1fv, GLint, location, GLsizei, count, const GLfloat *, value)
+DECLARE_VOID(void, glUniform1fv, GLint, location, GLsizei, count, const GLfloat *, value)
{
TYPEDEF(void (*methodType)(GLint, GLsizei, const GLfloat *));
BEFORE(glUniform1fv);
location, count, count * 1, voidp_to_uint64(value));
}
-DECLARE(void, glUniform2fv, GLint, location, GLsizei, count, const GLfloat *, value)
+DECLARE_VOID(void, glUniform2fv, GLint, location, GLsizei, count, const GLfloat *, value)
{
TYPEDEF(void (*methodType)(GLint, GLsizei, const GLfloat *));
BEFORE(glUniform2fv);
location, count, count * 2, voidp_to_uint64(value));
}
-DECLARE(void, glUniform3fv, GLint, location, GLsizei, count, const GLfloat *, value)
+DECLARE_VOID(void, glUniform3fv, GLint, location, GLsizei, count, const GLfloat *, value)
{
TYPEDEF(void (*methodType)(GLint, GLsizei, const GLfloat *));
BEFORE(glUniform3fv);
location, count, count * 3, voidp_to_uint64(value));
}
-DECLARE(void, glUniform4fv, GLint, location, GLsizei, count, const GLfloat *, value)
+DECLARE_VOID(void, glUniform4fv, GLint, location, GLsizei, count, const GLfloat *, value)
{
TYPEDEF(void (*methodType)(GLint, GLsizei, const GLfloat *));
BEFORE(glUniform4fv);
location, count, count * 4, voidp_to_uint64(value));
}
-DECLARE(void, glUniform1i, GLint, location, GLint, v0)
+DECLARE_VOID(void, glUniform1i, GLint, location, GLint, v0)
{
TYPEDEF(void (*methodType)(GLint, GLint));
BEFORE(glUniform1i);
location, v0);
}
-DECLARE(void, glUniform2i, GLint, location, GLint, v0, GLint, v1)
+DECLARE_VOID(void, glUniform2i, GLint, location, GLint, v0, GLint, v1)
{
TYPEDEF(void (*methodType)(GLint, GLint, GLint));
BEFORE(glUniform2i);
location, v0, v1);
}
-DECLARE(void, glUniform3i, GLint, location, GLint, v0, GLint, v1, GLint, v2)
+DECLARE_VOID(void, glUniform3i, GLint, location, GLint, v0, GLint, v1, GLint, v2)
{
TYPEDEF(void (*methodType)(GLint, GLint, GLint, GLint));
BEFORE(glUniform3i);
location, v0, v1, v2);
}
-DECLARE(void, glUniform4i, GLint, location, GLint, v0, GLint, v1, GLint, v2, GLint, v3)
+DECLARE_VOID(void, glUniform4i, GLint, location, GLint, v0, GLint, v1, GLint, v2, GLint, v3)
{
TYPEDEF(void (*methodType)(GLint, GLint, GLint, GLint, GLint));
BEFORE(glUniform4i);
location, v0, v1, v2, v3);
}
-DECLARE(void, glUniform1iv, GLint, location, GLsizei, count, const GLint *, value)
+DECLARE_VOID(void, glUniform1iv, GLint, location, GLsizei, count, const GLint *, value)
{
TYPEDEF(void (*methodType)(GLint, GLsizei, const GLint *));
BEFORE(glUniform1iv);
location, count, count * 1, voidp_to_uint64(value));
}
-DECLARE(void, glUniform2iv, GLint, location, GLsizei, count, const GLint *, value)
+DECLARE_VOID(void, glUniform2iv, GLint, location, GLsizei, count, const GLint *, value)
{
TYPEDEF(void (*methodType)(GLint, GLsizei, const GLint *));
BEFORE(glUniform2iv);
location, count, count * 2, voidp_to_uint64(value));
}
-DECLARE(void, glUniform3iv, GLint, location, GLsizei, count, const GLint *, value)
+DECLARE_VOID(void, glUniform3iv, GLint, location, GLsizei, count, const GLint *, value)
{
TYPEDEF(void (*methodType)(GLint, GLsizei, const GLint *));
BEFORE(glUniform3iv);
location, count, count * 3, voidp_to_uint64(value));
}
-DECLARE(void, glUniform4iv, GLint, location, GLsizei, count, const GLint *, value)
+DECLARE_VOID(void, glUniform4iv, GLint, location, GLsizei, count, const GLint *, value)
{
TYPEDEF(void (*methodType)(GLint, GLsizei, const GLint *));
BEFORE(glUniform4iv);
location, count, count * 4, voidp_to_uint64(value));
}
-DECLARE(void, glUniformMatrix2fv, GLint, location, GLsizei, count, GLboolean, transpose,
+DECLARE_VOID(void, glUniformMatrix2fv, GLint, location, GLsizei, count, GLboolean, transpose,
const GLfloat *, value)
{
TYPEDEF(void (*methodType)(GLint, GLsizei, GLboolean, const GLfloat *));
voidp_to_uint64(value));
}
-DECLARE(void, glUniformMatrix3fv, GLint, location, GLsizei, count, GLboolean, transpose,
+DECLARE_VOID(void, glUniformMatrix3fv, GLint, location, GLsizei, count, GLboolean, transpose,
const GLfloat *, value)
{
TYPEDEF(void (*methodType)(GLint, GLsizei, GLboolean, const GLfloat *));
voidp_to_uint64(value));
}
-DECLARE(void, glUniformMatrix4fv, GLint, location, GLsizei, count, GLboolean, transpose,
+DECLARE_VOID(void, glUniformMatrix4fv, GLint, location, GLsizei, count, GLboolean, transpose,
const GLfloat *, value)
{
TYPEDEF(void (*methodType)(GLint, GLsizei, GLboolean, const GLfloat *));
voidp_to_uint64(value));
}
-DECLARE(void, glUseProgram, GLuint, program)
+DECLARE_VOID(void, glUseProgram, GLuint, program)
{
TYPEDEF(void (*methodType)(GLuint));
BEFORE(glUseProgram);
// V 7
// ==================================================================
-DECLARE(void, glValidateProgram, GLuint, program)
+DECLARE_VOID(void, glValidateProgram, GLuint, program)
{
TYPEDEF(void (*methodType)(GLuint));
BEFORE(glValidateProgram);
program);
}
-DECLARE(void, glVertexAttrib1f, GLuint, index, GLfloat, v0)
+DECLARE_VOID(void, glVertexAttrib1f, GLuint, index, GLfloat, v0)
{
TYPEDEF(void (*methodType)(GLuint, GLfloat));
BEFORE(glVertexAttrib1f);
index, v0);
}
-DECLARE(void, glVertexAttrib2f, GLuint, index, GLfloat, v0, GLfloat, v1)
+DECLARE_VOID(void, glVertexAttrib2f, GLuint, index, GLfloat, v0, GLfloat, v1)
{
TYPEDEF(void (*methodType)(GLuint, GLfloat, GLfloat));
BEFORE(glVertexAttrib2f);
index, v0, v1);
}
-DECLARE(void, glVertexAttrib3f, GLuint, index, GLfloat, v0, GLfloat, v1, GLfloat, v2)
+DECLARE_VOID(void, glVertexAttrib3f, GLuint, index, GLfloat, v0, GLfloat, v1, GLfloat, v2)
{
TYPEDEF(void (*methodType)(GLuint, GLfloat, GLfloat, GLfloat));
BEFORE(glVertexAttrib3f);
index, v0, v1, v2);
}
-DECLARE(void, glVertexAttrib4f, GLuint, index, GLfloat, v0, GLfloat, v1, GLfloat, v2,
+DECLARE_VOID(void, glVertexAttrib4f, GLuint, index, GLfloat, v0, GLfloat, v1, GLfloat, v2,
GLfloat, v3)
{
TYPEDEF(void (*methodType)(GLuint, GLfloat, GLfloat, GLfloat, GLfloat));
index, v0, v1, v2, v3);
}
-DECLARE(void, glVertexAttrib1fv, GLuint, index, const GLfloat *, v)
+DECLARE_VOID(void, glVertexAttrib1fv, GLuint, index, const GLfloat *, v)
{
TYPEDEF(void (*methodType)(GLuint, const GLfloat *));
BEFORE(glVertexAttrib1fv);
"dp", index, voidp_to_uint64(v));
}
-DECLARE(void, glVertexAttrib2fv, GLuint, index, const GLfloat *, v)
+DECLARE_VOID(void, glVertexAttrib2fv, GLuint, index, const GLfloat *, v)
{
TYPEDEF(void (*methodType)(GLuint, const GLfloat *));
BEFORE(glVertexAttrib2fv);
"dp", index, voidp_to_uint64(v));
}
-DECLARE(void, glVertexAttrib3fv, GLuint, index, const GLfloat *, v)
+DECLARE_VOID(void, glVertexAttrib3fv, GLuint, index, const GLfloat *, v)
{
TYPEDEF(void (*methodType)(GLuint, const GLfloat *));
BEFORE(glVertexAttrib3fv);
"dp", index, voidp_to_uint64(v));
}
-DECLARE(void, glVertexAttrib4fv, GLuint, index, const GLfloat *, v)
+DECLARE_VOID(void, glVertexAttrib4fv, GLuint, index, const GLfloat *, v)
{
TYPEDEF(void (*methodType)(GLuint, const GLfloat *));
BEFORE(glVertexAttrib4fv);
"dp", index, voidp_to_uint64(v));
}
-DECLARE(void, glVertexAttribPointer, GLuint, index, GLint, size, GLenum, type,
+DECLARE_VOID(void, glVertexAttribPointer, GLuint, index, GLint, size, GLenum, type,
GLboolean, normalized, GLsizei, stride,
const GLvoid *, pointer)
{
stride, voidp_to_uint64(pointer));
}
-DECLARE(void, glViewport, GLint, x, GLint, y, GLsizei, width, GLsizei, height)
+DECLARE_VOID(void, glViewport, GLint, x, GLint, y, GLsizei, width, GLsizei, height)
{
TYPEDEF(void (*methodType)(GLint, GLint, GLsizei, GLsizei));
#define DECLARE FUNC_DECLAR
#define DECLARE_NOARGS FUNC_DECLAR_NOARGS
+#define DECLARE_VOID FUNC_DECLAR_VOID
+#define DECLARE_NOARGS_VOID FUNC_DECLAR_NOARGS_VOID
#define REAL_NAME(func) PROBE_NAME(func)
#define BEFORE BEFORE_GL2_ORIG
#define DECLARE(TYPE, FUNCNAME, ...) \
TYPE REAL_NAME(FUNCNAME)( FUNC_TA(__VA_ARGS__) )
#define DECLARE_NOARGS(TYPE, FUNCNAME) TYPE REAL_NAME(FUNCNAME)()
+#define DECLARE_VOID(TYPE, FUNCNAME, ...) \
+ TYPE REAL_NAME(FUNCNAME)(FUNC_TA(__VA_ARGS__))
+#define DECLARE_NOARGS_VOID(TYPE, FUNCNAME) TYPE REAL_NAME(FUNCNAME)()
#define REAL_NAME(func) CONCAT(__local_, func)
#define DECLARE FUNC_DECLAR
#define DECLARE_NOARGS FUNC_DECLAR_NOARGS
+#define DECLARE_VOID FUNC_DECLAR_VOID
+#define DECLARE_NOARGS_VOID FUNC_DECLAR_NOARGS_VOID
#define REAL_NAME(func) PROBE_NAME(func)
#define CALL_ORIG(func, ...) /* CALL_ORIG */ func##p(__VA_ARGS__)
-DECLARE(void, glVertexAttribI1i, GLuint, index, GLint, x)
+DECLARE_VOID(void, glVertexAttribI1i, GLuint, index, GLint, x)
{
TYPEDEF(void (*methodType)(GLuint, GLint));
BEFORE(glVertexAttribI1i);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd", index, x);
}
-DECLARE(void, glVertexAttribI2i, GLuint, index, GLint, x, GLint, y)
+DECLARE_VOID(void, glVertexAttribI2i, GLuint, index, GLint, x, GLint, y)
{
TYPEDEF(void (*methodType)(GLuint, GLint, GLint));
BEFORE(glVertexAttribI2i);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddd", index, x, y);
}
-DECLARE(void, glVertexAttribI3i, GLuint, index, GLint, x, GLint, y, GLint, z)
+DECLARE_VOID(void, glVertexAttribI3i, GLuint, index, GLint, x, GLint, y, GLint, z)
{
TYPEDEF(void (*methodType)(GLuint, GLint, GLint, GLint));
BEFORE(glVertexAttribI3i);
y, z);
}
-DECLARE(void, glVertexAttribI4i, GLuint, index, GLint, x, GLint, y, GLint, z,
+DECLARE_VOID(void, glVertexAttribI4i, GLuint, index, GLint, x, GLint, y, GLint, z,
GLint, w)
{
TYPEDEF(void (*methodType)(GLuint, GLint, GLint, GLint, GLint));
y, z, w);
}
-DECLARE(void, glVertexAttribI1ui, GLuint, index, GLuint, x)
+DECLARE_VOID(void, glVertexAttribI1ui, GLuint, index, GLuint, x)
{
TYPEDEF(void (*methodType)(GLuint, GLuint));
BEFORE(glVertexAttribI1ui);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd", index, x);
}
-DECLARE(void, glUniformBlockBinding, GLuint, program, GLuint, UniformBlockIndex,
+DECLARE_VOID(void, glUniformBlockBinding, GLuint, program, GLuint, UniformBlockIndex,
GLuint, uniformBlockBinding)
{
TYPEDEF(void (*methodType)(GLuint, GLuint, GLuint));
DECLARE_GL_DEFAULT_VOID(void, glUniformMatrix3x4fv, "dxbp", GLint, location, GLsizei, count, GLboolean, transpose, const GLfloat *, value)
DECLARE_GL_DEFAULT_VOID(void, glUniformMatrix4x3fv, "dxbp", GLint, location, GLsizei, count, GLboolean, transpose, const GLfloat *, value)
-DECLARE(void, glVertexAttribI2ui, GLuint, index, GLuint, x, GLuint, y)
+DECLARE_VOID(void, glVertexAttribI2ui, GLuint, index, GLuint, x, GLuint, y)
{
TYPEDEF(void (*methodType)(GLuint, GLuint, GLuint));
BEFORE(glVertexAttribI2ui);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddd", index, x, y);
}
-DECLARE(void, glVertexAttribI3ui, GLuint, index, GLuint, x, GLuint, y, GLuint, z)
+DECLARE_VOID(void, glVertexAttribI3ui, GLuint, index, GLuint, x, GLuint, y, GLuint, z)
{
TYPEDEF(void (*methodType)(GLuint, GLuint, GLuint, GLuint));
BEFORE(glVertexAttribI3ui);
}
-DECLARE(void, glVertexAttribI4ui, GLuint, index, GLuint, x, GLuint, y, GLuint, z,
+DECLARE_VOID(void, glVertexAttribI4ui, GLuint, index, GLuint, x, GLuint, y, GLuint, z,
GLuint, w)
{
TYPEDEF(void (*methodType)(GLuint, GLuint, GLuint, GLuint, GLuint));
y, z, w);
}
-DECLARE(void, glVertexAttribI1iv, GLuint, index, const GLint *, v)
+DECLARE_VOID(void, glVertexAttribI1iv, GLuint, index, const GLint *, v)
{
TYPEDEF(void (*methodType)(GLuint, const GLint*));
BEFORE(glVertexAttribI1iv);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp", index, v);
}
-DECLARE(void, glVertexAttribI2iv, GLuint, index, const GLint *, v)
+DECLARE_VOID(void, glVertexAttribI2iv, GLuint, index, const GLint *, v)
{
TYPEDEF(void (*methodType)(GLuint, const GLint*));
BEFORE(glVertexAttribI2iv);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp", index, v);
}
-DECLARE(void, glVertexAttribI3iv, GLuint, index, const GLint *, v)
+DECLARE_VOID(void, glVertexAttribI3iv, GLuint, index, const GLint *, v)
{
TYPEDEF(void (*methodType)(GLuint, const GLint*));
BEFORE(glVertexAttribI3iv);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp", index, v);
}
-DECLARE(void, glVertexAttribI4iv, GLuint, index, const GLint *, v)
+DECLARE_VOID(void, glVertexAttribI4iv, GLuint, index, const GLint *, v)
{
TYPEDEF(void (*methodType)(GLuint, const GLint*));
BEFORE(glVertexAttribI4iv);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp", index, v);
}
-DECLARE(void, glVertexAttribI1uiv, GLuint, index, const GLuint *, v)
+DECLARE_VOID(void, glVertexAttribI1uiv, GLuint, index, const GLuint *, v)
{
TYPEDEF(void (*methodType)(GLuint, const GLuint*));
BEFORE(glVertexAttribI1uiv);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp", index, v);
}
-DECLARE(void, glVertexAttribI2uiv, GLuint, index, const GLuint *, v)
+DECLARE_VOID(void, glVertexAttribI2uiv, GLuint, index, const GLuint *, v)
{
TYPEDEF(void (*methodType)(GLuint, const GLuint*));
BEFORE(glVertexAttribI2uiv);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp", index, v);
}
-DECLARE(void, glGetQueryObjectuiv, GLuint, id, GLenum, pname, GLuint *, params)
+DECLARE_VOID(void, glGetQueryObjectuiv, GLuint, id, GLenum, pname, GLuint *, params)
{
TYPEDEF(void (*methodType)(GLuint, GLenum, GLuint *));
BEFORE(glGetQueryObjectuiv);
params);
}
-DECLARE(void, glGetActiveUniformsiv, GLuint, program, GLsizei, uniformCount,
+DECLARE_VOID(void, glGetActiveUniformsiv, GLuint, program, GLsizei, uniformCount,
const GLuint *, uniformIndices, GLenum, pname, GLint *, params)
{
TYPEDEF(void (*methodType)(GLuint, GLsizei, const GLuint *, GLenum,
uniformCount, uniformIndices, pname, params);
}
-DECLARE(void, glVertexAttribI3uiv, GLuint, index, const GLuint *, v)
+DECLARE_VOID(void, glVertexAttribI3uiv, GLuint, index, const GLuint *, v)
{
TYPEDEF(void (*methodType)(GLuint, const GLuint*));
BEFORE(glVertexAttribI3uiv);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp", index, v);
}
-DECLARE(void, glVertexAttribI4uiv, GLuint, index, const GLuint *, v)
+DECLARE_VOID(void, glVertexAttribI4uiv, GLuint, index, const GLuint *, v)
{
TYPEDEF(void (*methodType)(GLuint, const GLuint*));
BEFORE(glVertexAttribI4uiv);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp", index, v);
}
-DECLARE(void, glVertexAttribI4bv, GLuint, index, const GLbyte *, v)
+DECLARE_VOID(void, glVertexAttribI4bv, GLuint, index, const GLbyte *, v)
{
TYPEDEF(void (*methodType)(GLuint, const GLbyte*));
BEFORE(glVertexAttribI4bv);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp", index, v);
}
-DECLARE(void, glVertexAttribI4sv, GLuint, index, const GLshort *, v)
+DECLARE_VOID(void, glVertexAttribI4sv, GLuint, index, const GLshort *, v)
{
TYPEDEF(void (*methodType)(GLuint, const GLshort*));
BEFORE(glVertexAttribI4sv);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp", index, v);
}
-DECLARE(void, glVertexAttribI4ubv, GLuint, index, const GLubyte *, v)
+DECLARE_VOID(void, glVertexAttribI4ubv, GLuint, index, const GLubyte *, v)
{
TYPEDEF(void (*methodType)(GLuint, const GLubyte*));
BEFORE(glVertexAttribI4ubv);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp", index, v);
}
-DECLARE(void, glVertexAttribI4usv, GLuint, index, const GLushort *, v)
+DECLARE_VOID(void, glVertexAttribI4usv, GLuint, index, const GLushort *, v)
{
TYPEDEF(void (*methodType)(GLuint, const GLushort*));
BEFORE(glVertexAttribI4usv);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp", index, v);
}
-DECLARE(void, glVertexAttribIPointer, GLuint, index, GLint, size, GLenum, type,
+DECLARE_VOID(void, glVertexAttribIPointer, GLuint, index, GLint, size, GLenum, type,
GLsizei, stride, const GLvoid *, pointer)
{
TYPEDEF(void (*methodType)(GLuint, GLint, GLenum, GLsizei, const
size, type, stride, pointer);
}
-DECLARE(void, glGetVertexAttribIiv, GLuint, index, GLenum, pname, GLint *, params)
+DECLARE_VOID(void, glGetVertexAttribIiv, GLuint, index, GLenum, pname, GLint *, params)
{
TYPEDEF(void (*methodType)(GLuint, GLenum, GLint*));
BEFORE(glGetVertexAttribIiv);
pname, params);
}
-DECLARE(void, glGetVertexAttribIuiv, GLuint, index, GLenum, pname, GLuint
+DECLARE_VOID(void, glGetVertexAttribIuiv, GLuint, index, GLenum, pname, GLuint
*, params)
{
TYPEDEF(void (*methodType)(GLuint, GLenum, GLuint*));
params);
}
-DECLARE(void, glUniform1ui, GLint, location, GLuint, v0)
+DECLARE_VOID(void, glUniform1ui, GLint, location, GLuint, v0)
{
TYPEDEF(void (*methodType)(GLint, GLuint));
BEFORE(glUniform1ui);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd", location, v0);
}
-DECLARE(void, glUniform2ui, GLint, location, GLuint, v0, GLuint, v1)
+DECLARE_VOID(void, glUniform2ui, GLint, location, GLuint, v0, GLuint, v1)
{
TYPEDEF(void (*methodType)(GLint, GLuint, GLuint));
BEFORE(glUniform2ui);
v0, v1);
}
-DECLARE(void, glUniform3ui, GLint, location, GLuint, v0, GLuint, v1, GLuint, v2)
+DECLARE_VOID(void, glUniform3ui, GLint, location, GLuint, v0, GLuint, v1, GLuint, v2)
{
TYPEDEF(void (*methodType)(GLint, GLuint, GLuint, GLuint));
BEFORE(glUniform3ui);
v0, v1, v2);
}
-DECLARE(void, glUniform4ui, GLint, location, GLuint, v0, GLuint, v1, GLuint, v2,
+DECLARE_VOID(void, glUniform4ui, GLint, location, GLuint, v0, GLuint, v1, GLuint, v2,
GLuint, v3)
{
TYPEDEF(void (*methodType)(GLint, GLuint, GLuint, GLuint, GLuint));
v0, v1, v2, v3);
}
-DECLARE(void, glUniform2uiv, GLint, location, GLsizei, count, const GLuint
+DECLARE_VOID(void, glUniform2uiv, GLint, location, GLsizei, count, const GLuint
*, value)
{
TYPEDEF(void (*methodType)(GLint, GLuint, const GLuint*));
count, value);
}
-DECLARE(void, glUniform3uiv, GLint, location, GLsizei, count, const GLuint
+DECLARE_VOID(void, glUniform3uiv, GLint, location, GLsizei, count, const GLuint
*, value)
{
TYPEDEF(void (*methodType)(GLint, GLuint, const GLuint*));
count, value);
}
-DECLARE(void, glUniform1uiv, GLint, location, GLsizei, count, const GLuint
+DECLARE_VOID(void, glUniform1uiv, GLint, location, GLsizei, count, const GLuint
*, value)
{
TYPEDEF(void (*methodType)(GLint, GLuint, const GLuint*));
count, value);
}
-DECLARE(void, glUniform4uiv, GLint, location, GLsizei, count, const GLuint
+DECLARE_VOID(void, glUniform4uiv, GLint, location, GLsizei, count, const GLuint
*, value)
{
TYPEDEF(void (*methodType)(GLint, GLuint, const GLuint*));
count, value);
}
-DECLARE(void, glGetUniformuiv, GLuint, program, GLint, location, GLuint *, params)
+DECLARE_VOID(void, glGetUniformuiv, GLuint, program, GLint, location, GLuint *, params)
{
TYPEDEF(void (*methodType)(GLuint, GLint, GLuint*));
BEFORE(glGetUniformuiv);
location, params);
}
-DECLARE(void, glBindFragDataLocation, GLuint, program, GLuint, colorNumber,
+DECLARE_VOID(void, glBindFragDataLocation, GLuint, program, GLuint, colorNumber,
const GLchar *, name)
{
TYPEDEF(void (*methodType)(GLuint, GLuint, const GLchar*));
colorNumber, name);
}
-DECLARE(void, glGetFragDataLocation, GLuint, program, const GLchar *, name)
+DECLARE_VOID(void, glGetFragDataLocation, GLuint, program, const GLchar *, name)
{
TYPEDEF(void (*methodType)(GLuint, const GLchar*));
BEFORE(glGetFragDataLocation);
name);
}
-DECLARE(void, glBeginConditionalRenderNV, GLuint, id, GLenum, mode)
+DECLARE_VOID(void, glBeginConditionalRenderNV, GLuint, id, GLenum, mode)
{
TYPEDEF(void (*methodType)(GLuint, GLenum));
BEFORE(glBeginConditionalRenderNV);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx", id, mode);
}
-DECLARE_NOARGS(void, glEndConditionalRenderNV)
+DECLARE_NOARGS_VOID(void, glEndConditionalRenderNV)
{
TYPEDEF(void (*methodType)(void));
BEFORE(glEndConditionalRenderNV);
AFTER_NO_PARAM('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "");
}
-DECLARE(void, glClampColorARB, GLenum, target, GLenum, clamp)
+DECLARE_VOID(void, glClampColorARB, GLenum, target, GLenum, clamp)
{
TYPEDEF(void (*methodType)(GLenum, GLenum));
BEFORE(glClampColorARB);
clamp);
}
-DECLARE(void, glRenderbufferStorageMultisample, GLenum, target, GLsizei,
+DECLARE_VOID(void, glRenderbufferStorageMultisample, GLenum, target, GLsizei,
samplers, GLenum, internalformat, GLsizei, width, GLsizei, height)
{
TYPEDEF(void (*methodType)(GLenum, GLsizei, GLenum, GLsizei,
internalformat, width, height);
}
-DECLARE(void, glBlitFramebuffer, GLint, srcX0, GLint, srcY0, GLint, srcX1,
+DECLARE_VOID(void, glBlitFramebuffer, GLint, srcX0, GLint, srcY0, GLint, srcX1,
GLint, srcY1, GLint, dstX0, GLint, dstY0, GLint, dstX1, GLint, dstY1)
{
TYPEDEF(void (*methodType)(GLint, GLint, GLint, GLint, GLint, GLint,
srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1);
}
-DECLARE(void, glClearColorIi, GLint, r, GLint, g, GLint, b, GLint, a)
+DECLARE_VOID(void, glClearColorIi, GLint, r, GLint, g, GLint, b, GLint, a)
{
TYPEDEF(void (*methodType)(GLint, GLint, GLint, GLint));
BEFORE(glClearColorIi);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dddd", r, g, b, a);
}
-DECLARE(void, glClearColorIui, GLint, r, GLint, g, GLint, b, GLint, a)
+DECLARE_VOID(void, glClearColorIui, GLint, r, GLint, g, GLint, b, GLint, a)
{
TYPEDEF(void (*methodType)(GLint, GLint, GLint, GLint));
BEFORE(glClearColorIui);
DECLARE_GL_DEFAULT_VOID(void, glClearBufferfi, "xdpd", GLenum, buffer, GLint, drawBuffer, GLfloat, depth, GLint, stencil)
-DECLARE(void, glTexParameterIiv, GLenum, target, GLenum, pname, GLint *, params)
+DECLARE_VOID(void, glTexParameterIiv, GLenum, target, GLenum, pname, GLint *, params)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLint*));
BEFORE(glTexParameterIiv);
params);
}
-DECLARE(void, glTexParameterIuiv, GLenum, target, GLenum, pname, GLint *, params)
+DECLARE_VOID(void, glTexParameterIuiv, GLenum, target, GLenum, pname, GLint *, params)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLint*));
BEFORE(glTexParameterIuiv);
params);
}
-DECLARE(void, glGetTexParameterIiv, GLenum, target, GLenum, pname, GLint *, params)
+DECLARE_VOID(void, glGetTexParameterIiv, GLenum, target, GLenum, pname, GLint *, params)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLint*));
BEFORE(glGetTexParameterIiv);
params);
}
-DECLARE(void, glGetTexParameterIuiv, GLenum, target, GLenum, pname, GLint *, params)
+DECLARE_VOID(void, glGetTexParameterIuiv, GLenum, target, GLenum, pname, GLint *, params)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLint*));
BEFORE(glGetTexParameterIuiv);
params);
}
-DECLARE(void, glFramebufferTureLayer, GLenum, target, GLenum, attachment, GLuint,
+DECLARE_VOID(void, glFramebufferTureLayer, GLenum, target, GLenum, attachment, GLuint,
ture, GLint, level, GLint, layer)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLuint, GLint, GLint));
attachment, ture, layer);
}
-DECLARE(void, glColorMaskIndexed, GLuint, buf, GLboolean, r, GLboolean, g,
+DECLARE_VOID(void, glColorMaskIndexed, GLuint, buf, GLboolean, r, GLboolean, g,
GLboolean, b, GLboolean, a)
{
TYPEDEF(void (*methodType)(GLuint, GLboolean, GLboolean, GLboolean,
b, a);
}
-DECLARE(void, glGetBooleanIndexedv, GLenum, value, GLint, index, GLboolean *, data)
+DECLARE_VOID(void, glGetBooleanIndexedv, GLenum, value, GLint, index, GLboolean *, data)
{
TYPEDEF(void (*methodType)(GLenum, GLint, GLboolean*));
BEFORE(glGetBooleanIndexedv);
DECLARE_GL_DEFAULT_VOID(void, glGetInteger64v, "xp", GLenum, pname, GLint64xx *, data)
DECLARE_GL_DEFAULT_VOID(void, glGetIntegeri_v, "xdp", GLenum, target, GLuint, index, GLint *, data)
-DECLARE(void, glGetIntegerIndexedv, GLenum, value, GLint, index, GLboolean *, data)
+DECLARE_VOID(void, glGetIntegerIndexedv, GLenum, value, GLint, index, GLboolean *, data)
{
TYPEDEF(void (*methodType)(GLenum, GLint, GLboolean*));
BEFORE(glGetIntegerIndexedv);
data);
}
-DECLARE(void, glEnableIndexed, GLenum, value, GLint, index)
+DECLARE_VOID(void, glEnableIndexed, GLenum, value, GLint, index)
{
TYPEDEF(void (*methodType)(GLenum, GLint));
BEFORE(glEnableIndexed);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd", value, index);
}
-DECLARE(void, glDisableIndexed, GLenum, value, GLint, index)
+DECLARE_VOID(void, glDisableIndexed, GLenum, value, GLint, index)
{
TYPEDEF(void (*methodType)(GLenum, GLint));
BEFORE(glDisableIndexed);
return ret;
}
-DECLARE(void, glBindBufferRange, GLenum, target, GLuint, index, GLuint, buffer,
+DECLARE_VOID(void, glBindBufferRange, GLenum, target, GLuint, index, GLuint, buffer,
GLintptr, offset, GLsizeiptr, size)
{
TYPEDEF(void (*methodType)(GLenum, GLuint, GLuint, GLintptr,
index, buffer, offset, size);
}
-DECLARE(void, glBindBufferOffset, GLenum, target, GLuint, index, GLuint, buffer,
+DECLARE_VOID(void, glBindBufferOffset, GLenum, target, GLuint, index, GLuint, buffer,
GLintptr, offset)
{
TYPEDEF(void (*methodType)(GLenum, GLuint, GLuint, GLintptr));
index, buffer, offset);
}
-DECLARE(void, glBindBufferBase, GLenum, target, GLuint, index, GLuint, buffer)
+DECLARE_VOID(void, glBindBufferBase, GLenum, target, GLuint, index, GLuint, buffer)
{
TYPEDEF(void (*methodType)(GLenum, GLuint, GLuint));
BEFORE(glBindBufferBase);
index, buffer);
}
-DECLARE(void, glBeginTransformFeedback, GLenum, primitiveMode)
+DECLARE_VOID(void, glBeginTransformFeedback, GLenum, primitiveMode)
{
TYPEDEF(void (*methodType)(GLenum));
BEFORE(glBeginTransformFeedback);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", primitiveMode);
}
-DECLARE_NOARGS(void, glEndTransformFeedback)
+DECLARE_NOARGS_VOID(void, glEndTransformFeedback)
{
TYPEDEF(void (*methodType)(void));
BEFORE(glEndTransformFeedback);
AFTER_NO_PARAM('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "");
}
-DECLARE(void, glTransformFeedbackVaryings, GLuint, program, GLsizei, count, const
+DECLARE_VOID(void, glTransformFeedbackVaryings, GLuint, program, GLsizei, count, const
char **, varyings, GLenum, bufferMode)
{
TYPEDEF(void (*methodType)(GLuint, GLsizei, const char **, GLenum));
count, varyings, bufferMode);
}
-DECLARE(void, glGetTransformFeedbackVarying, GLuint, program, GLuint, index,
+DECLARE_VOID(void, glGetTransformFeedbackVarying, GLuint, program, GLuint, index,
GLsizei, bufSize, GLsizei *, length, GLsizei *, size, GLenum *, type, char
*, name)
{
index, bufSize, length, size, type, name);
}
-DECLARE(void, glFlushMappedBufferRange, GLenum, target, GLintptr, offset,
+DECLARE_VOID(void, glFlushMappedBufferRange, GLenum, target, GLintptr, offset,
GLsizeiptr, length)
{
TYPEDEF(void (*methodType)(GLenum, GLintptr, GLsizeiptr));
return ret;
}
-DECLARE(void, glCopyBufferSubData, GLenum, readtarget, GLenum, writetarget,
+DECLARE_VOID(void, glCopyBufferSubData, GLenum, readtarget, GLenum, writetarget,
GLintptr, readoffset, GLintptr, writeoffset, GLsizeiptr, size)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLintptr, GLintptr,
writetarget, readoffset, writeoffset, size);
}
-DECLARE(void, glGenVertexArrays, GLsizei, n, GLuint *, arrays)
+DECLARE_VOID(void, glGenVertexArrays, GLsizei, n, GLuint *, arrays)
{
TYPEDEF(void (*methodType)(GLsizei, GLuint *));
BEFORE(glGenVertexArrays);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xp", n, arrays);
}
-DECLARE(void, glDeleteVertexArrays, GLsizei, n, const GLuint *, arrays)
+DECLARE_VOID(void, glDeleteVertexArrays, GLsizei, n, const GLuint *, arrays)
{
TYPEDEF(void (*methodType)(GLsizei, const GLuint *));
BEFORE(glDeleteVertexArrays);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xp", n, arrays);
}
-DECLARE(void, glBindVertexArray, GLuint, arrays)
+DECLARE_VOID(void, glBindVertexArray, GLuint, arrays)
{
TYPEDEF(void (*methodType)(GLuint));
BEFORE(glBindVertexArray);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", arrays);
}
-DECLARE(void, glGetProgramBinary, GLuint, program, GLsizei, bufSize, GLsizei
+DECLARE_VOID(void, glGetProgramBinary, GLuint, program, GLsizei, bufSize, GLsizei
*, length, GLenum *, binaryFormat, void *, binary)
{
TYPEDEF(void (*methodType)(GLuint, GLsizei, GLsizei *, GLenum *,
bufSize, length, binaryFormat, binary);
}
-DECLARE(void, glProgramBinary, GLuint, program, GLenum, binaryFormat, const void
+DECLARE_VOID(void, glProgramBinary, GLuint, program, GLenum, binaryFormat, const void
*, binary, GLsizei, length)
{
TYPEDEF(void (*methodType)(GLuint, GLenum, const void *, GLsizei));
return ret;
}
-DECLARE(void, glGetActiveUniformBlockName, GLuint, program, GLuint,
+DECLARE_VOID(void, glGetActiveUniformBlockName, GLuint, program, GLuint,
UniformBlockIndex, GLsizei, bufSize, GLsizei *, length, GLchar
*, uniformBlockName)
{
UniformBlockIndex, bufSize, length, uniformBlockName);
}
-DECLARE(void, glGetActiveUniformBlockiv, GLuint, program, GLuint,
+DECLARE_VOID(void, glGetActiveUniformBlockiv, GLuint, program, GLuint,
UniformBlockIndex, GLenum, pname, GLint *, params)
{
TYPEDEF(void (*methodType)(GLuint, GLuint, GLenum, GLint *));
UniformBlockIndex, pname, params);
}
-DECLARE(void, glGetUniformIndices, GLuint, program, GLsizei, uniformCount, const
+DECLARE_VOID(void, glGetUniformIndices, GLuint, program, GLsizei, uniformCount, const
GLchar **, uniformsNames, GLuint *, uniformIndices)
{
TYPEDEF(void (*methodType)(GLuint, GLsizei, const GLchar **, GLuint
uniformCount, uniformsNames, uniformIndices);
}
-DECLARE(void, glGenQueries, GLsizei, n, GLuint *, ids)
+DECLARE_VOID(void, glGenQueries, GLsizei, n, GLuint *, ids)
{
TYPEDEF(void (*methodType)(GLsizei, GLuint *));
BEFORE(glGenQueries);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp", n, ids);
}
-DECLARE(void, glBeginQuery, GLenum, target, GLuint, id)
+DECLARE_VOID(void, glBeginQuery, GLenum, target, GLuint, id)
{
TYPEDEF(void (*methodType)(GLenum, GLuint));
BEFORE(glBeginQuery);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd", target, id);
}
-DECLARE(void, glEndQuery, GLenum, target, GLuint, id)
+DECLARE_VOID(void, glEndQuery, GLenum, target, GLuint, id)
{
TYPEDEF(void (*methodType)(GLenum, GLuint));
BEFORE(glEndQuery);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd", target, id);
}
-DECLARE(void, glDeleteQueries, GLsizei, n, const GLuint *, ids)
+DECLARE_VOID(void, glDeleteQueries, GLsizei, n, const GLuint *, ids)
{
TYPEDEF(void (*methodType)(GLsizei, const GLuint *));
BEFORE(glDeleteQueries);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp", n, ids);
}
-DECLARE(void, glGenTransformFeedbacks, GLsizei, n, const GLuint *, ids)
+DECLARE_VOID(void, glGenTransformFeedbacks, GLsizei, n, const GLuint *, ids)
{
TYPEDEF(void (*methodType)(GLsizei, const GLuint *));
BEFORE(glGenTransformFeedbacks);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp", n, ids);
}
-DECLARE(void, glDeleteTransformFeedbacks, GLsizei, n, const GLuint *, ids)
+DECLARE_VOID(void, glDeleteTransformFeedbacks, GLsizei, n, const GLuint *, ids)
{
TYPEDEF(void (*methodType)(GLsizei, const GLuint *));
BEFORE(glDeleteTransformFeedbacks);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp", n, ids);
}
-DECLARE_NOARGS(void, glPauseTransformFeedback)
+DECLARE_NOARGS_VOID(void, glPauseTransformFeedback)
{
TYPEDEF(void (*methodType)(void));
BEFORE(glPauseTransformFeedback);
AFTER_NO_PARAM('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "");
}
-DECLARE_NOARGS(void, glResumeTransformFeedback)
+DECLARE_NOARGS_VOID(void, glResumeTransformFeedback)
{
TYPEDEF(void (*methodType)(void));
BEFORE(glResumeTransformFeedback);
AFTER_NO_PARAM('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "");
}
-DECLARE(void, glGenSamplers, GLsizei, n, GLuint *, samplers)
+DECLARE_VOID(void, glGenSamplers, GLsizei, n, GLuint *, samplers)
{
TYPEDEF(void (*methodType)(GLsizei, GLuint *));
BEFORE(glGenSamplers);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp", n, samplers);
}
-DECLARE(void, glBindSampler, GLuint, unit, GLuint, sampler)
+DECLARE_VOID(void, glBindSampler, GLuint, unit, GLuint, sampler)
{
TYPEDEF(void (*methodType)(GLuint, GLuint));
BEFORE(glBindSampler);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd", unit, sampler);
}
-DECLARE(void, glSamplerParameterf, GLuint, sampler, GLenum, pname, GLfloat, param)
+DECLARE_VOID(void, glSamplerParameterf, GLuint, sampler, GLenum, pname, GLfloat, param)
{
TYPEDEF(void (*methodType)(GLuint, GLenum, GLfloat));
BEFORE(glSamplerParameterf);
pname, param);
}
-DECLARE(void, glSamplerParameteri, GLuint, sampler, GLenum, pname, GLint, param)
+DECLARE_VOID(void, glSamplerParameteri, GLuint, sampler, GLenum, pname, GLint, param)
{
TYPEDEF(void (*methodType)(GLuint, GLenum, GLint));
BEFORE(glSamplerParameteri);
pname, param);
}
-DECLARE(void, glSamplerParameterfv, GLuint, sampler, GLenum, pname, const GLfloat
+DECLARE_VOID(void, glSamplerParameterfv, GLuint, sampler, GLenum, pname, const GLfloat
*, params)
{
TYPEDEF(void (*methodType)(GLuint, GLenum, const GLfloat *));
pname, params);
}
-DECLARE(void, glSamplerParameteriv, GLuint, sampler, GLenum, pname, const GLint
+DECLARE_VOID(void, glSamplerParameteriv, GLuint, sampler, GLenum, pname, const GLint
*, params)
{
TYPEDEF(void (*methodType)(GLuint, GLenum, const GLint *));
pname, params);
}
-DECLARE(void, glSamplerParameterIiv, GLuint, sampler, GLenum, pname, const GLint
+DECLARE_VOID(void, glSamplerParameterIiv, GLuint, sampler, GLenum, pname, const GLint
*, params)
{
TYPEDEF(void (*methodType)(GLuint, GLenum, const GLint *));
pname, params);
}
-DECLARE(void, glSamplerParameterIuiv, GLuint, sampler, GLenum, pname, const
+DECLARE_VOID(void, glSamplerParameterIuiv, GLuint, sampler, GLenum, pname, const
GLuint *, params)
{
TYPEDEF(void (*methodType)(GLuint, GLenum, const GLuint *));
pname, params);
}
-DECLARE(void, glDeleteSamplers, GLsizei, n, const GLuint *, samplers)
+DECLARE_VOID(void, glDeleteSamplers, GLsizei, n, const GLuint *, samplers)
{
TYPEDEF(void (*methodType)(GLsizei, const GLuint *));
BEFORE(glDeleteSamplers);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp", n, samplers);
}
-DECLARE(void, glTexImage3D, GLenum, target, GLint, level, GLint, internalFormat,
+DECLARE_VOID(void, glTexImage3D, GLenum, target, GLint, level, GLint, internalFormat,
GLsizei, width, GLsizei, height, GLsizei, depth, GLint, border, GLenum,
format, GLenum, type, const GLvoid *, data)
{
type, data);
}
-DECLARE(void, glTexStorage2D, GLenum, target, GLsizei, levels, GLenum,
+DECLARE_VOID(void, glTexStorage2D, GLenum, target, GLsizei, levels, GLenum,
internalformat, GLsizei, width, GLsizei, height)
{
TYPEDEF(void (*methodType)(GLenum, GLsizei, GLenum, GLsizei, GLsizei));
levels, internalformat, width, height);
}
-DECLARE(void, glTexSubImage3D, GLint, level, GLint, xoffset, GLint, yoffset, GLint,
+DECLARE_VOID(void, glTexSubImage3D, GLint, level, GLint, xoffset, GLint, yoffset, GLint,
zoffset, GLsizei, width, GLsizei, height, GLsizei, depth, GLenum, format,
GLenum, type, const GLvoid *, pixels)
{
pixels);
}
-DECLARE(void, glCompressedTexImage3D, GLenum, target, GLint, level, GLenum,
+DECLARE_VOID(void, glCompressedTexImage3D, GLenum, target, GLint, level, GLenum,
internalformat, GLsizei, width, GLsizei, height, GLsizei, depth, GLint,
border, GLsizei, imageSize, const GLvoid *, data)
{
imageSize, data);
}
-DECLARE(void, glCompressedTexSubImage3D, GLenum, target, GLint, xoffset, GLint,
+DECLARE_VOID(void, glCompressedTexSubImage3D, GLenum, target, GLint, xoffset, GLint,
yoffset, GLint, zoffset, GLsizei, width, GLint, height, GLint, depth,
GLenum, format, GLsizei, imageSize, const GLvoid *, data)
{
format, imageSize, data);
}
-DECLARE(void, glFramebufferTextureLayer, GLenum, target, GLenum, attachment,
+DECLARE_VOID(void, glFramebufferTextureLayer, GLenum, target, GLenum, attachment,
GLuint, texture, GLint, level, GLint, layer)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLuint, GLint, GLint));
attachment, texture, level, layer);
}
-DECLARE(void, glInvalidateFramebuffer, GLenum, target, GLsizei, numAttachments,
+DECLARE_VOID(void, glInvalidateFramebuffer, GLenum, target, GLsizei, numAttachments,
const GLenum *, attachments)
{
TYPEDEF(void (*methodType)(GLenum, GLsizei, const GLenum *));
numAttachments, attachments);
}
-DECLARE(void, glInvalidateSubFramebuffer, GLenum, target, GLsizei,
+DECLARE_VOID(void, glInvalidateSubFramebuffer, GLenum, target, GLsizei,
numAttachments, const GLenum *, attachments, GLint, x, GLint, y, GLint,
width, GLsizei, height)
{
numAttachments, attachments, x, y, width, height);
}
-DECLARE(void, glInvalidateTexSubImage, GLuint, texture, GLint, level, GLint,
+DECLARE_VOID(void, glInvalidateTexSubImage, GLuint, texture, GLint, level, GLint,
xoffset, GLint, yoffset, GLint, zoffset, GLsizei, width, GLsizei, height,
GLsizei, depth)
{
level, xoffset, yoffset, zoffset, width, height, depth);
}
-DECLARE(void, glInvalidateTexImage, GLuint, texture, GLint, level)
+DECLARE_VOID(void, glInvalidateTexImage, GLuint, texture, GLint, level)
{
TYPEDEF(void (*methodType)(GLuint, GLint));
BEFORE(glInvalidateTexImage);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd", texture, level);
}
-DECLARE(void, glInvalidateBufferData, GLuint, buffer)
+DECLARE_VOID(void, glInvalidateBufferData, GLuint, buffer)
{
TYPEDEF(void (*methodType)(GLuint));
BEFORE(glInvalidateBufferData);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", buffer);
}
-DECLARE(void, glInvalidateBufferSubData, GLuint, buffer, GLintptr, offset,
+DECLARE_VOID(void, glInvalidateBufferSubData, GLuint, buffer, GLintptr, offset,
GLsizeiptr, length)
{
TYPEDEF(void (*methodType)(GLuint, GLintptr, GLsizeiptr));
}
//==========================================================================
-DECLARE(void, glBindTransformFeedback, GLenum, target, GLuint, id)
+DECLARE_VOID(void, glBindTransformFeedback, GLenum, target, GLuint, id)
{
TYPEDEF(void (*methodType)(GLenum, GLuint));
BEFORE(glBindTransformFeedback);
return ret;
}
-DECLARE(void, glCopyTexSubImage3D, GLenum, target, GLint, level, GLint, xoffset,
+DECLARE_VOID(void, glCopyTexSubImage3D, GLenum, target, GLint, level, GLint, xoffset,
GLint, yoffset, GLint, zoffset, GLint, x, GLint, y, GLsizei, width,
GLsizei, height)
{
target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
-DECLARE(void, glDeleteSync, GLsync, sync)
+DECLARE_VOID(void, glDeleteSync, GLsync, sync)
{
TYPEDEF(void (*methodType)(GLsync));
BEFORE(glDeleteSync);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "p", sync);
}
-DECLARE(void, glDrawArraysInstanced, GLenum, mode, GLint, first, GLsizei, count,
+DECLARE_VOID(void, glDrawArraysInstanced, GLenum, mode, GLint, first, GLsizei, count,
GLsizei, primcount)
{
TYPEDEF(void (*methodType)(GLenum, GLint, GLsizei, GLsizei));
count, primcount);
}
-DECLARE(void, glDrawBuffers, GLsizei, n, const GLenum *, bufs)
+DECLARE_VOID(void, glDrawBuffers, GLsizei, n, const GLenum *, bufs)
{
TYPEDEF(void (*methodType)(GLsizei, const GLenum *));
BEFORE(glDrawBuffers);
AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp", n, bufs);
}
-DECLARE(void, glDrawElementsInstanced, GLenum, mode, GLsizei, count, GLenum, type,
+DECLARE_VOID(void, glDrawElementsInstanced, GLenum, mode, GLsizei, count, GLenum, type,
const void *, indices, GLsizei, primcount)
{
TYPEDEF(void (*methodType)(GLenum, GLsizei, GLenum, const void *,
mode, count, type, indices, primcount);
}
-DECLARE(void, glDrawRangeElements, GLenum, mode, GLuint, start, GLuint, end,
+DECLARE_VOID(void, glDrawRangeElements, GLenum, mode, GLuint, start, GLuint, end,
GLsizei, count, GLenum, type, const GLvoid *, indices)
{
TYPEDEF(void (*methodType)(GLenum, GLuint, GLuint, GLsizei, GLenum,
mode, start, end, count, type, indices);
}
-DECLARE(void, glWaitSync, GLsync, sync, GLbitfield, flags, GLuint64xx, timeout)
+DECLARE_VOID(void, glWaitSync, GLsync, sync, GLbitfield, flags, GLuint64xx, timeout)
{
TYPEDEF(void (*methodType)(GLsync, GLbitfield, GLuint64xx));
BEFORE(glWaitSync);
sync, flags, timeout);
}
-DECLARE(void, glVertexAttribDivisor, GLuint, index, GLuint, divisor)
+DECLARE_VOID(void, glVertexAttribDivisor, GLuint, index, GLuint, divisor)
{
TYPEDEF(void (*methodType)(GLuint, GLuint));
BEFORE(glVertexAttribDivisor);
index, divisor);
}
-DECLARE(void, glTexStorage3D, GLenum, target, GLsizei, levels,
+DECLARE_VOID(void, glTexStorage3D, GLenum, target, GLsizei, levels,
GLenum, internalformat, GLsizei, width, GLsizei, height, GLsizei, depth)
{
TYPEDEF(void (*methodType)(GLenum, GLsizei, GLenum, GLsizei, GLsizei,
target, levels, internalformat, width, height, depth);
}
-DECLARE(void, glReadBuffer, GLenum, src)
+DECLARE_VOID(void, glReadBuffer, GLenum, src)
{
TYPEDEF(void (*methodType)(GLenum));
BEFORE(glReadBuffer);
src);
}
-DECLARE(void, glProgramParameteri, GLuint, program, GLenum, pname, GLint, value)
+DECLARE_VOID(void, glProgramParameteri, GLuint, program, GLenum, pname, GLint, value)
{
TYPEDEF(void (*methodType)(GLuint, GLenum, GLint));
BEFORE(glProgramParameteri);
DECLARE_GL_DEFAULT_VOID(void, glGetSamplerParameterfv, "dxp", GLuint, sampler, GLenum, pname, GLfloat *, params)
DECLARE_GL_DEFAULT_VOID(void, glGetSamplerParameteriv, "dxp", GLuint, sampler, GLenum, pname, GLint *, params)
-DECLARE(void, glGetSynciv, GLsync, sync, GLenum, pname, GLsizei, bufSize,
+DECLARE_VOID(void, glGetSynciv, GLsync, sync, GLenum, pname, GLsizei, bufSize,
GLsizei *, length, GLint *, values)
{
TYPEDEF(void (*methodType)(GLsync, GLenum, GLsizei, GLsizei *, GLint *));
sync, pname, bufSize, length, values);
}
-DECLARE(void, glGetQueryiv, GLenum, target, GLenum, pname, GLint *, params)
+DECLARE_VOID(void, glGetQueryiv, GLenum, target, GLenum, pname, GLint *, params)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLint *));
BEFORE(glGetQueryiv);
target, pname, params);
}
-DECLARE(void, glGetInternalformativ, GLenum, target, GLenum, internalformat,
+DECLARE_VOID(void, glGetInternalformativ, GLenum, target, GLenum, internalformat,
GLenum, pname, GLsizei, bufSize, GLint *, params)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLenum, GLsizei, GLint *));
DECLARE_GL_DEFAULT_VOID(void, glGetBufferParameteri64v, "xxp", GLenum, target, GLenum, value, GLint64xx *, data)
-DECLARE(void, glGetBufferPointerv, GLenum, target, GLenum, pname,
+DECLARE_VOID(void, glGetBufferPointerv, GLenum, target, GLenum, pname,
GLvoid **, params)
{
TYPEDEF(void (*methodType)(GLenum, GLenum, GLvoid **));
return ret;
}
-HANDLER_WRAPPERS(network_feature, void , freeaddrinfo, struct addrinfo *, res)
+HANDLER_WRAPPERS_VOID(network_feature, void , freeaddrinfo,
+ struct addrinfo *, res)
{
static void (*freeaddrinfop)(struct addrinfo *res);
return pret;
}
-HANDLER_WRAPPERS(network_feature, void , sethostent, int, stayopen)
+HANDLER_WRAPPERS_VOID(network_feature, void , sethostent, int, stayopen)
{
static void (*sethostentp)(int stayopen);
info, "d", stayopen);
}
-HANDLER_WRAPPERS(network_feature, void , endhostent, void)
+HANDLER_WRAPPERS_VOID(network_feature, void , endhostent, void)
{
static void (*endhostentp)(void);
info, "s", "");
}
-HANDLER_WRAPPERS(network_feature, void , herror, const char *, s)
+HANDLER_WRAPPERS_VOID(network_feature, void , herror, const char *, s)
{
static void (*herrorp)(const char *s);
return pret;
}
-HANDLER_WRAPPERS(network_feature, void , setservent, int, stayopen)
+HANDLER_WRAPPERS_VOID(network_feature, void , setservent, int, stayopen)
{
static void (*setserventp)(int stayopen);
info, "d", stayopen);
}
-HANDLER_WRAPPERS(network_feature, void , endservent, void)
+HANDLER_WRAPPERS_VOID(network_feature, void , endservent, void)
{
static void (*endserventp)(void);
return pret;
}
-HANDLER_WRAPPERS(network_feature, void , setnetent, int, stayopen)
+HANDLER_WRAPPERS_VOID(network_feature, void , setnetent, int, stayopen)
{
static void (*setnetentp)(int stayopen);
info, "d", stayopen);
}
-HANDLER_WRAPPERS(network_feature, void , endnetent)
+HANDLER_WRAPPERS_VOID(network_feature, void , endnetent)
{
static void (*endnetentp)(void);
return pret;
}
-HANDLER_WRAPPERS(network_feature, void , setprotoent, int, stayopen)
+HANDLER_WRAPPERS_VOID(network_feature, void , setprotoent, int, stayopen)
{
static void (*setprotoentp)(int stayopen);
info, "d", stayopen);
}
-HANDLER_WRAPPERS(network_feature, void , endprotoent)
+HANDLER_WRAPPERS_VOID(network_feature, void , endprotoent)
{
static void (*endprotoentp)(void);
return pret;
}
-HANDLER_WRAPPERS(network_feature, void , if_freenameindex, struct if_nameindex *, __ptr)
+HANDLER_WRAPPERS_VOID(network_feature, void , if_freenameindex,
+ struct if_nameindex *, __ptr)
{
static void (*if_freenameindexp)(struct if_nameindex *__ptr);
return ret;
}
-HANDLER_WRAPPERS(network_feature, void , freeifaddrs, struct ifaddrs *, ifa)
+HANDLER_WRAPPERS_VOID(network_feature, void , freeifaddrs,
+ struct ifaddrs *, ifa)
{
static void (*freeifaddrsp)(struct ifaddrs *ifa);
return ret;
}
-HANDLER_WRAPPERS(thread_feature, void , pthread_exit, void *, retval)
+HANDLER_WRAPPERS_VOID(thread_feature, void , pthread_exit, void *, retval)
{
pthread_t pSelf;
void (*pthread_exitp)(void *retval) __attribute__((noreturn));
projects / platform / core / system / swap-probe.git / commitdiff