diff options
Diffstat (limited to 'libGL/parse_gl_h.c')
| -rwxr-xr-x | libGL/parse_gl_h.c | 1503 |
1 files changed, 1503 insertions, 0 deletions
diff --git a/libGL/parse_gl_h.c b/libGL/parse_gl_h.c new file mode 100755 index 0000000..dd18c7c --- /dev/null +++ b/libGL/parse_gl_h.c @@ -0,0 +1,1503 @@ +/* + * Parse gl.h et glx.h to auto-generate source code + * + * Copyright (c) 2006,2007 Even Rouault + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +/* gcc -g parse_gl_h.c -o parse_gl_h && ./parse_gl_h */ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <assert.h> + +int isExtByName(const char* name) +{ + return (strstr(name, "ARB") != NULL) || + (strstr(name, "IBM") != NULL) || + (strstr(name, "EXT") != NULL) || + (strstr(name, "ATI") != NULL) || + (strstr(name, "NV") != NULL) || + (strstr(name, "MESA") != NULL) || + (strstr(name, "APPLE") != NULL) || + (strstr(name, "SUN") != NULL) || + (strstr(name, "SGI") != NULL); +} + +char* get_arg_type(char* s) +{ + while(*s == ' ' || *s == '\t') s++; + char* n = s; + char* c = strstr(n, "const"); + if (c) + n += 6; + + char* t = strstr(n, " "); + if (t) + { + if (t[1] == '*') + t += 2; + t[0] = 0; + char* ori = t; + t = strstr(t+1, "["); + if (t) + { + memmove(ori, t, strlen(t)); + strstr(ori, "]")[1] = 0; + } + } + return strdup(s); +} + +typedef struct +{ + char* type; + char* name; + int nargs; + char** args; + int ok; + int just_for_server_side; + int has_out_parameters; + int isExt; +} FuncDesc; + +int isExt(FuncDesc* func) +{ + return func->isExt; +} + +char* get_type_string(char* type) +{ + if (strstr(type, "[16]")) + { + if (strstr(type, "float")) + return ("TYPE_16FLOAT"); + else if (strstr(type, "double")) + return ("TYPE_16DOUBLE"); + else + { + printf("inconnu %s\n", type); + exit(-1); + } + } + else if (strstr(type, "[128]") && strstr(type, "GLubyte")) + return strstr(type, "const") ? "TYPE_128UCHAR" : "TYPE_OUT_128UCHAR"; + else if (strstr(type, "const GLvoid *")) + return "TYPE_ARRAY_VOID"; + else if (strstr(type, "const GLchar *") || + strstr(type, "const GLcharARB *")) + return "TYPE_NULL_TERMINATED_STRING"; + else if (strstr(type, "const GLbyte *")) + return "TYPE_ARRAY_SIGNED_CHAR"; + else if (strstr(type, "const GLubyte *")) + return "TYPE_ARRAY_UNSIGNED_CHAR"; + else if (strstr(type, "const GLshort *")) + return "TYPE_ARRAY_SHORT"; + else if (strstr(type, "const GLushort *") || + strstr(type, "const GLhalfNV *")) + return "TYPE_ARRAY_UNSIGNED_SHORT"; + else if (strstr(type, "const GLint *")) + return "TYPE_ARRAY_INT"; + else if (strstr(type, "const GLuint *") || + strstr(type, "const GLenum *")) + return "TYPE_ARRAY_UNSIGNED_INT"; + else if (strstr(type, "const GLfloat *") || + strstr(type, "const GLclampf *")) + return "TYPE_ARRAY_FLOAT"; + else if (strstr(type, "const GLdouble *")) + return "TYPE_ARRAY_DOUBLE"; + else if (strstr(type, "GLvoid *")) + return "TYPE_OUT_ARRAY_VOID"; + else if (strstr(type, "GLboolean *") || + strstr(type, "GLubyte *")) + return "TYPE_OUT_ARRAY_UNSIGNED_CHAR"; + else if (strstr(type, "GLcharARB *") || + strstr(type, "GLchar *")) + return "TYPE_OUT_ARRAY_CHAR"; + else if (strstr(type, "GLshort *")) + return "TYPE_OUT_ARRAY_SHORT"; + else if (strstr(type, "GLushort *")) + return "TYPE_OUT_ARRAY_UNSIGNED_SHORT"; + else if (strstr(type, "GLint *")|| + strstr(type, "GLsizei *")) + return "TYPE_OUT_ARRAY_INT"; + else if (strstr(type, "GLuint *") || + strstr(type, "GLenum *") || + strstr(type, "GLhandleARB *")) + return "TYPE_OUT_ARRAY_UNSIGNED_INT"; + else if (strstr(type, "GLfloat *")) + return "TYPE_OUT_ARRAY_FLOAT"; + else if (strstr(type, "GLdouble *")) + return "TYPE_OUT_ARRAY_DOUBLE"; + else if (strcmp(type, "void") == 0) + return("TYPE_NONE"); + else if (strcmp(type, "GLbyte") == 0) + return("TYPE_CHAR"); + else if (strcmp(type, "GLubyte") == 0 || + strcmp(type, "GLboolean") == 0) + return("TYPE_UNSIGNED_CHAR"); + else if (strcmp(type, "GLshort") == 0) + return("TYPE_SHORT"); + else if (strcmp(type, "GLushort") == 0 || + strcmp(type, "GLhalfNV") == 0) + return("TYPE_UNSIGNED_SHORT"); + else if (strcmp(type, "GLint") == 0 || + strcmp(type, "GLsizei") == 0 || + strcmp(type, "GLintptr") == 0 || + strcmp(type, "GLsizeiptr") == 0 || + strcmp(type, "GLintptrARB") == 0 || + strcmp(type, "GLsizeiptrARB") == 0) + return("TYPE_INT"); + else if (strcmp(type, "GLenum") == 0 || + strcmp(type, "GLuint") == 0 || + strcmp(type, "GLhandleARB") == 0 || + strcmp(type, "GLbitfield") == 0) + return("TYPE_UNSIGNED_INT"); + else if (strcmp(type, "GLfloat") == 0 || + strcmp(type, "GLclampf") == 0) + return("TYPE_FLOAT"); + else if (strcmp(type, "GLdouble") == 0 || + strcmp(type, "GLclampd") == 0) + return("TYPE_DOUBLE"); + else + { + printf("inconnu %s\n", type); + exit(-1); + } +} + +typedef struct +{ + char* letter; + char* signature_type_name; + char* gl_c_type_name; + char* c_type_name; +} ForIsKnownArgVector; + +#define N_ELEMENTS(x) (sizeof(x)/sizeof(x[0])) +#define N_FIELDS_IN_ARG_VECTOR 4 + + +typedef struct +{ + char* func_name; + char* signature_type_name; +} KnownLastArgFunc; + +static KnownLastArgFunc knownLastArgFuncs[] = +{ +{"glFogCoordfv", "TYPE_1FLOAT"}, +{"glFogCoorddv", "TYPE_1DOUBLE"}, +{"glFogCoordfvEXT", "TYPE_1FLOAT"}, +{"glFogCoorddvEXT", "TYPE_1DOUBLE"}, +{"glFogCoordhvNV", "TYPE_1USHORT"}, + +{"glGetFenceivNV", "TYPE_OUT_1INT"}, + +{"glGetTexLevelParameteriv", "TYPE_OUT_1INT" }, +{"glGetTexLevelParameterfv", "TYPE_OUT_1FLOAT" }, + +{"glGetRenderbufferParameterivEXT", "TYPE_OUT_1INT"}, +{"glGetFramebufferAttachmentParameterivEXT", "TYPE_OUT_1INT"}, +{"glGetFinalCombinerInputParameterivNV", "TYPE_OUT_1INT"}, +{"glGetCombinerOutputParameterivNV", "TYPE_OUT_1INT"}, +{"glGetCombinerInputParameterivNV", "TYPE_OUT_1INT"}, +{"glGetOcclusionQueryivNV", "TYPE_OUT_1INT"}, +{"glGetOcclusionQueryuivNV", "TYPE_OUT_1UINT"}, +{"glGetObjectParameterivARB", "TYPE_OUT_1INT"}, +{"glGetQueryivARB", "TYPE_OUT_1INT"}, +{"glGetQueryiv", "TYPE_OUT_1INT"}, +{"glGetQueryObjectivARB", "TYPE_OUT_1INT"}, +{"glGetQueryObjectiv", "TYPE_OUT_1INT"}, +{"glGetQueryObjectuivARB", "TYPE_OUT_1UINT"}, +{"glGetQueryObjectuiv", "TYPE_OUT_1UINT"}, +{"glGetProgramivARB", "TYPE_OUT_1INT"}, +{"glGetProgramiv", "TYPE_OUT_1INT"}, +{"glGetProgramivNV", "TYPE_OUT_1INT"}, +{"glGetShaderiv", "TYPE_OUT_1INT"}, + +{"glCombinerParameterfvNV", "TYPE_1FLOAT"}, +{"glCombinerParameterivNV", "TYPE_1INT"}, + +{"glGetFinalCombinerInputParameterfvNV", "TYPE_OUT_1FLOAT"}, +{"glGetCombinerOutputParameterfvNV", "TYPE_OUT_1FLOAT"}, +{"glGetCombinerInputParameterfvNV", "TYPE_OUT_1FLOAT"}, +{"glGetObjectParameterfvARB", "TYPE_OUT_1FLOAT"}, + +{"glCombinerStageParameterfvNV", "TYPE_4FLOAT"}, +{"glGetCombinerStageParameterfvNV", "TYPE_OUT_4FLOAT"}, + +{"glTexBumpParameterivATI", "TYPE_1INT"}, +{"glTexBumpParameterfvATI", "TYPE_1FLOAT"}, +{"glGetTexBumpParameterivATI", "TYPE_OUT_1INT"}, +{"glGetTexBumpParameterfvATI", "TYPE_OUT_1FLOAT"}, + +{"glGetProgramLocalParameterfvARB", "TYPE_OUT_4FLOAT"}, +{"glGetProgramLocalParameterdvARB", "TYPE_OUT_4DOUBLE"}, +{"glGetProgramEnvParameterfvARB", "TYPE_OUT_4FLOAT"}, +{"glGetProgramEnvParameterdvARB", "TYPE_OUT_4DOUBLE"}, +{"glGetProgramLocalParameterIivNV", "TYPE_OUT_1INT"}, +{"glGetProgramLocalParameterIuivNV", "TYPE_OUT_1UINT"}, +{"glGetProgramEnvParameterIivNV", "TYPE_OUT_1INT"}, +{"glGetProgramEnvParameterIuivNV", "TYPE_OUT_1UINT"}, + +{"glGetProgramParameterfvNV", "TYPE_OUT_4FLOAT"}, +{"glGetProgramParameterdvNV", "TYPE_OUT_4DOUBLE"}, +{"glGetProgramNamedParameterfvNV", "TYPE_OUT_4FLOAT"}, +{"glGetProgramNamedParameterdvNV", "TYPE_OUT_4DOUBLE"}, + +{"glCullParameterfvEXT", "TYPE_4FLOAT"}, +{"glCullParameterdvEXT", "TYPE_4DOUBLE"}, + +{"glGetTrackMatrixivNV", "TYPE_OUT_1INT"}, +{"glExecuteProgramNV", "TYPE_4FLOAT"}, + +{"glEdgeFlagv", "TYPE_1UCHAR"}, + +{"glClipPlane", "TYPE_4DOUBLE"}, +{"glGetClipPlane", "TYPE_OUT_4DOUBLE"}, + +{"glSetFragmentShaderConstantATI", "TYPE_4FLOAT"}, + +{"glGetObjectBufferfvATI", "TYPE_OUT_1FLOAT"}, +{"glGetObjectBufferivATI", "TYPE_OUT_1INT"}, +{"glGetArrayObjectfvATI", "TYPE_OUT_1FLOAT"}, +{"glGetArrayObjectivATI", "TYPE_OUT_1INT"}, +{"glGetVariantArrayObjectfvATI", "TYPE_OUT_1FLOAT"}, +{"glGetVariantArrayObjectivATI", "TYPE_OUT_1INT"}, +{"glGetVertexAttribArrayObjectfvATI", "TYPE_OUT_1FLOAT"}, +{"glGetVertexAttribArrayObjectivATI", "TYPE_OUT_1INT"}, + +{"glPixelTransformParameterivEXT", "TYPE_1INT"}, +{"glPixelTransformParameterfvEXT", "TYPE_1FLOAT"}, +{"glGetPixelTransformParameterivEXT", "TYPE_OUT_1INT"}, +{"glGetPixelTransformParameterfvEXT", "TYPE_OUT_1FLOAT"}, + +{"glColorTableParameterfv", "TYPE_4FLOAT"}, +{"glColorTableParameteriv", "TYPE_4INT"}, +{"glGetColorTableParameterfv", "TYPE_OUT_4FLOAT"}, +{"glGetColorTableParameteriv", "TYPE_OUT_4INT"}, +{"glColorTableParameterfvEXT", "TYPE_4FLOAT"}, +{"glColorTableParameterivEXT", "TYPE_4INT"}, +{"glGetColorTableParameterfvEXT", "TYPE_OUT_4FLOAT"}, +{"glGetColorTableParameterivEXT", "TYPE_OUT_4INT"}, + +{"glGetMinmaxParameterfv", "TYPE_OUT_1FLOAT"}, +{"glGetMinmaxParameteriv", "TYPE_OUT_1INT"}, +{"glGetHistogramParameterfv", "TYPE_OUT_1FLOAT"}, +{"glGetHistogramParameteriv", "TYPE_OUT_1INT"}, +{"glGetMinmaxParameterfvEXT", "TYPE_OUT_1FLOAT"}, +{"glGetMinmaxParameterivEXT", "TYPE_OUT_1INT"}, +{"glGetHistogramParameterfvEXT", "TYPE_OUT_1FLOAT"}, +{"glGetHistogramParameterivEXT", "TYPE_OUT_1INT"}, + +/* Not sure at all for the 2 followingo ones ! */ +{"glGetBooleanIndexedvEXT", "TYPE_OUT_4UCHAR"}, +{"glGetIntegerIndexedvEXT", "TYPE_OUT_4INT"}, + +{"glReferencePlaneSGIX", "TYPE_4DOUBLE"}, + +{"glGetTransformFeedbackVaryingNV", "TYPE_OUT_1INT"}, + +}; + +int is_known_arg_vector(FuncDesc* desc, char** p_signature_type_name, char** p_c_type_name) +{ + static ForIsKnownArgVector my_tab[] = + { + { "b", "CHAR", "GLbyte", "signed char" }, + { "Boolean", "CHAR", "GLboolean", "unsigned char" }, + { "s", "SHORT", "GLshort", "short" }, + { "i", "INT", "GLint", "int" }, + { "Integer", "INT", "GLint", "int" }, + { "ub", "CHAR", "GLubyte", "unsigned char" }, + { "h", "SHORT", "GLhalf", "unsigned short" }, + { "us", "SHORT", "GLushort", "unsigned short" }, + { "ui", "INT", "GLuint", "unsigned int" }, + { "Nb", "CHAR", "GLbyte", "signed char" }, + { "Ns", "SHORT", "GLshort", "short" }, + { "Ni", "INT", "GLint", "int" }, + { "Nub", "CHAR", "GLubyte", "unsigned char" }, + { "Nus", "SHORT", "GLushort", "unsigned short" }, + { "Nui", "INT", "GLuint", "unsigned int" }, + + { "f", "FLOAT", "GLfloat", "float" }, + { "Float", "FLOAT", "GLfloat", "float" }, + { "d", "DOUBLE", "GLdouble", "double" }, + }; + + if (desc->nargs == 0) + return 0; + + int i , j; + + if (strstr(desc->name, "glVertexAttribs") || + strstr(desc->name, "glProgramParameters") || + strstr(desc->name, "glProgramEnvParameters") || + strstr(desc->name, "glProgramLocalParameters") || + (strstr(desc->name, "glUniform") && (strstr(desc->name, "iv") || strstr(desc->name, "fv")))) + return 0; + + static char signatures[N_ELEMENTS(my_tab)][N_FIELDS_IN_ARG_VECTOR][20] = {0}; + char signature[10]; + + for(i=0;i<N_ELEMENTS(knownLastArgFuncs);i++) + { + if (strcmp(desc->name, knownLastArgFuncs[i].func_name) == 0) + { + if (p_signature_type_name) + { + *p_signature_type_name = knownLastArgFuncs[i].signature_type_name; + } + if (p_c_type_name) + { + if (strstr(knownLastArgFuncs[i].signature_type_name, "FLOAT")) + *p_c_type_name = "float"; + else if (strstr(knownLastArgFuncs[i].signature_type_name, "DOUBLE")) + *p_c_type_name = "double"; + else if (strstr(knownLastArgFuncs[i].signature_type_name, "UINT")) + *p_c_type_name = "unsigned int"; + else if (strstr(knownLastArgFuncs[i].signature_type_name, "INT")) + *p_c_type_name = "int"; + else if (strstr(knownLastArgFuncs[i].signature_type_name, "USHORT")) + *p_c_type_name = "unsigned short"; + else if (strstr(knownLastArgFuncs[i].signature_type_name, "SHORT")) + *p_c_type_name = "short"; + else if (strstr(knownLastArgFuncs[i].signature_type_name, "UCHAR")) + *p_c_type_name = "unsigned char"; + else if (strstr(knownLastArgFuncs[i].signature_type_name, "CHAR")) + *p_c_type_name = "char"; + else + assert(0); + } + return 1; + } + } + + for(i=0;i<N_ELEMENTS(my_tab);i++) + { + for(j=1;j<=N_FIELDS_IN_ARG_VECTOR;j++) + { + if (strstr(desc->name, "glIndex") && strstr(desc->name, "v")) + sprintf(signature, "%sv", my_tab[i].letter); + else + sprintf(signature, "%d%sv", j, my_tab[i].letter); + if (strstr(desc->name, signature) && + strstr(desc->args[desc->nargs - 1], my_tab[i].gl_c_type_name) && + strstr(desc->args[desc->nargs - 1], "*")) + { + if (p_signature_type_name) + { + if (signatures[i][j-1][0] == 0) + sprintf(signatures[i][j-1], "TYPE_%d%s", j, my_tab[i].signature_type_name); + *p_signature_type_name = signatures[i][j-1]; + } + if (p_c_type_name) *p_c_type_name = my_tab[i].c_type_name; + return 1; + } + } + } + return 0; +} + +static void print_server_side_argument(FILE* server_stub, int j, char* glType) +{ + const char* symbolic_type = get_type_string(glType); + if (strcmp(symbolic_type, "TYPE_CHAR") == 0) + fprintf(server_stub, "ARG_TO_CHAR(args[%d])", j); + else if (strcmp(symbolic_type, "TYPE_UNSIGNED_CHAR") == 0) + fprintf(server_stub, "ARG_TO_UNSIGNED_CHAR(args[%d])", j); + else if (strcmp(symbolic_type, "TYPE_SHORT") == 0) + fprintf(server_stub, "ARG_TO_SHORT(args[%d])", j); + else if (strcmp(symbolic_type, "TYPE_UNSIGNED_SHORT") == 0) + fprintf(server_stub, "ARG_TO_UNSIGNED_SHORT(args[%d])", j); + else if (strcmp(symbolic_type, "TYPE_INT") == 0) + fprintf(server_stub, "ARG_TO_INT(args[%d])", j); + else if (strcmp(symbolic_type, "TYPE_UNSIGNED_INT") == 0) + fprintf(server_stub, "ARG_TO_UNSIGNED_INT(args[%d])", j); + else if (strcmp(symbolic_type, "TYPE_FLOAT") == 0) + fprintf(server_stub, "ARG_TO_FLOAT(args[%d])", j); + else if (strcmp(symbolic_type, "TYPE_16FLOAT") == 0) + fprintf(server_stub, "(const float*)(args[%d])", j); + else if (strcmp(symbolic_type, "TYPE_DOUBLE") == 0) + fprintf(server_stub, "ARG_TO_DOUBLE(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_16DOUBLE") == 0) + fprintf(server_stub, "(const double*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_OUT_128UCHAR") == 0) + fprintf(server_stub, "(unsigned char*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_128UCHAR") == 0) + fprintf(server_stub, "(const unsigned char*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_NULL_TERMINATED_STRING") == 0) + fprintf(server_stub, "(const char*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_ARRAY_SHORT") == 0) + fprintf(server_stub, "(const short*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_ARRAY_UNSIGNED_SHORT") == 0) + fprintf(server_stub, "(const unsigned short*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_ARRAY_INT") == 0) + fprintf(server_stub, "(const int*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_ARRAY_UNSIGNED_INT") == 0) + fprintf(server_stub, "(const unsigned int*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_ARRAY_FLOAT") == 0) + fprintf(server_stub, "(const float*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_ARRAY_DOUBLE") == 0) + fprintf(server_stub, "(const double*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_ARRAY_CHAR") == 0) + fprintf(server_stub, "(const char*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_ARRAY_SIGNED_CHAR") == 0) + fprintf(server_stub, "(const signed char*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_ARRAY_VOID") == 0) + fprintf(server_stub, "(const void*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_ARRAY_UNSIGNED_CHAR") == 0) + fprintf(server_stub, "(const unsigned char*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_SHORT") == 0) + fprintf(server_stub, "(short*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_UNSIGNED_SHORT") == 0) + fprintf(server_stub, "(unsigned short*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_INT") == 0) + fprintf(server_stub, "(int*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_UNSIGNED_INT") == 0) + fprintf(server_stub, "(unsigned int*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_FLOAT") == 0) + fprintf(server_stub, "(float*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_DOUBLE") == 0) + fprintf(server_stub, "(double*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_VOID") == 0) + fprintf(server_stub, "(void*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_CHAR") == 0) + fprintf(server_stub, "(char*)(args[%d])", j); + else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_UNSIGNED_CHAR") == 0) + fprintf(server_stub, "(unsigned char*)(args[%d])", j); + + else + { + fprintf(stderr, "Unknown : %s\n", symbolic_type); + assert(0); + } +} + +static const char* func_dealt_by_hand[500] = { NULL }; + + +static const char* ignore_func[] = +{ + "glGetPointerv", + "glRectdv", + "glRectfv", + "glRectiv", + "glRectsv", + "glMultiDrawArrays", + "glMultiDrawArraysEXT", + "glMultiDrawElements", + "glMultiDrawElementsEXT", + "glUnmapBuffer", + "glUnmapBufferARB", + "glLoadTransposeMatrixf", + "glLoadTransposeMatrixd", + "glMultTransposeMatrixf", + "glMultTransposeMatrixd", + "glLoadTransposeMatrixfARB", + "glLoadTransposeMatrixdARB", + "glMultTransposeMatrixfARB", + "glMultTransposeMatrixdARB", + + "glPixelDataRangeNV", + "glFlushPixelDataRangeNV", + "glVertexArrayRangeNV", + "glFlushVertexArrayRangeNV", + "glVertexWeightfEXT", + + "glGetBufferPointerv", + "glGetBufferPointervARB", + "glGetVertexAttribPointerv", + "glGetVertexAttribPointervARB", + "glVertexAttribPointer", + "glVertexAttribPointerARB", + "glGetVariantPointervEXT", + NULL, +}; + +void get_func_dealt_by_hand() +{ + FILE* f = fopen("gl_func_perso.h", "r"); + char buffer[256]; + int i = 0; + char* c; + while(fgets(buffer, 256, f)) + { + if (strstr(buffer, "MAGIC_MACRO(")) + { + func_dealt_by_hand[i] = strdup(strstr(buffer, "MAGIC_MACRO(") + strlen("MAGIC_MACRO(")); + * strstr(func_dealt_by_hand[i], ")") = 0; + c = strstr(func_dealt_by_hand[i], "_"); + if (c && c != func_dealt_by_hand[i]) *c = 0; + i ++; + } + } + fclose(f); + + int j = 0; + while(ignore_func[j]) + { + func_dealt_by_hand[i] = ignore_func[j]; + i++; + j++; + } +} + +static const char* just_for_server_side_list[] = +{ + "glEnableClientState", + "glDisableClientState", + "glPushClientAttrib", + "glPopClientAttrib", + "glPixelStorei", + "glPixelStoref", + "glClientActiveTexture", + "glClientActiveTextureARB", + "glEnableVertexAttribArray", + "glEnableVertexAttribArrayARB", + "glDisableVertexAttribArray", + "glDisableVertexAttribArrayARB", + "glDrawElementArrayATI", + "glDrawRangeElementArrayATI", + "glGenSymbolsEXT", + "glFreeObjectBufferATI", + "glUnmapObjectBufferATI", + "glLockArraysEXT", + "glUnlockArraysEXT", + "glDepthFunc", + "glFogf", + "glFogi", + "glClipPlane", + "glGetClipPlane", + +/* begin of openquartz optimization */ +#if 1 + "glMatrixMode", + "glOrtho", + "glFrustum", + "glPushMatrix", + "glPopMatrix", + "glLoadIdentity", + "glLoadMatrixd", + "glLoadMatrixf", + "glMultMatrixd", + "glMultMatrixf", + "glRotated", + "glRotatef", + "glScaled", + "glScalef", + "glTranslated", + "glTranslatef", +#endif +/* end of openquartz optimization */ + + "glGetError", + "glActiveTextureARB", + + "glViewport", + "glScissor", + + "glBindBufferARB", + "glDeleteBuffersARB", + "glGenBuffersARB", + "glBufferDataARB", + "glBufferSubDataARB", + "glGetBufferSubDataARB", + "glGetBufferParameterivARB", + "glBindBuffer", + "glDeleteBuffers", + "glGenBuffers", + "glBufferData", + "glBufferSubData", + "glGetBufferSubData", + "glGetBufferParameteriv", + + "glPushAttrib", + "glPopAttrib", + "glEnable", + "glDisable", + "glIsEnabled", + "glBindTexture", + "glBindTextureEXT", + "glFogfv", + "glFogiv", + "glBitmap", + "glGetTexImage", + "glReadPixels", + "glDrawPixels", + "glSelectBuffer", + "glFeedbackBuffer", + + "glTexImage1D", + "glTexImage2D", + "glTexImage3D", + "glTexSubImage1D", + "glTexSubImage2D", + "glTexSubImage3D", + + "glTexImage3DEXT", + "glTexSubImage1DEXT", + "glTexSubImage2DEXT", + "glTexSubImage3DEXT", + + "glGetCompressedTexImage", + "glCompressedTexImage1D", + "glCompressedTexImage2D", + "glCompressedTexImage3D", + "glCompressedTexSubImage1D", + "glCompressedTexSubImage2D", + "glCompressedTexSubImage3D", + + "glGetCompressedTexImageARB", + "glCompressedTexImage1DARB", + "glCompressedTexImage2DARB", + "glCompressedTexImage3DARB", + "glCompressedTexSubImage1DARB", + "glCompressedTexSubImage2DARB", + "glCompressedTexSubImage3DARB", + + "glCallLists", + "glNewList", + "glDeleteLists", + "glGenLists", + + "glGenTextures", + "glDeleteTextures", + "glDeleteTexturesEXT", + "glMap1f", + "glMap1d", + "glMap2f", + "glMap2d", + "glGetMapdv", + "glGetMapfv", + "glGetMapiv", + "glGetBooleanv", + "glGetIntegerv", + "glGetFloatv", + "glGetDoublev", + + "glGetPixelMapfv", + "glGetPixelMapuiv", + "glGetPixelMapusv", + "glGetProgramStringARB", + "glGetProgramStringNV", + "glArrayElement", + "glDrawArrays", + "glDrawElements", + "glDrawRangeElements", + "glDrawRangeElementsEXT", + "glGetProgramInfoLog", + "glGetTexLevelParameteriv", + "glGetInfoLogARB", + "glGetShaderInfoLog", + "glGetAttachedObjectsARB", + "glGetAttachedShaders", + "glGetActiveUniformARB", + "glGetActiveUniform", + "glGetUniformLocationARB", + "glGetUniformLocation", + "glGetUniformfvARB", + "glGetUniformfv", + "glGetUniformivARB", + "glGetUniformiv", + "glGetUniformuivEXT", + "glGetShaderSourceARB", + "glGetShaderSource", + "glGetActiveAttribARB", + "glGetActiveAttrib", + "glGetAttribLocationARB", + "glGetAttribLocation", + + "glNewObjectBufferATI", + "glUpdateObjectBufferATI", + + "glSetLocalConstantEXT", + "glSetInvariantEXT", + "glVariantbvEXT", + "glVariantsvEXT", + "glVariantivEXT", + "glVariantfvEXT", + "glVariantdvEXT", + "glVariantubvEXT", + "glVariantusvEXT", + "glVariantuivEXT", + "glGetVariantBooleanvEXT", + "glGetVariantIntegervEXT", + "glGetVariantFloatvEXT", + "glGetInvariantBooleanvEXT", + "glGetInvariantIntegervEXT", + "glGetInvariantFloatvEXT", + "glGetLocalConstantBooleanvEXT", + "glGetLocalConstantIntegervEXT", + "glGetLocalConstantFloatvEXT", + + "glMatrixIndexubvARB", + "glMatrixIndexusvARB", + "glMatrixIndexuivARB", + + "glColorTable", + "glColorSubTable", + "glGetColorTable", + "glConvolutionFilter1D", + "glConvolutionFilter2D", + "glGetConvolutionFilter", + "glSeparableFilter2D", + "glGetSeparableFilter", + "glGetHistogram", + "glGetMinmax", + "glColorTableEXT", + "glColorSubTableEXT", + "glGetColorTableEXT", + "glConvolutionFilter1DEXT", + "glConvolutionFilter2DEXT", + "glGetConvolutionFilterEXT", + "glSeparableFilter2DEXT", + "glGetSeparableFilterEXT", + "glGetHistogramEXT", + "glGetMinmaxEXT", + + "glGetTexParameterfv", + + "glGetVertexAttribivARB", + "glGetVertexAttribfvARB", + "glGetVertexAttribdvARB", + "glGetVertexAttribiv", + "glGetVertexAttribfv", + "glGetVertexAttribdv", + + "glGetDetailTexFuncSGIS", + "glGetSharpenTexFuncSGIS", + + "fake_gluBuild2DMipmaps", + + "glRenderMode", + + "glEnableVariantClientStateEXT", + "glDisableVariantClientStateEXT", + + "glGetActiveVaryingNV", + + "glLinkProgram", + "glLinkProgramARB", + + /*"glEGLImageTargetTexture2DOES",*/ + + NULL, +}; + +static int just_for_server_side_func(char* funcname) +{ + int i; + for(i=0;just_for_server_side_list[i];i++) + { + if (strcmp(just_for_server_side_list[i], funcname) == 0) + return 1; + } + return 0; +} + +int parse(FILE* f, FuncDesc* funcDesc, int funcDescCount, int ignoreEXT) +{ + char buffer[256]; + while(fgets(buffer, 256, f)) + { + + if (strncmp(buffer, "GLAPI", 5) == 0 && strstr(buffer, "APIENTRY") && strstr(buffer, "(")) + { + int i = 0; + int skip = 0; + if (func_dealt_by_hand[0] == 0) + { + get_func_dealt_by_hand(); + } + while (func_dealt_by_hand[i]) + { + if (strstr(buffer, func_dealt_by_hand[i])) + { + skip = 1; + break; + } + i++; + } + if (skip) + continue; + + char** args = malloc(15 * sizeof(char*)); + int narg = 0; + char* type = buffer + 6; + char* n = strstr(type, "GLAPIENTRY") ? strstr(type, "GLAPIENTRY") : strstr(type, "APIENTRY"); + int skip_length = strstr(type, "GLAPIENTRY") ? 11 : 9; + n[-1] = 0; + type = strdup(type); + n += skip_length; + char* fonc = n; + n = strstr(n, "("); + if (n[-1] == ' ') n[-1] = 0; + n[0] = 0; + fonc = strdup(fonc); + /*if (strstr(fonc, "glLockArraysEXT") || strstr(fonc, "glUnlockArraysEXT")) + { + } + else*/ + + + if (ignoreEXT == 1 && isExtByName(fonc)) + { + free(type); + free(fonc); + continue; + } + n++; + while(1) + { + char* virg = strstr(n, ","); + if (virg) + { + args[narg] = n; + virg[0] = 0; + args[narg] = get_arg_type(args[narg]); + narg++; + n = virg+1; + } + else + break; + } + while (strstr(n, ")") == 0) + { + fgets(buffer, 256, f); + n = buffer; + while(1) + { + char* virg = strstr(n, ","); + if (virg) + { + args[narg] = n; + virg[0] = 0; + args[narg] = get_arg_type(args[narg]); + narg++; + n = virg+1; + } + else + break; + } + } + char* par = strstr(n, ")"); + args[narg] = n; + par[0] = 0; + args[narg] = get_arg_type(args[narg]); + narg++; + + + /*printf("%s %s (", type, fonc); + for(i=0;i<narg;i++) + { + printf("%s,", args[i]); + } + printf(")\n");*/ + + for(i=0;i<funcDescCount;i++) + { + if (strcmp(funcDesc[i].name, fonc) == 0) + { + if (ignoreEXT == 0) + funcDesc[i].isExt = 1; + break; + } + } + if (i == funcDescCount) + { + funcDesc[funcDescCount].type = type; + funcDesc[funcDescCount].name = fonc; + funcDesc[funcDescCount].nargs = narg; + funcDesc[funcDescCount].args = args; + funcDesc[funcDescCount].isExt = ignoreEXT == 0; + funcDescCount++; + } + else + { + free(fonc); + free(args); + free(type); + } + /* + for(i=0;i<narg;i++) + { + free(args[i]); + } + free(fonc); + free(type);*/ + } + } + return funcDescCount; +} + +typedef struct +{ + char* str; + int i; +} StringIntStruct; + +StringIntStruct argDependingOnPreviousArgTab[] = +{ + { "glLoadProgramNV", 3}, + { "ProgramNamedParameter", 2}, + { "glDeleteBuffers", 1}, + { "glDrawBuffers", 1}, + { "glGenPrograms", 1}, + { "glDeletePrograms", 1}, + { "glGenQueries", 1}, + { "glDeleteQueries", 1}, + { "glGenFencesNV", 1}, + { "glDeleteFencesNV", 1}, + { "glGenOcclusionQueriesNV", 1}, + { "glDeleteOcclusionQueriesNV", 1}, + { "glRequestResidentProgramsNV", 1}, + { "glDeleteTextures", 1}, + { "glGenFramebuffersEXT", 1}, + { "glDeleteFramebuffersEXT", 1}, + { "glGenRenderbuffersEXT", 1}, + { "glDeleteRenderbuffersEXT", 1}, + { "glUniform1fv", 2}, + { "glUniform2fv", 2}, + { "glUniform3fv", 2}, + { "glUniform4fv", 2}, + { "glUniform1iv", 2}, + { "glUniform2iv", 2}, + { "glUniform3iv", 2}, + { "glUniform4iv", 2}, + { "glUniform1uivEXT", 2}, + { "glUniform2uivEXT", 2}, + { "glUniform3uivEXT", 2}, + { "glUniform4uivEXT", 2}, + { "glProgramParameters4fvNV", 3}, + { "glProgramParameters4dvNV", 3}, + { "glProgramLocalParameters4fvEXT", 3}, + { "glProgramLocalParametersI4ivNV", 3}, + { "glProgramLocalParametersI4uivNV", 3}, + { "glProgramEnvParameters4fvEXT", 3}, + { "glProgramEnvParametersI4ivNV", 3}, + { "glProgramEnvParametersI4uivNV", 3}, + { "glAreProgramsResidentNV", 1} , + { "glAreProgramsResidentNV", 2} , + { "glAreTexturesResident", 1} , + { "glAreTexturesResident", 2} , + { "glPrioritizeTextures", 1} , + { "glPrioritizeTextures", 2} , + { "glProgramStringARB", 3} , + + { "glVertexAttribs", 2}, + + { "glUniformMatrix", 3 }, + + { "glGetVertexAttribfv", 2}, + { "glGetVertexAttribiv", 2}, + { "glGetVertexAttribdv", 2}, + { "glGetVertexAttribIivEXT", 2}, + { "glGetVertexAttribIuivEXT", 2}, + + { "glPointParameterfv", 1}, + { "glPointParameteriv", 1}, + + { "glWeightbvARB", 1}, + { "glWeightsvARB", 1}, + { "glWeightivARB", 1}, + { "glWeightfvARB", 1}, + { "glWeightdvARB", 1}, + { "glWeightubvARB", 1}, + { "glWeightusvARB", 1}, + { "glWeightuivARB", 1}, + + { "glTexEnvfv", 2}, + { "glTexEnviv", 2}, + { "glGetTexEnvfv", 2}, + { "glGetTexEnviv", 2}, + { "glTexGendv", 2}, + { "glTexGenfv", 2}, + { "glTexGeniv", 2}, + { "glGetTexGendv", 2}, + { "glGetTexGenfv", 2}, + { "glGetTexGeniv", 2}, + + { "glLightfv", 2}, + { "glLightiv", 2}, + { "glGetLightfv", 2}, + { "glGetLightiv", 2}, + { "glFragmentLightfvSGIX", 2}, + { "glFragmentLightivSGIX", 2}, + { "glGetFragmentLightfvSGIX", 2}, + { "glGetFragmentLightivSGIX", 2}, + + + { "glLightModelfv", 1}, + { "glLightModeliv", 1}, + { "glFragmentLightModelfvSGIX", 1}, + { "glFragmentLightModelivSGIX", 1}, + + { "glMaterialfv", 2}, + { "glMaterialiv", 2}, + { "glGetMaterialfv", 2}, + { "glGetMaterialiv", 2}, + { "glFragmentMaterialfvSGIX", 2}, + { "glFragmentMaterialivSGIX", 2}, + { "glGetFragmentMaterialfvSGIX", 2}, + { "glGetFragmentMaterialivSGIX", 2}, + + { "glFogiv", 1}, + { "glFogfv", 1}, + + { "glTexParameterfv", 2}, + { "glTexParameteriv", 2}, + { "glGetTexParameterfv", 2}, + { "glGetTexParameteriv", 2}, + + { "glTexParameterIivEXT", 2}, + { "glTexParameterIuivEXT", 2}, + { "glGetTexParameterIivEXT", 2}, + { "glGetTexParameterIuivEXT", 2}, + + { "glPixelMapfv", 2}, + { "glPixelMapuiv", 2}, + { "glPixelMapusv", 2}, + + { "glDetailTexFuncSGIS", 2 }, + { "glSharpenTexFuncSGIS", 2 }, + + { "glSpriteParameterfvSGIX", 1 }, + { "glSpriteParameterivSGIX", 1 }, + + { "ConvolutionParameter", 2}, + + { "glProgramBufferParametersfvNV", 4}, + { "glProgramBufferParametersIivNV", 4}, + { "glProgramBufferParametersIuivNV", 4}, + + { "glTransformFeedbackAttribsNV", 1}, + { "glTransformFeedbackVaryingsNV", 2}, +}; + +int is_arg_of_length_depending_on_previous_args(FuncDesc* funcDesc, int j) +{ + int i; + if (strstr(funcDesc->args[j], "*") == NULL) + return 0; + for(i=0;i< N_ELEMENTS(argDependingOnPreviousArgTab); i++) + { + if (strstr(funcDesc->name, argDependingOnPreviousArgTab[i].str) && j == argDependingOnPreviousArgTab[i].i) + return 1; + } + return 0; +} + +static void fprintf_prototype_args(FILE* f, FuncDesc* funcDesc) +{ + int j; + for(j=0;j<funcDesc->nargs;j++) + { + if (j != 0) fprintf(f,", "); + if (strstr(funcDesc->args[j], "[16]")) + { + if (strstr(funcDesc->args[j], "float")) + { + fprintf(f, "const GLfloat arg_%d[16]", j); + } + else if (strstr(funcDesc->args[j], "double")) + { + fprintf(f, "const GLdouble arg_%d[16]", j); + } + else + { + exit(-1); + } + } + else if (strstr(funcDesc->args[j], "[128]") && strstr(funcDesc->args[j], "GLubyte")) + fprintf(f, (strstr(funcDesc->args[j], "const")) ? "const GLubyte* arg_%d" : "GLubyte* arg_%d", j); + else + fprintf(f, "%s arg_%d", funcDesc->args[j], j); + } +} + +int main(int argc, char* argv[]) +{ + FuncDesc funcDesc[3000]; + int funcDescCount = 0; + FILE* f; + + f = fopen("mesa_gl.h", "r"); + assert(f); + /*if (!f) + f = fopen("/usr/include/GL/gl.h", "r");*/ + funcDescCount = parse(f, funcDesc, 0, 1); + fclose(f); + + f = fopen("mesa_glext.h", "r"); + assert(f); + /*if (!f) + f = fopen("/usr/include/GL/glext.h", "r");*/ + funcDescCount = parse(f, funcDesc, funcDescCount, 0); + fclose(f); + + FILE* header = fopen("gl_func.h", "w"); + FILE* table = fopen("gl_func_tabs.h", "w"); + FILE* client_stub = fopen("client_stub.c", "w"); + FILE* server_stub = fopen("server_stub.c", "w"); + + fprintf(header, "/* This is a generated file. DO NOT EDIT ! */\n\n"); + fprintf(table, "/* This is a generated file. DO NOT EDIT ! */\n\n"); + fprintf(header, "#define COMPOSE(x,y) x##y\n"); + fprintf(header, "#define MAGIC_MACRO(x) COMPOSE(x,_func)\n"); + fprintf(header, "enum {\n" + "#include \"gl_func_perso.h\"\n"); + + fprintf(client_stub, "/* This is a generated file. DO NOT EDIT ! */\n\n"); + + fprintf(server_stub, "/* This is a generated file. DO NOT EDIT ! */\n\n"); + + int i; + for(i=0;i<funcDescCount;i++) + { + funcDesc[i].ok = 0; + char* name = funcDesc[i].name; + char* type = funcDesc[i].type; + if ((strcmp(type, "void") == 0 || strcmp(type, "GLboolean") == 0 || + strcmp(type, "GLuint") == 0 || strcmp(type, "GLint") == 0 || + strcmp(type, "GLenum") == 0) || strcmp(type, "GLhandleARB") == 0 || + strcmp(type, "GLhalf") == 0 || strcmp(type, "GLhalfNV") == 0) + { + int pointer_of_unknown_size = 0; + int j; + + if (funcDesc[i].nargs == 1 && strcmp(funcDesc[i].args[0], "void") == 0) + { + funcDesc[i].nargs = 0; + } + for(j=0;j<funcDesc[i].nargs-1;j++) + { + if (!is_arg_of_length_depending_on_previous_args(&funcDesc[i], j) && + strstr(funcDesc[i].args[j], "const GLchar") == NULL && + strstr(funcDesc[i].args[j], "[16]") == NULL) + { + pointer_of_unknown_size |= strstr(funcDesc[i].args[j], "*") != NULL; + pointer_of_unknown_size |= strstr(funcDesc[i].args[j], "[") != NULL; + } + } + + if (pointer_of_unknown_size == 0) + { + char* signature_type_name; + if (is_known_arg_vector(&funcDesc[i], &signature_type_name, NULL)) + { + if (strstr(signature_type_name, "TYPE_OUT")) + funcDesc[i].has_out_parameters = 1; + } + else + { + if (funcDesc[i].nargs-1 >= 0) + { + j = funcDesc[i].nargs-1; + if (!is_arg_of_length_depending_on_previous_args(&funcDesc[i], j) && + strstr(funcDesc[i].args[j], "const GLchar") == NULL && + strstr(funcDesc[i].args[j], "[16]") == NULL) + { + pointer_of_unknown_size |= strstr(funcDesc[i].args[j], "*") != NULL; + pointer_of_unknown_size |= strstr(funcDesc[i].args[j], "[") != NULL; + } + } + } + } + if (pointer_of_unknown_size && funcDesc[i].nargs == 1) + { + if (strstr(funcDesc[i].name, "Matrixf") || strstr(funcDesc[i].name, "Matrixd")) + { + free(funcDesc[i].args[0]); + if (strstr(funcDesc[i].name, "Matrixf")) + funcDesc[i].args[0] = strdup("GLfloat m[16]"); + else + funcDesc[i].args[0] = strdup("GLdouble m[16]"); + pointer_of_unknown_size = 0; + } + else if (strcmp(funcDesc[i].name, "glPolygonStipple") == 0) + { + free(funcDesc[i].args[0]); + funcDesc[i].args[0] = strdup("const GLubyte mask[128]"); + pointer_of_unknown_size = 0; + } + else if (strcmp(funcDesc[i].name, "glGetPolygonStipple") == 0) + { + free(funcDesc[i].args[0]); + funcDesc[i].args[0] = strdup("GLubyte mask[128]"); + funcDesc[i].has_out_parameters = 1; + pointer_of_unknown_size = 0; + } + } + if (just_for_server_side_func(name) || pointer_of_unknown_size == 0) + { + fprintf(header, " %s_func,\n", funcDesc[i].name); + funcDesc[i].ok = 1; + if (just_for_server_side_func(name)) + funcDesc[i].just_for_server_side = 1; + for(j=0;j<funcDesc[i].nargs;j++) + { + if (strstr(get_type_string(funcDesc[i].args[j]), "OUT")) + funcDesc[i].has_out_parameters = 1; + } + } + else + { + fprintf(stderr, "not handled either manually or automatically : %s\n", funcDesc[i].name); + } + } + } + + fprintf(header, " GL_N_CALLS\n};\n"); + + + fprintf(server_stub, "void execute_func(int func_number, long* args, int* pret_int, char* pret_char)\n"); + fprintf(server_stub, "{\n"); + fprintf(server_stub, " switch(func_number)\n"); + fprintf(server_stub, " {\n"); + + for(i=0;i<funcDescCount;i++) + { + if (funcDesc[i].ok) + { + fprintf(table, "static const int %s_signature[] = { %s, %d, ", + funcDesc[i].name, + get_type_string(funcDesc[i].type), + funcDesc[i].has_out_parameters); + fprintf(table, "%d", funcDesc[i].nargs); + int j; + char* signature_type_name; + int n_args_to_check = is_known_arg_vector(&funcDesc[i], &signature_type_name, NULL) ? funcDesc[i].nargs - 1 : funcDesc[i].nargs; + + for(j=0;j<n_args_to_check;j++) + { + if (is_arg_of_length_depending_on_previous_args(&funcDesc[i], j)) + { + fprintf(table, ", %s_OF_LENGTH_DEPENDING_ON_PREVIOUS_ARGS", get_type_string(funcDesc[i].args[j])); + } + else + fprintf(table, ", %s", get_type_string(funcDesc[i].args[j])); + } + + if (is_known_arg_vector(&funcDesc[i], &signature_type_name, NULL)) + { + fprintf(table, ", %s", signature_type_name); + } + fprintf(table, "};\n"); + + + if (funcDesc[i].just_for_server_side == 0) + { + if (isExt(&funcDesc[i])) + fprintf(client_stub, "GLAPI %s APIENTRY EXT_FUNC(%s) (", funcDesc[i].type, funcDesc[i].name); + else + fprintf(client_stub, "GLAPI %s APIENTRY %s(", funcDesc[i].type, funcDesc[i].name); + fprintf_prototype_args(client_stub, &funcDesc[i]); + fprintf(client_stub, ")\n"); + fprintf(client_stub, "{\n"); + if (strcmp(funcDesc[i].type, "void") != 0) + { + fprintf(client_stub, " %s ret;\n", funcDesc[i].type); + if (isExt(&funcDesc[i])) + fprintf(client_stub, " CHECK_PROC_WITH_RET(%s);\n", funcDesc[i].name); + } + else + { + if (isExt(&funcDesc[i])) + fprintf(client_stub, " CHECK_PROC(%s);\n", funcDesc[i].name); + } + + /* + fprintf(client_stub, " do_opengl_call(%s_func, %s", + funcDesc[i].name, (strcmp(funcDesc[i].type, "void") == 0) ? "NULL" : "&ret"); + for(j=0;j<funcDesc[i].nargs;j++) + { + fprintf(client_stub, ", arg_%d", j); + } + fprintf(client_stub, ");\n"); + */ + + if (funcDesc[i].nargs) + { + fprintf(client_stub, " long args[] = { "); + for(j=0;j<funcDesc[i].nargs;j++) + { + if (j > 0) fprintf(client_stub, ", "); + if (strstr(funcDesc[i].args[j], "*")) + { + fprintf(client_stub, "POINTER_TO_ARG(arg_%d)", j); + } + else + { + const char* symbolic_type = get_type_string(funcDesc[i].args[j]); + if (strcmp(symbolic_type, "TYPE_CHAR") == 0) + fprintf(client_stub, "CHAR_TO_ARG"); + else if (strcmp(symbolic_type, "TYPE_UNSIGNED_CHAR") == 0) + fprintf(client_stub, "UNSIGNED_CHAR_TO_ARG"); + else if (strcmp(symbolic_type, "TYPE_SHORT") == 0) + fprintf(client_stub, "SHORT_TO_ARG"); + else if (strcmp(symbolic_type, "TYPE_UNSIGNED_SHORT") == 0) + fprintf(client_stub, "UNSIGNED_SHORT_TO_ARG"); + else if (strcmp(symbolic_type, "TYPE_INT") == 0) + fprintf(client_stub, "INT_TO_ARG"); + else if (strcmp(symbolic_type, "TYPE_UNSIGNED_INT") == 0) + fprintf(client_stub, "UNSIGNED_INT_TO_ARG"); + else if (strcmp(symbolic_type, "TYPE_FLOAT") == 0) + fprintf(client_stub, "FLOAT_TO_ARG"); + else if (strcmp(symbolic_type, "TYPE_16FLOAT") == 0) + fprintf(client_stub, "POINTER_TO_ARG"); + else if (strcmp(symbolic_type, "TYPE_DOUBLE") == 0) + fprintf(client_stub, "DOUBLE_TO_ARG"); + else if ( strcmp(symbolic_type, "TYPE_16DOUBLE") == 0) + fprintf(client_stub, "POINTER_TO_ARG"); + else if ( strcmp(symbolic_type, "TYPE_128UCHAR") == 0 || strcmp(symbolic_type, "TYPE_OUT_128UCHAR") == 0) + fprintf(client_stub, "POINTER_TO_ARG"); + else + { + fprintf(stderr, "Unknown : %s\n", symbolic_type); + assert(0); + } + fprintf(client_stub, "(arg_%d)", j); + } + } + fprintf(client_stub, "};\n"); + } + + fprintf(client_stub, " do_opengl_call(%s_func, %s, %s, NULL);\n", + funcDesc[i].name, (strcmp(funcDesc[i].type, "void") == 0) ? "NULL" : "&ret", + (funcDesc[i].nargs) ? "args" : "NULL"); + + if (strcmp(funcDesc[i].type, "void") != 0) + { + fprintf(client_stub, " return ret;\n"); + } + fprintf(client_stub, "}\n\n"); + } + + fprintf(server_stub, " case %s_func:\n", funcDesc[i].name); + fprintf(server_stub, " {\n"); + + if (isExt(&funcDesc[i])) + { + fprintf(server_stub, " GET_EXT_PTR(%s, %s, (", funcDesc[i].type, funcDesc[i].name); + fprintf_prototype_args(server_stub, &funcDesc[i]); + fprintf(server_stub, "));\n"); + } + + fprintf(server_stub, " "); + + if (strcmp(funcDesc[i].type, "void") == 0) + ; + else if (strcmp(get_type_string(funcDesc[i].type), "TYPE_INT") == 0 || + strcmp(get_type_string(funcDesc[i].type), "TYPE_UNSIGNED_INT") == 0) + fprintf(server_stub, "*pret_int = "); + else if (strcmp(get_type_string(funcDesc[i].type), "TYPE_CHAR") == 0 || + strcmp(get_type_string(funcDesc[i].type), "TYPE_UNSIGNED_CHAR") == 0) + fprintf(server_stub, "*pret_char = "); + else + { + fprintf(stderr, "unknown ret type = %s\n", get_type_string(funcDesc[i].type)); + exit(-1); + } + /*if (strstr(funcDesc[i].name, "EXT")) + { + char* dup = strdup(funcDesc[i].name); + *strstr(dup, "EXT") = 0; + fprintf(server_stub, "%s(", dup); + free(dup); + } + else*/ + { + if (isExt(&funcDesc[i])) + fprintf(server_stub, "ptr_func_%s(", funcDesc[i].name); + else + fprintf(server_stub, "%s(", funcDesc[i].name); + } + char* c_type_name; + if (is_known_arg_vector(&funcDesc[i], NULL, &c_type_name)) + { + for(j=0;j<funcDesc[i].nargs - 1;j++) + { + if (j != 0) fprintf(server_stub,", "); + print_server_side_argument(server_stub, j, funcDesc[i].args[j]); + } + if (j != 0) fprintf(server_stub,", "); + if (strstr(funcDesc[i].args[funcDesc[i].nargs - 1], "const")) + fprintf(server_stub, "(const %s*)args[%d]", c_type_name, j); + else + fprintf(server_stub, "(%s*)args[%d]", c_type_name, j); + } + else + { + for(j=0;j<funcDesc[i].nargs;j++) + { + if (j != 0) fprintf(server_stub,", "); + print_server_side_argument(server_stub, j, funcDesc[i].args[j]); + } + } + fprintf(server_stub, ");\n"); + + fprintf(server_stub, " break;\n"); + fprintf(server_stub, " }\n"); + } + } + + fprintf(server_stub, " default:\n"); + fprintf(server_stub, " fprintf(stderr, \"unknown=%%d\", func_number);\n"); + fprintf(server_stub, " break;\n"); + fprintf(server_stub, " }\n"); + fprintf(server_stub, "}\n"); + + fprintf(header, "#undef MAGIC_MACRO\n"); + fprintf(table, "#define MAGIC_MACRO(x) COMPOSE(x,_signature)\n\n"); + fprintf(table, "const int* tab_opengl_calls[GL_N_CALLS] =\n"); + fprintf(table, "{\n"); + fprintf(table, "#include \"gl_func_perso.h\"\n"); + for(i=0;i<funcDescCount;i++) + { + if (funcDesc[i].ok) + { + fprintf(table, " %s_signature,\n", funcDesc[i].name); + } + } + fprintf(table, "};\n\n"); + + fprintf(table, "#undef MAGIC_MACRO\n"); + fprintf(table, "#define MAGIC_MACRO(x) #x\n"); + fprintf(table, "const char* tab_opengl_calls_name[GL_N_CALLS] =\n"); + fprintf(table, "{\n"); + fprintf(table, "#include \"gl_func_perso.h\"\n"); + for(i=0;i<funcDescCount;i++) + { + if (funcDesc[i].ok) + { + fprintf(table, " \"%s\",\n", funcDesc[i].name); + } + } + fprintf(table, "};\n\n"); + + fclose(header); + fclose(table); + fclose(server_stub); + fclose(client_stub); + + return 0; +} |