tizen/src/hw/parse_gl_h.c

   1 /*
   2  *  Parse gl.h et glx.h to auto-generate source code
   3  *
   4  *  Copyright (c) 2006,2007 Even Rouault
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 /* gcc -g parse_gl_h.c -o parse_gl_h && ./parse_gl_h */
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <assert.h>
  30
  31 #define         GL_INCLUDE_PATH         "../tizen/src/hw/"
  32
  33
  34 int isExtByName(const char* name)
  35 {
  36   return (strstr(name, "ARB") != NULL) ||
  37          (strstr(name, "IBM") != NULL) ||
  38          (strstr(name, "EXT") != NULL) ||
  39          (strstr(name, "ATI") != NULL) ||
  40          (strstr(name, "NV") != NULL) ||
  41          (strstr(name, "MESA") != NULL) ||
  42          (strstr(name, "APPLE") != NULL) ||
  43          (strstr(name, "SUN") != NULL) ||
  44          (strstr(name, "SGI") != NULL);
  45 }
  46
  47 char* get_arg_type(char* s)
  48 {
  49   while(*s == ' ' || *s == '\t') s++;
  50   char* n = s;
  51   char* c = strstr(n, "const");
  52   if (c)
  53     n += 6;
  54
  55   char* t = strstr(n, " ");
  56   if (t)
  57   {
  58     if (t[1] == '*')
  59       t += 2;
  60     t[0] = 0;
  61     char* ori = t;
  62     t = strstr(t+1, "[");
  63     if (t)
  64     {
  65       memmove(ori, t, strlen(t));
  66       strstr(ori, "]")[1] = 0;
  67     }
  68   }
  69   return strdup(s);
  70 }
  71
  72 typedef struct
  73 {
  74   char* type;
  75   char* name;
  76   int nargs;
  77   char** args;
  78   int ok;
  79   int just_for_server_side;
  80   int has_out_parameters;
  81   int isExt;
  82 } FuncDesc;
  83
  84 int isExt(FuncDesc* func)
  85 {
  86   return func->isExt;
  87 }
  88
  89 char* get_type_string(char* type)
  90 {
  91   if (strstr(type, "[16]"))
  92   {
  93     if (strstr(type, "float"))
  94       return ("TYPE_16FLOAT");
  95     else if (strstr(type, "double"))
  96       return ("TYPE_16DOUBLE");
  97     else
  98     {
  99       printf("inconnu %s\n", type);
 100       exit(-1);
 101     }
 102   }
 103   else if (strstr(type, "[128]") && strstr(type, "GLubyte"))
 104     return strstr(type, "const") ? "TYPE_128UCHAR" : "TYPE_OUT_128UCHAR";
 105   else if (strstr(type, "const GLvoid *"))
 106     return "TYPE_ARRAY_VOID";
 107   else if (strstr(type, "const GLchar *") ||
 108            strstr(type, "const GLcharARB *"))
 109     return "TYPE_NULL_TERMINATED_STRING";
 110   else if (strstr(type, "const GLbyte *"))
 111     return "TYPE_ARRAY_SIGNED_CHAR";
 112   else if (strstr(type, "const GLubyte *"))
 113     return "TYPE_ARRAY_UNSIGNED_CHAR";
 114   else if (strstr(type, "const GLshort *"))
 115     return "TYPE_ARRAY_SHORT";
 116   else if (strstr(type, "const GLushort *") ||
 117            strstr(type, "const GLhalfNV *"))
 118     return "TYPE_ARRAY_UNSIGNED_SHORT";
 119   else if (strstr(type, "const GLint *"))
 120     return "TYPE_ARRAY_INT";
 121   else if (strstr(type, "const GLuint *") ||
 122            strstr(type, "const GLenum *"))
 123     return "TYPE_ARRAY_UNSIGNED_INT";
 124   else if (strstr(type, "const GLfloat *") ||
 125            strstr(type, "const GLclampf *"))
 126     return "TYPE_ARRAY_FLOAT";
 127   else if (strstr(type, "const GLdouble *"))
 128     return "TYPE_ARRAY_DOUBLE";
 129   else if (strstr(type, "GLvoid *"))
 130     return "TYPE_OUT_ARRAY_VOID";
 131   else if (strstr(type, "GLboolean *") ||
 132            strstr(type, "GLubyte *"))
 133     return "TYPE_OUT_ARRAY_UNSIGNED_CHAR";
 134   else if (strstr(type, "GLcharARB *") ||
 135            strstr(type, "GLchar *"))
 136     return "TYPE_OUT_ARRAY_CHAR";
 137   else if (strstr(type, "GLshort *"))
 138     return "TYPE_OUT_ARRAY_SHORT";
 139   else if (strstr(type, "GLushort *"))
 140     return "TYPE_OUT_ARRAY_UNSIGNED_SHORT";
 141   else if (strstr(type, "GLint *")||
 142            strstr(type, "GLsizei *"))
 143     return "TYPE_OUT_ARRAY_INT";
 144   else if (strstr(type, "GLuint *") ||
 145            strstr(type, "GLenum *") ||
 146            strstr(type, "GLhandleARB *"))
 147     return "TYPE_OUT_ARRAY_UNSIGNED_INT";
 148   else if (strstr(type, "GLfloat *"))
 149     return "TYPE_OUT_ARRAY_FLOAT";
 150   else if (strstr(type, "GLdouble *"))
 151     return "TYPE_OUT_ARRAY_DOUBLE";
 152   else if (strcmp(type, "void") == 0)
 153     return("TYPE_NONE");
 154   else if (strcmp(type, "GLbyte") == 0)
 155     return("TYPE_CHAR");
 156   else if (strcmp(type, "GLubyte") == 0 ||
 157            strcmp(type, "GLboolean") == 0)
 158     return("TYPE_UNSIGNED_CHAR");
 159   else if (strcmp(type, "GLshort") == 0)
 160     return("TYPE_SHORT");
 161   else if (strcmp(type, "GLushort") == 0 ||
 162            strcmp(type, "GLhalfNV") == 0)
 163     return("TYPE_UNSIGNED_SHORT");
 164   else if (strcmp(type, "GLint") == 0 ||
 165            strcmp(type, "GLsizei") == 0 ||
 166            strcmp(type, "GLintptr") == 0 ||
 167            strcmp(type, "GLsizeiptr") == 0 ||
 168            strcmp(type, "GLintptrARB") == 0 ||
 169            strcmp(type, "GLsizeiptrARB") == 0)
 170     return("TYPE_INT");
 171   else if (strcmp(type, "GLenum") == 0 ||
 172            strcmp(type, "GLuint") == 0 ||
 173            strcmp(type, "GLhandleARB") == 0 ||
 174            strcmp(type, "GLbitfield") == 0)
 175     return("TYPE_UNSIGNED_INT");
 176   else if (strcmp(type, "GLfloat") == 0 ||
 177            strcmp(type, "GLclampf") == 0)
 178     return("TYPE_FLOAT");
 179   else if (strcmp(type, "GLdouble") == 0 ||
 180            strcmp(type, "GLclampd") == 0)
 181     return("TYPE_DOUBLE");
 182   else
 183   {
 184     printf("inconnu %s\n", type);
 185     exit(-1);
 186   }
 187 }
 188
 189 typedef struct
 190 {
 191   char* letter;
 192   char* signature_type_name;
 193   char* gl_c_type_name;
 194   char* c_type_name;
 195 } ForIsKnownArgVector;
 196
 197 #define N_ELEMENTS(x)  (sizeof(x)/sizeof(x[0]))
 198 #define N_FIELDS_IN_ARG_VECTOR  4
 199
 200
 201 typedef struct
 202 {
 203   char* func_name;
 204   char* signature_type_name;
 205 } KnownLastArgFunc;
 206
 207 static KnownLastArgFunc knownLastArgFuncs[] =
 208 {
 209 {"glFogCoordfv", "TYPE_1FLOAT"},
 210 {"glFogCoorddv", "TYPE_1DOUBLE"},
 211 {"glFogCoordfvEXT", "TYPE_1FLOAT"},
 212 {"glFogCoorddvEXT", "TYPE_1DOUBLE"},
 213 {"glFogCoordhvNV", "TYPE_1USHORT"},
 214
 215 {"glGetFenceivNV", "TYPE_OUT_1INT"},
 216
 217 {"glGetTexLevelParameteriv", "TYPE_OUT_1INT" },
 218 {"glGetTexLevelParameterfv", "TYPE_OUT_1FLOAT" },
 219
 220 {"glGetRenderbufferParameterivEXT", "TYPE_OUT_1INT"},
 221 {"glGetFramebufferAttachmentParameterivEXT", "TYPE_OUT_1INT"},
 222 {"glGetFinalCombinerInputParameterivNV", "TYPE_OUT_1INT"},
 223 {"glGetCombinerOutputParameterivNV", "TYPE_OUT_1INT"},
 224 {"glGetCombinerInputParameterivNV", "TYPE_OUT_1INT"},
 225 {"glGetOcclusionQueryivNV", "TYPE_OUT_1INT"},
 226 {"glGetOcclusionQueryuivNV", "TYPE_OUT_1UINT"},
 227 {"glGetObjectParameterivARB", "TYPE_OUT_1INT"},
 228 {"glGetQueryivARB", "TYPE_OUT_1INT"},
 229 {"glGetQueryiv", "TYPE_OUT_1INT"},
 230 {"glGetQueryObjectivARB", "TYPE_OUT_1INT"},
 231 {"glGetQueryObjectiv", "TYPE_OUT_1INT"},
 232 {"glGetQueryObjectuivARB", "TYPE_OUT_1UINT"},
 233 {"glGetQueryObjectuiv", "TYPE_OUT_1UINT"},
 234 {"glGetProgramivARB", "TYPE_OUT_1INT"},
 235 {"glGetProgramiv", "TYPE_OUT_1INT"},
 236 {"glGetProgramivNV", "TYPE_OUT_1INT"},
 237 {"glGetShaderiv", "TYPE_OUT_1INT"},
 238
 239 {"glCombinerParameterfvNV", "TYPE_1FLOAT"},
 240 {"glCombinerParameterivNV", "TYPE_1INT"},
 241
 242 {"glGetFinalCombinerInputParameterfvNV", "TYPE_OUT_1FLOAT"},
 243 {"glGetCombinerOutputParameterfvNV", "TYPE_OUT_1FLOAT"},
 244 {"glGetCombinerInputParameterfvNV", "TYPE_OUT_1FLOAT"},
 245 {"glGetObjectParameterfvARB", "TYPE_OUT_1FLOAT"},
 246
 247 {"glCombinerStageParameterfvNV", "TYPE_4FLOAT"},
 248 {"glGetCombinerStageParameterfvNV", "TYPE_OUT_4FLOAT"},
 249
 250 {"glTexBumpParameterivATI", "TYPE_1INT"},
 251 {"glTexBumpParameterfvATI", "TYPE_1FLOAT"},
 252 {"glGetTexBumpParameterivATI", "TYPE_OUT_1INT"},
 253 {"glGetTexBumpParameterfvATI", "TYPE_OUT_1FLOAT"},
 254
 255 {"glGetProgramLocalParameterfvARB", "TYPE_OUT_4FLOAT"},
 256 {"glGetProgramLocalParameterdvARB", "TYPE_OUT_4DOUBLE"},
 257 {"glGetProgramEnvParameterfvARB", "TYPE_OUT_4FLOAT"},
 258 {"glGetProgramEnvParameterdvARB", "TYPE_OUT_4DOUBLE"},
 259 {"glGetProgramLocalParameterIivNV", "TYPE_OUT_1INT"},
 260 {"glGetProgramLocalParameterIuivNV", "TYPE_OUT_1UINT"},
 261 {"glGetProgramEnvParameterIivNV", "TYPE_OUT_1INT"},
 262 {"glGetProgramEnvParameterIuivNV", "TYPE_OUT_1UINT"},
 263
 264 {"glGetProgramParameterfvNV", "TYPE_OUT_4FLOAT"},
 265 {"glGetProgramParameterdvNV", "TYPE_OUT_4DOUBLE"},
 266 {"glGetProgramNamedParameterfvNV", "TYPE_OUT_4FLOAT"},
 267 {"glGetProgramNamedParameterdvNV", "TYPE_OUT_4DOUBLE"},
 268
 269 {"glCullParameterfvEXT", "TYPE_4FLOAT"},
 270 {"glCullParameterdvEXT", "TYPE_4DOUBLE"},
 271
 272 {"glGetTrackMatrixivNV", "TYPE_OUT_1INT"},
 273 {"glExecuteProgramNV", "TYPE_4FLOAT"},
 274
 275 {"glEdgeFlagv", "TYPE_1UCHAR"},
 276
 277 {"glClipPlane", "TYPE_4DOUBLE"},
 278 {"glGetClipPlane", "TYPE_OUT_4DOUBLE"},
 279
 280 {"glSetFragmentShaderConstantATI", "TYPE_4FLOAT"},
 281
 282 {"glGetObjectBufferfvATI", "TYPE_OUT_1FLOAT"},
 283 {"glGetObjectBufferivATI", "TYPE_OUT_1INT"},
 284 {"glGetArrayObjectfvATI", "TYPE_OUT_1FLOAT"},
 285 {"glGetArrayObjectivATI", "TYPE_OUT_1INT"},
 286 {"glGetVariantArrayObjectfvATI", "TYPE_OUT_1FLOAT"},
 287 {"glGetVariantArrayObjectivATI", "TYPE_OUT_1INT"},
 288 {"glGetVertexAttribArrayObjectfvATI", "TYPE_OUT_1FLOAT"},
 289 {"glGetVertexAttribArrayObjectivATI", "TYPE_OUT_1INT"},
 290
 291 {"glPixelTransformParameterivEXT", "TYPE_1INT"},
 292 {"glPixelTransformParameterfvEXT", "TYPE_1FLOAT"},
 293 {"glGetPixelTransformParameterivEXT", "TYPE_OUT_1INT"},
 294 {"glGetPixelTransformParameterfvEXT", "TYPE_OUT_1FLOAT"},
 295
 296 {"glColorTableParameterfv", "TYPE_4FLOAT"},
 297 {"glColorTableParameteriv", "TYPE_4INT"},
 298 {"glGetColorTableParameterfv", "TYPE_OUT_4FLOAT"},
 299 {"glGetColorTableParameteriv", "TYPE_OUT_4INT"},
 300 {"glColorTableParameterfvEXT", "TYPE_4FLOAT"},
 301 {"glColorTableParameterivEXT", "TYPE_4INT"},
 302 {"glGetColorTableParameterfvEXT", "TYPE_OUT_4FLOAT"},
 303 {"glGetColorTableParameterivEXT", "TYPE_OUT_4INT"},
 304
 305 {"glGetMinmaxParameterfv", "TYPE_OUT_1FLOAT"},
 306 {"glGetMinmaxParameteriv", "TYPE_OUT_1INT"},
 307 {"glGetHistogramParameterfv", "TYPE_OUT_1FLOAT"},
 308 {"glGetHistogramParameteriv", "TYPE_OUT_1INT"},
 309 {"glGetMinmaxParameterfvEXT", "TYPE_OUT_1FLOAT"},
 310 {"glGetMinmaxParameterivEXT", "TYPE_OUT_1INT"},
 311 {"glGetHistogramParameterfvEXT", "TYPE_OUT_1FLOAT"},
 312 {"glGetHistogramParameterivEXT", "TYPE_OUT_1INT"},
 313
 314 /* Not sure at all for the 2 followingo ones ! */
 315 {"glGetBooleanIndexedvEXT", "TYPE_OUT_4UCHAR"},
 316 {"glGetIntegerIndexedvEXT", "TYPE_OUT_4INT"},
 317
 318 {"glReferencePlaneSGIX", "TYPE_4DOUBLE"},
 319
 320 {"glGetTransformFeedbackVaryingNV", "TYPE_OUT_1INT"},
 321
 322 };
 323
 324 int is_known_arg_vector(FuncDesc* desc, char** p_signature_type_name, char** p_c_type_name)
 325 {
 326   static ForIsKnownArgVector my_tab[] =
 327   {
 328     { "b", "CHAR", "GLbyte", "signed char" },
 329     { "Boolean", "CHAR", "GLboolean", "unsigned char" },
 330     { "s", "SHORT", "GLshort", "short" },
 331     { "i", "INT", "GLint", "int" },
 332     { "Integer", "INT", "GLint", "int" },
 333     { "ub", "CHAR", "GLubyte", "unsigned char" },
 334     { "h", "SHORT", "GLhalf", "unsigned short" },
 335     { "us", "SHORT", "GLushort", "unsigned short" },
 336     { "ui", "INT", "GLuint", "unsigned int" },
 337     { "Nb", "CHAR", "GLbyte", "signed char" },
 338     { "Ns", "SHORT", "GLshort", "short" },
 339     { "Ni", "INT", "GLint", "int" },
 340     { "Nub", "CHAR", "GLubyte", "unsigned char" },
 341     { "Nus", "SHORT", "GLushort", "unsigned short" },
 342     { "Nui", "INT", "GLuint", "unsigned int" },
 343
 344     { "f", "FLOAT", "GLfloat", "float" },
 345     { "Float", "FLOAT", "GLfloat", "float" },
 346     { "d", "DOUBLE", "GLdouble", "double" },
 347   };
 348
 349   if (desc->nargs == 0)
 350     return 0;
 351
 352   int i , j;
 353
 354   if (strstr(desc->name, "glVertexAttribs") ||
 355       strstr(desc->name, "glProgramParameters") ||
 356       strstr(desc->name, "glProgramEnvParameters") ||
 357       strstr(desc->name, "glProgramLocalParameters") ||
 358       (strstr(desc->name, "glUniform") && (strstr(desc->name, "iv") || strstr(desc->name, "fv"))))
 359     return 0;
 360
 361   static char signatures[N_ELEMENTS(my_tab)][N_FIELDS_IN_ARG_VECTOR][20] = {0};
 362   char signature[10];
 363
 364   for(i=0;i<N_ELEMENTS(knownLastArgFuncs);i++)
 365   {
 366     if (strcmp(desc->name, knownLastArgFuncs[i].func_name) == 0)
 367     {
 368       if (p_signature_type_name)
 369       {
 370         *p_signature_type_name = knownLastArgFuncs[i].signature_type_name;
 371       }
 372       if (p_c_type_name)
 373       {
 374         if (strstr(knownLastArgFuncs[i].signature_type_name, "FLOAT"))
 375           *p_c_type_name = "float";
 376         else if (strstr(knownLastArgFuncs[i].signature_type_name, "DOUBLE"))
 377           *p_c_type_name = "double";
 378         else if (strstr(knownLastArgFuncs[i].signature_type_name, "UINT"))
 379           *p_c_type_name = "unsigned int";
 380         else if (strstr(knownLastArgFuncs[i].signature_type_name, "INT"))
 381           *p_c_type_name = "int";
 382         else if (strstr(knownLastArgFuncs[i].signature_type_name, "USHORT"))
 383           *p_c_type_name = "unsigned short";
 384         else if (strstr(knownLastArgFuncs[i].signature_type_name, "SHORT"))
 385           *p_c_type_name = "short";
 386         else if (strstr(knownLastArgFuncs[i].signature_type_name, "UCHAR"))
 387           *p_c_type_name = "unsigned char";
 388         else if (strstr(knownLastArgFuncs[i].signature_type_name, "CHAR"))
 389           *p_c_type_name = "char";
 390         else
 391           assert(0);
 392       }
 393       return 1;
 394     }
 395   }
 396
 397   for(i=0;i<N_ELEMENTS(my_tab);i++)
 398   {
 399     for(j=1;j<=N_FIELDS_IN_ARG_VECTOR;j++)
 400     {
 401       if (strstr(desc->name, "glIndex") && strstr(desc->name, "v"))
 402         sprintf(signature, "%sv", my_tab[i].letter);
 403       else
 404         sprintf(signature, "%d%sv", j, my_tab[i].letter);
 405       if (strstr(desc->name, signature) &&
 406           strstr(desc->args[desc->nargs - 1], my_tab[i].gl_c_type_name) &&
 407           strstr(desc->args[desc->nargs - 1], "*"))
 408       {
 409         if (p_signature_type_name)
 410         {
 411           if (signatures[i][j-1][0] == 0)
 412             sprintf(signatures[i][j-1], "TYPE_%d%s", j, my_tab[i].signature_type_name);
 413           *p_signature_type_name = signatures[i][j-1];
 414         }
 415         if (p_c_type_name) *p_c_type_name = my_tab[i].c_type_name;
 416         return 1;
 417       }
 418     }
 419   }
 420   return 0;
 421 }
 422
 423 static void print_server_side_argument(FILE* server_stub, int j, char* glType)
 424 {
 425   const char* symbolic_type = get_type_string(glType);
 426   if (strcmp(symbolic_type, "TYPE_CHAR") == 0)
 427     fprintf(server_stub, "ARG_TO_CHAR(args[%d])", j);
 428   else if (strcmp(symbolic_type, "TYPE_UNSIGNED_CHAR") == 0)
 429     fprintf(server_stub, "ARG_TO_UNSIGNED_CHAR(args[%d])", j);
 430   else if (strcmp(symbolic_type, "TYPE_SHORT") == 0)
 431     fprintf(server_stub, "ARG_TO_SHORT(args[%d])", j);
 432   else if (strcmp(symbolic_type, "TYPE_UNSIGNED_SHORT") == 0)
 433     fprintf(server_stub, "ARG_TO_UNSIGNED_SHORT(args[%d])", j);
 434   else if (strcmp(symbolic_type, "TYPE_INT") == 0)
 435     fprintf(server_stub, "ARG_TO_INT(args[%d])", j);
 436   else if (strcmp(symbolic_type, "TYPE_UNSIGNED_INT") == 0)
 437     fprintf(server_stub, "ARG_TO_UNSIGNED_INT(args[%d])", j);
 438   else if (strcmp(symbolic_type, "TYPE_FLOAT") == 0)
 439     fprintf(server_stub, "ARG_TO_FLOAT(args[%d])", j);
 440   else if (strcmp(symbolic_type, "TYPE_16FLOAT") == 0)
 441     fprintf(server_stub, "(const float*)(args[%d])", j);
 442   else if (strcmp(symbolic_type, "TYPE_DOUBLE") == 0)
 443     fprintf(server_stub, "ARG_TO_DOUBLE(args[%d])", j);
 444   else if ( strcmp(symbolic_type, "TYPE_16DOUBLE") == 0)
 445     fprintf(server_stub, "(const double*)(args[%d])", j);
 446   else if ( strcmp(symbolic_type, "TYPE_OUT_128UCHAR") == 0)
 447     fprintf(server_stub, "(unsigned char*)(args[%d])", j);
 448   else if ( strcmp(symbolic_type, "TYPE_128UCHAR") == 0)
 449     fprintf(server_stub, "(const unsigned char*)(args[%d])", j);
 450   else if ( strcmp(symbolic_type, "TYPE_NULL_TERMINATED_STRING") == 0)
 451     fprintf(server_stub, "(const char*)(args[%d])", j);
 452   else if ( strcmp(symbolic_type, "TYPE_ARRAY_SHORT") == 0)
 453     fprintf(server_stub, "(const short*)(args[%d])", j);
 454   else if ( strcmp(symbolic_type, "TYPE_ARRAY_UNSIGNED_SHORT") == 0)
 455     fprintf(server_stub, "(const unsigned short*)(args[%d])", j);
 456   else if ( strcmp(symbolic_type, "TYPE_ARRAY_INT") == 0)
 457     fprintf(server_stub, "(const int*)(args[%d])", j);
 458   else if ( strcmp(symbolic_type, "TYPE_ARRAY_UNSIGNED_INT") == 0)
 459     fprintf(server_stub, "(const unsigned int*)(args[%d])", j);
 460   else if ( strcmp(symbolic_type, "TYPE_ARRAY_FLOAT") == 0)
 461     fprintf(server_stub, "(const float*)(args[%d])", j);
 462   else if ( strcmp(symbolic_type, "TYPE_ARRAY_DOUBLE") == 0)
 463     fprintf(server_stub, "(const double*)(args[%d])", j);
 464   else if ( strcmp(symbolic_type, "TYPE_ARRAY_CHAR") == 0)
 465     fprintf(server_stub, "(const char*)(args[%d])", j);
 466   else if ( strcmp(symbolic_type, "TYPE_ARRAY_SIGNED_CHAR") == 0)
 467     fprintf(server_stub, "(const signed char*)(args[%d])", j);
 468   else if ( strcmp(symbolic_type, "TYPE_ARRAY_VOID") == 0)
 469     fprintf(server_stub, "(const void*)(args[%d])", j);
 470   else if ( strcmp(symbolic_type, "TYPE_ARRAY_UNSIGNED_CHAR") == 0)
 471     fprintf(server_stub, "(const unsigned char*)(args[%d])", j);
 472   else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_SHORT") == 0)
 473     fprintf(server_stub, "(short*)(args[%d])", j);
 474   else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_UNSIGNED_SHORT") == 0)
 475     fprintf(server_stub, "(unsigned short*)(args[%d])", j);
 476   else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_INT") == 0)
 477     fprintf(server_stub, "(int*)(args[%d])", j);
 478   else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_UNSIGNED_INT") == 0)
 479     fprintf(server_stub, "(unsigned int*)(args[%d])", j);
 480   else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_FLOAT") == 0)
 481     fprintf(server_stub, "(float*)(args[%d])", j);
 482   else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_DOUBLE") == 0)
 483     fprintf(server_stub, "(double*)(args[%d])", j);
 484   else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_VOID") == 0)
 485     fprintf(server_stub, "(void*)(args[%d])", j);
 486   else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_CHAR") == 0)
 487     fprintf(server_stub, "(char*)(args[%d])", j);
 488   else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_UNSIGNED_CHAR") == 0)
 489     fprintf(server_stub, "(unsigned char*)(args[%d])", j);
 490
 491   else
 492   {
 493     fprintf(stderr, "Unknown : %s\n", symbolic_type);
 494     assert(0);
 495   }
 496 }
 497
 498 static const char* func_dealt_by_hand[500] = { NULL };
 499
 500
 501 static const char* ignore_func[] =
 502 {
 503   "glGetPointerv",
 504   "glRectdv",
 505   "glRectfv",
 506   "glRectiv",
 507   "glRectsv",
 508   "glMultiDrawArrays",
 509   "glMultiDrawArraysEXT",
 510   "glMultiDrawElements",
 511   "glMultiDrawElementsEXT",
 512   "glUnmapBuffer",
 513   "glUnmapBufferARB",
 514   "glLoadTransposeMatrixf",
 515   "glLoadTransposeMatrixd",
 516   "glMultTransposeMatrixf",
 517   "glMultTransposeMatrixd",
 518   "glLoadTransposeMatrixfARB",
 519   "glLoadTransposeMatrixdARB",
 520   "glMultTransposeMatrixfARB",
 521   "glMultTransposeMatrixdARB",
 522
 523   "glPixelDataRangeNV",
 524   "glFlushPixelDataRangeNV",
 525   "glVertexArrayRangeNV",
 526   "glFlushVertexArrayRangeNV",
 527   "glVertexWeightfEXT",
 528
 529   "glGetBufferPointerv",
 530   "glGetBufferPointervARB",
 531   "glGetVertexAttribPointerv",
 532   "glGetVertexAttribPointervARB",
 533   "glVertexAttribPointer",
 534   "glVertexAttribPointerARB",
 535   "glGetVariantPointervEXT",
 536   NULL,
 537 };
 538
 539 void get_func_dealt_by_hand()
 540 {
 541   FILE* f = fopen(GL_INCLUDE_PATH"gl_func_perso.h", "r");
 542   char buffer[256];
 543   int i = 0;
 544   char* c;
 545   while(fgets(buffer, 256, f))
 546   {
 547     if (strstr(buffer, "MAGIC_MACRO("))
 548     {
 549       func_dealt_by_hand[i] = strdup(strstr(buffer, "MAGIC_MACRO(") + strlen("MAGIC_MACRO("));
 550       * strstr(func_dealt_by_hand[i], ")") = 0;
 551       c = strstr(func_dealt_by_hand[i], "_");
 552       if (c && c != func_dealt_by_hand[i]) *c = 0;
 553       i ++;
 554     }
 555   }
 556   fclose(f);
 557
 558   int j = 0;
 559   while(ignore_func[j])
 560   {
 561     func_dealt_by_hand[i] = ignore_func[j];
 562     i++;
 563     j++;
 564   }
 565 }
 566
 567 static const char* just_for_server_side_list[] =
 568 {
 569   "glEnableClientState",
 570   "glDisableClientState",
 571   "glPushClientAttrib",
 572   "glPopClientAttrib",
 573   "glPixelStorei",
 574   "glPixelStoref",
 575   "glClientActiveTexture",
 576   "glClientActiveTextureARB",
 577   "glEnableVertexAttribArray",
 578   "glEnableVertexAttribArrayARB",
 579   "glDisableVertexAttribArray",
 580   "glDisableVertexAttribArrayARB",
 581   "glDrawElementArrayATI",
 582   "glDrawRangeElementArrayATI",
 583   "glGenSymbolsEXT",
 584   "glFreeObjectBufferATI",
 585   "glUnmapObjectBufferATI",
 586   "glLockArraysEXT",
 587   "glUnlockArraysEXT",
 588   "glDepthFunc",
 589   "glFogf",
 590   "glFogi",
 591   "glClipPlane",
 592   "glGetClipPlane",
 593
 594 /* begin of openquartz optimization */
 595 #if 1
 596   "glMatrixMode",
 597   "glOrtho",
 598   "glFrustum",
 599   "glPushMatrix",
 600   "glPopMatrix",
 601   "glLoadIdentity",
 602   "glLoadMatrixd",
 603   "glLoadMatrixf",
 604   "glMultMatrixd",
 605   "glMultMatrixf",
 606   "glRotated",
 607   "glRotatef",
 608   "glScaled",
 609   "glScalef",
 610   "glTranslated",
 611   "glTranslatef",
 612 #endif
 613 /* end of openquartz optimization */
 614
 615   "glGetError",
 616   "glActiveTextureARB",
 617
 618   "glViewport",
 619   "glScissor",
 620
 621   "glBindBufferARB",
 622   "glDeleteBuffersARB",
 623   "glGenBuffersARB",
 624   "glBufferDataARB",
 625   "glBufferSubDataARB",
 626   "glGetBufferSubDataARB",
 627   "glGetBufferParameterivARB",
 628   "glBindBuffer",
 629   "glDeleteBuffers",
 630   "glGenBuffers",
 631   "glBufferData",
 632   "glBufferSubData",
 633   "glGetBufferSubData",
 634   "glGetBufferParameteriv",
 635
 636   "glPushAttrib",
 637   "glPopAttrib",
 638   "glEnable",
 639   "glDisable",
 640   "glIsEnabled",
 641   "glBindTexture",
 642   "glBindTextureEXT",
 643   "glFogfv",
 644   "glFogiv",
 645   "glBitmap",
 646   "glGetTexImage",
 647   "glReadPixels",
 648   "glDrawPixels",
 649   "glSelectBuffer",
 650   "glFeedbackBuffer",
 651
 652   "glTexImage1D",
 653   "glTexImage2D",
 654   "glTexImage3D",
 655   "glTexSubImage1D",
 656   "glTexSubImage2D",
 657   "glTexSubImage3D",
 658
 659   "glTexImage3DEXT",
 660   "glTexSubImage1DEXT",
 661   "glTexSubImage2DEXT",
 662   "glTexSubImage3DEXT",
 663
 664   "glGetCompressedTexImage",
 665   "glCompressedTexImage1D",
 666   "glCompressedTexImage2D",
 667   "glCompressedTexImage3D",
 668   "glCompressedTexSubImage1D",
 669   "glCompressedTexSubImage2D",
 670   "glCompressedTexSubImage3D",
 671
 672   "glGetCompressedTexImageARB",
 673   "glCompressedTexImage1DARB",
 674   "glCompressedTexImage2DARB",
 675   "glCompressedTexImage3DARB",
 676   "glCompressedTexSubImage1DARB",
 677   "glCompressedTexSubImage2DARB",
 678   "glCompressedTexSubImage3DARB",
 679
 680   "glCallLists",
 681   "glNewList",
 682   "glDeleteLists",
 683   "glGenLists",
 684
 685   "glGenTextures",
 686   "glDeleteTextures",
 687   "glDeleteTexturesEXT",
 688   "glMap1f",
 689   "glMap1d",
 690   "glMap2f",
 691   "glMap2d",
 692   "glGetMapdv",
 693   "glGetMapfv",
 694   "glGetMapiv",
 695   "glGetBooleanv",
 696   "glGetIntegerv",
 697   "glGetFloatv",
 698   "glGetDoublev",
 699
 700   "glGetPixelMapfv",
 701   "glGetPixelMapuiv",
 702   "glGetPixelMapusv",
 703   "glGetProgramStringARB",
 704   "glGetProgramStringNV",
 705   "glArrayElement",
 706   "glDrawArrays",
 707   "glDrawElements",
 708   "glDrawRangeElements",
 709   "glDrawRangeElementsEXT",
 710   "glGetProgramInfoLog",
 711   "glGetTexLevelParameteriv",
 712   "glGetInfoLogARB",
 713   "glGetShaderInfoLog",
 714   "glGetAttachedObjectsARB",
 715   "glGetAttachedShaders",
 716   "glGetActiveUniformARB",
 717   "glGetActiveUniform",
 718   "glGetUniformLocationARB",
 719   "glGetUniformLocation",
 720   "glGetUniformfvARB",
 721   "glGetUniformfv",
 722   "glGetUniformivARB",
 723   "glGetUniformiv",
 724   "glGetUniformuivEXT",
 725   "glGetShaderSourceARB",
 726   "glGetShaderSource",
 727   "glGetActiveAttribARB",
 728   "glGetActiveAttrib",
 729   "glGetAttribLocationARB",
 730   "glGetAttribLocation",
 731
 732   "glNewObjectBufferATI",
 733   "glUpdateObjectBufferATI",
 734
 735   "glSetLocalConstantEXT",
 736   "glSetInvariantEXT",
 737   "glVariantbvEXT",
 738   "glVariantsvEXT",
 739   "glVariantivEXT",
 740   "glVariantfvEXT",
 741   "glVariantdvEXT",
 742   "glVariantubvEXT",
 743   "glVariantusvEXT",
 744   "glVariantuivEXT",
 745   "glGetVariantBooleanvEXT",
 746   "glGetVariantIntegervEXT",
 747   "glGetVariantFloatvEXT",
 748   "glGetInvariantBooleanvEXT",
 749   "glGetInvariantIntegervEXT",
 750   "glGetInvariantFloatvEXT",
 751   "glGetLocalConstantBooleanvEXT",
 752   "glGetLocalConstantIntegervEXT",
 753   "glGetLocalConstantFloatvEXT",
 754
 755   "glMatrixIndexubvARB",
 756   "glMatrixIndexusvARB",
 757   "glMatrixIndexuivARB",
 758
 759   "glColorTable",
 760   "glColorSubTable",
 761   "glGetColorTable",
 762   "glConvolutionFilter1D",
 763   "glConvolutionFilter2D",
 764   "glGetConvolutionFilter",
 765   "glSeparableFilter2D",
 766   "glGetSeparableFilter",
 767   "glGetHistogram",
 768   "glGetMinmax",
 769   "glColorTableEXT",
 770   "glColorSubTableEXT",
 771   "glGetColorTableEXT",
 772   "glConvolutionFilter1DEXT",
 773   "glConvolutionFilter2DEXT",
 774   "glGetConvolutionFilterEXT",
 775   "glSeparableFilter2DEXT",
 776   "glGetSeparableFilterEXT",
 777   "glGetHistogramEXT",
 778   "glGetMinmaxEXT",
 779
 780   "glGetTexParameterfv",
 781
 782   "glGetVertexAttribivARB",
 783   "glGetVertexAttribfvARB",
 784   "glGetVertexAttribdvARB",
 785   "glGetVertexAttribiv",
 786   "glGetVertexAttribfv",
 787   "glGetVertexAttribdv",
 788
 789   "glGetDetailTexFuncSGIS",
 790   "glGetSharpenTexFuncSGIS",
 791
 792   "fake_gluBuild2DMipmaps",
 793
 794   "glRenderMode",
 795
 796   "glEnableVariantClientStateEXT",
 797   "glDisableVariantClientStateEXT",
 798
 799   "glGetActiveVaryingNV",
 800
 801   NULL,
 802 };
 803
 804 static int just_for_server_side_func(char* funcname)
 805 {
 806   int i;
 807   for(i=0;just_for_server_side_list[i];i++)
 808   {
 809     if (strcmp(just_for_server_side_list[i], funcname) == 0)
 810       return 1;
 811   }
 812   return 0;
 813 }
 814
 815 int parse(FILE* f, FuncDesc* funcDesc, int funcDescCount, int ignoreEXT)
 816 {
 817   char buffer[256];
 818   while(fgets(buffer, 256, f))
 819   {
 820
 821     if (strncmp(buffer, "GLAPI", 5) == 0 && strstr(buffer, "APIENTRY") && strstr(buffer, "("))
 822     {
 823       int i = 0;
 824       int skip = 0;
 825       if (func_dealt_by_hand[0] == 0)
 826       {
 827         get_func_dealt_by_hand();
 828       }
 829       while (func_dealt_by_hand[i])
 830       {
 831         if (strstr(buffer, func_dealt_by_hand[i]))
 832         {
 833           skip = 1;
 834           break;
 835         }
 836         i++;
 837       }
 838       if (skip)
 839         continue;
 840
 841       char** args = malloc(15 * sizeof(char*));
 842       int narg = 0;
 843       char* type = buffer + 6;
 844       char* n = strstr(type, "GLAPIENTRY") ? strstr(type, "GLAPIENTRY") : strstr(type, "APIENTRY");
 845       int skip_length = strstr(type, "GLAPIENTRY") ? 11 : 9;
 846       n[-1] = 0;
 847       type = strdup(type);
 848       n += skip_length;
 849       char* fonc = n;
 850       n = strstr(n, "(");
 851       if (n[-1] == ' ') n[-1] = 0;
 852       n[0] = 0;
 853       fonc = strdup(fonc);
 854       /*if (strstr(fonc, "glLockArraysEXT") || strstr(fonc, "glUnlockArraysEXT"))
 855       {
 856       }
 857       else*/
 858
 859
 860       if (ignoreEXT == 1 && isExtByName(fonc))
 861       {
 862         free(type);
 863         free(fonc);
 864         continue;
 865       }
 866       n++;
 867       while(1)
 868       {
 869         char* virg = strstr(n, ",");
 870         if (virg)
 871         {
 872           args[narg] = n;
 873           virg[0] = 0;
 874           args[narg] = get_arg_type(args[narg]);
 875           narg++;
 876           n = virg+1;
 877         }
 878         else
 879           break;
 880       }
 881       while (strstr(n, ")") == 0)
 882       {
 883         fgets(buffer, 256, f);
 884         n = buffer;
 885         while(1)
 886         {
 887           char* virg = strstr(n, ",");
 888           if (virg)
 889           {
 890             args[narg] = n;
 891             virg[0] = 0;
 892             args[narg] = get_arg_type(args[narg]);
 893             narg++;
 894             n = virg+1;
 895           }
 896           else
 897             break;
 898         }
 899       }
 900       char* par = strstr(n, ")");
 901       args[narg] = n;
 902       par[0] = 0;
 903       args[narg] = get_arg_type(args[narg]);
 904       narg++;
 905
 906
 907       /*printf("%s %s (", type, fonc);
 908       for(i=0;i<narg;i++)
 909       {
 910       printf("%s,", args[i]);
 911     }
 912       printf(")\n");*/
 913
 914       for(i=0;i<funcDescCount;i++)
 915       {
 916         if (strcmp(funcDesc[i].name, fonc) == 0)
 917         {
 918           if (ignoreEXT == 0)
 919             funcDesc[i].isExt = 1;
 920           break;
 921         }
 922       }
 923       if (i == funcDescCount)
 924       {
 925         funcDesc[funcDescCount].type = type;
 926         funcDesc[funcDescCount].name = fonc;
 927         funcDesc[funcDescCount].nargs = narg;
 928         funcDesc[funcDescCount].args = args;
 929         funcDesc[funcDescCount].isExt = ignoreEXT == 0;
 930         funcDescCount++;
 931       }
 932       else
 933       {
 934         free(fonc);
 935         free(args);
 936         free(type);
 937       }
 938       /*
 939       for(i=0;i<narg;i++)
 940       {
 941       free(args[i]);
 942     }
 943       free(fonc);
 944       free(type);*/
 945     }
 946   }
 947   return funcDescCount;
 948 }
 949
 950 typedef struct
 951 {
 952   char* str;
 953   int i;
 954 } StringIntStruct;
 955
 956 StringIntStruct argDependingOnPreviousArgTab[] =
 957 {
 958   { "glLoadProgramNV", 3},
 959   { "ProgramNamedParameter", 2},
 960   { "glDeleteBuffers", 1},
 961   { "glDrawBuffers", 1},
 962   { "glGenPrograms", 1},
 963   { "glDeletePrograms", 1},
 964   { "glGenQueries", 1},
 965   { "glDeleteQueries", 1},
 966   { "glGenFencesNV", 1},
 967   { "glDeleteFencesNV", 1},
 968   { "glGenOcclusionQueriesNV", 1},
 969   { "glDeleteOcclusionQueriesNV", 1},
 970   { "glRequestResidentProgramsNV", 1},
 971   { "glDeleteTextures", 1},
 972   { "glGenFramebuffersEXT", 1},
 973   { "glDeleteFramebuffersEXT", 1},
 974   { "glGenRenderbuffersEXT", 1},
 975   { "glDeleteRenderbuffersEXT", 1},
 976   { "glUniform1fv", 2},
 977   { "glUniform2fv", 2},
 978   { "glUniform3fv", 2},
 979   { "glUniform4fv", 2},
 980   { "glUniform1iv", 2},
 981   { "glUniform2iv", 2},
 982   { "glUniform3iv", 2},
 983   { "glUniform4iv", 2},
 984   { "glUniform1uivEXT", 2},
 985   { "glUniform2uivEXT", 2},
 986   { "glUniform3uivEXT", 2},
 987   { "glUniform4uivEXT", 2},
 988   { "glProgramParameters4fvNV", 3},
 989   { "glProgramParameters4dvNV", 3},
 990   { "glProgramLocalParameters4fvEXT", 3},
 991   { "glProgramLocalParametersI4ivNV", 3},
 992   { "glProgramLocalParametersI4uivNV", 3},
 993   { "glProgramEnvParameters4fvEXT", 3},
 994   { "glProgramEnvParametersI4ivNV", 3},
 995   { "glProgramEnvParametersI4uivNV", 3},
 996   { "glAreProgramsResidentNV", 1} ,
 997   { "glAreProgramsResidentNV", 2} ,
 998   { "glAreTexturesResident", 1} ,
 999   { "glAreTexturesResident", 2} ,
1000   { "glPrioritizeTextures", 1} ,
1001   { "glPrioritizeTextures", 2} ,
1002   { "glProgramStringARB", 3} ,
1003
1004   { "glVertexAttribs", 2},
1005
1006   { "glUniformMatrix", 3 },
1007
1008   { "glGetVertexAttribfv", 2},
1009   { "glGetVertexAttribiv", 2},
1010   { "glGetVertexAttribdv", 2},
1011   { "glGetVertexAttribIivEXT", 2},
1012   { "glGetVertexAttribIuivEXT", 2},
1013
1014   { "glPointParameterfv", 1},
1015   { "glPointParameteriv", 1},
1016
1017   { "glWeightbvARB", 1},
1018   { "glWeightsvARB", 1},
1019   { "glWeightivARB", 1},
1020   { "glWeightfvARB", 1},
1021   { "glWeightdvARB", 1},
1022   { "glWeightubvARB", 1},
1023   { "glWeightusvARB", 1},
1024   { "glWeightuivARB", 1},
1025
1026   { "glTexEnvfv", 2},
1027   { "glTexEnviv", 2},
1028   { "glGetTexEnvfv", 2},
1029   { "glGetTexEnviv", 2},
1030   { "glTexGendv", 2},
1031   { "glTexGenfv", 2},
1032   { "glTexGeniv", 2},
1033   { "glGetTexGendv", 2},
1034   { "glGetTexGenfv", 2},
1035   { "glGetTexGeniv", 2},
1036
1037   { "glLightfv", 2},
1038   { "glLightiv", 2},
1039   { "glGetLightfv", 2},
1040   { "glGetLightiv", 2},
1041   { "glFragmentLightfvSGIX", 2},
1042   { "glFragmentLightivSGIX", 2},
1043   { "glGetFragmentLightfvSGIX", 2},
1044   { "glGetFragmentLightivSGIX", 2},
1045
1046
1047   { "glLightModelfv", 1},
1048   { "glLightModeliv", 1},
1049   { "glFragmentLightModelfvSGIX", 1},
1050   { "glFragmentLightModelivSGIX", 1},
1051
1052   { "glMaterialfv", 2},
1053   { "glMaterialiv", 2},
1054   { "glGetMaterialfv", 2},
1055   { "glGetMaterialiv", 2},
1056   { "glFragmentMaterialfvSGIX", 2},
1057   { "glFragmentMaterialivSGIX", 2},
1058   { "glGetFragmentMaterialfvSGIX", 2},
1059   { "glGetFragmentMaterialivSGIX", 2},
1060
1061   { "glFogiv", 1},
1062   { "glFogfv", 1},
1063
1064   { "glTexParameterfv", 2},
1065   { "glTexParameteriv", 2},
1066   { "glGetTexParameterfv", 2},
1067   { "glGetTexParameteriv", 2},
1068
1069   { "glTexParameterIivEXT", 2},
1070   { "glTexParameterIuivEXT", 2},
1071   { "glGetTexParameterIivEXT", 2},
1072   { "glGetTexParameterIuivEXT", 2},
1073
1074   { "glPixelMapfv", 2},
1075   { "glPixelMapuiv", 2},
1076   { "glPixelMapusv", 2},
1077
1078   { "glDetailTexFuncSGIS", 2 },
1079   { "glSharpenTexFuncSGIS", 2 },
1080
1081   { "glSpriteParameterfvSGIX", 1 },
1082   { "glSpriteParameterivSGIX", 1 },
1083
1084   { "ConvolutionParameter", 2},
1085
1086   { "glProgramBufferParametersfvNV", 4},
1087   { "glProgramBufferParametersIivNV", 4},
1088   { "glProgramBufferParametersIuivNV", 4},
1089
1090   { "glTransformFeedbackAttribsNV", 1},
1091   { "glTransformFeedbackVaryingsNV", 2},
1092 };
1093
1094 int is_arg_of_length_depending_on_previous_args(FuncDesc* funcDesc, int j)
1095 {
1096   int i;
1097   if (strstr(funcDesc->args[j], "*") == NULL)
1098     return 0;
1099   for(i=0;i< N_ELEMENTS(argDependingOnPreviousArgTab); i++)
1100   {
1101     if (strstr(funcDesc->name, argDependingOnPreviousArgTab[i].str) && j == argDependingOnPreviousArgTab[i].i)
1102       return 1;
1103   }
1104   return 0;
1105 }
1106
1107 static void fprintf_prototype_args(FILE* f, FuncDesc* funcDesc)
1108 {
1109   int j;
1110   for(j=0;j<funcDesc->nargs;j++)
1111   {
1112     if (j != 0) fprintf(f,", ");
1113     if (strstr(funcDesc->args[j], "[16]"))
1114     {
1115       if (strstr(funcDesc->args[j], "float"))
1116       {
1117         fprintf(f, "const GLfloat arg_%d[16]", j);
1118       }
1119       else if (strstr(funcDesc->args[j], "double"))
1120       {
1121         fprintf(f, "const GLdouble arg_%d[16]", j);
1122       }
1123       else
1124       {
1125         exit(-1);
1126       }
1127     }
1128     else if (strstr(funcDesc->args[j], "[128]") && strstr(funcDesc->args[j], "GLubyte"))
1129       fprintf(f, (strstr(funcDesc->args[j], "const")) ? "const GLubyte* arg_%d" : "GLubyte* arg_%d", j);
1130     else
1131       fprintf(f, "%s arg_%d", funcDesc->args[j], j);
1132   }
1133 }
1134
1135 static void gen_mangled_gl(FuncDesc *funcs_p, int func_cnt)
1136 {
1137     int i;
1138     FILE *header = fopen("gl_mangled.h", "w");
1139     FILE *source = fopen("gl_mangled.c", "w");
1140     char** args;
1141
1142     assert(header && source);
1143
1144     /* Manually add glGetString */
1145     args = malloc(1 * sizeof(char*));
1146     args[0] = strdup("GLenum");
1147     funcs_p[func_cnt].type = strdup("const GLubyte *");
1148     funcs_p[func_cnt].name = strdup("glGetString");
1149     funcs_p[func_cnt].nargs = 1;
1150     funcs_p[func_cnt].args = args;
1151     func_cnt++;
1152
1153     fprintf(header, "/* This file is generated by parse_gl_h.c - DO NOT EDIT ! */\n\n");
1154     fprintf(header, "#include <GL/gl.h>\n\n");
1155     fprintf(header, "typedef struct mglHDL {\n");
1156
1157     for (i = 0; i < func_cnt; ++i) {
1158         fprintf(header, "\t%s (*%s)(", funcs_p[i].type, funcs_p[i].name);
1159         if (funcs_p[i].nargs == 1 && !strncmp(funcs_p[i].args[0], "void",  4)) {
1160             free(funcs_p[i].args[0]);
1161             funcs_p[i].nargs = 0;
1162             fprintf(header, "void");
1163         }
1164         fprintf_prototype_args(header, &funcs_p[i]);
1165         fprintf(header, ");\n");
1166     }
1167     fprintf(header, "} mglHDL;\n\n");
1168
1169     fprintf(header, "extern mglHDL mgl_hdl;\n\n");
1170     fprintf(header, "int mgl_load_symbols(const char *libname);\n");
1171     fprintf(header, "int mgl_unload(void);\n\n");
1172
1173     for (i = 0; i < func_cnt; ++i) {
1174         fprintf(header, "#define %s    mgl_hdl.%s\n", funcs_p[i].name, funcs_p[i].name);
1175     }
1176
1177     fprintf(header, "\n");
1178
1179     fprintf(source, "/* This file is generated by parse_gl_h.c - DO NOT EDIT ! */\n\n");
1180     fprintf(source, "#include <stdio.h>\n#include \"gl_mangled.h\"\n\n");
1181     fprintf(source, "#ifdef _WIN32\n#include <Windows.h>\n"
1182             "typedef HINSTANCE handle_t;\n#else\n#include <dlfcn.h>\n"
1183             "typedef void * handle_t;\n#endif\n\n");
1184     fprintf(source, "mglHDL mgl_hdl;\n");
1185     fprintf(source, "static handle_t mgl_lib_hdl;\n\n");
1186
1187     fprintf(source, "static inline handle_t mgl_load_lib(const char *libname)\n{\n"
1188             "#ifdef _WIN32\n\treturn LoadLibrary(libname);\n"
1189             "#else\n\treturn dlopen(libname, RTLD_LAZY | RTLD_LOCAL);\n"
1190             "#endif\n}\n\n");
1191
1192     fprintf(source, "static inline void *mgl_load_sym(const char *symname)\n{\n"
1193             "#ifdef _WIN32\n\treturn GetProcAddress(mgl_lib_hdl, symname);\n"
1194             "#else\n\treturn dlsym(mgl_lib_hdl, symname);\n"
1195             "#endif\n}\n\n");
1196
1197     fprintf(source, "int mgl_unload(void)\n{\n"
1198             "#ifdef _WIN32\n\treturn FreeLibrary(mgl_lib_hdl);\n"
1199             "#else\n\treturn dlclose(mgl_lib_hdl);\n"
1200             "#endif\n}\n\n");
1201
1202     fprintf(source, "int mgl_load_symbols(const char *libname)\n{\n"
1203             "\tif (!(mgl_lib_hdl = mgl_load_lib(libname))) {\n"
1204             "\t\tfprintf(stderr, \"ERROR: Couldn't load %%s library!\\n\", libname);\n"
1205             "\t\treturn 1;\n\t}\n\n");
1206
1207     for (i = 0; i < func_cnt; ++i) {
1208         fprintf(source, "\tif (!(%s = mgl_load_sym(\"%s\"))) {\n"
1209                 "\t\tmgl_unload();\n\t\t"
1210                 "fprintf(stderr, \"function %s not found!\\n\");\n\t\treturn 1;\n\t}\n\n",
1211                 funcs_p[i].name, funcs_p[i].name, funcs_p[i].name);
1212     }
1213
1214     fprintf(source, "\treturn 0;\n}\n");
1215
1216     for (i = 0; i < func_cnt; ++i) {
1217         free(funcs_p[func_cnt].name);
1218         free(funcs_p[func_cnt].type);
1219         for (; funcs_p[func_cnt].nargs; --funcs_p[func_cnt].nargs) {
1220             free(funcs_p[func_cnt].args[funcs_p[func_cnt].nargs - 1]);
1221         }
1222         free(funcs_p[func_cnt].args);
1223     }
1224
1225     fclose(header);
1226     fclose(source);
1227 }
1228
1229 int main(int argc, char* argv[])
1230 {
1231   FuncDesc funcDesc[3000];
1232   int funcDescCount = 0;
1233   FILE* f;
1234
1235         printf("***** path : %s\n", GL_INCLUDE_PATH"mesa_gl.h");
1236   f = fopen(GL_INCLUDE_PATH"mesa_gl.h", "r");
1237   assert(f);
1238   /*if (!f)
1239     f = fopen("/usr/include/GL/gl.h", "r");*/
1240   funcDescCount = parse(f, funcDesc, 0, 1);
1241   fclose(f);
1242
1243   if ((argc > 1) && !strncmp(argv[1], "mangle", 6)) {
1244       gen_mangled_gl(funcDesc, funcDescCount);
1245       return 0;
1246   }
1247
1248   f = fopen(GL_INCLUDE_PATH"mesa_glext.h", "r");
1249   assert(f);
1250   /*if (!f)
1251     f = fopen("/usr/include/GL/glext.h", "r");*/
1252   funcDescCount = parse(f, funcDesc, funcDescCount, 0);
1253   fclose(f);
1254
1255   FILE* header = fopen("gl_func.h", "w");
1256   FILE* client_stub = fopen("client_stub.c", "w");
1257   FILE* server_stub = fopen("server_stub.c", "w");
1258
1259   fprintf(header, "/* This is a generated file by parse_gl_h.c - DO NOT EDIT ! */\n\n");
1260   fprintf(header, "union gl_ret_type {\n"
1261     "const char *s;\n"
1262     "int i;\n"
1263     "char c;\n"
1264     "};\n");
1265
1266   fprintf(header, "#define COMPOSE(x,y) x##y\n");
1267   fprintf(header, "#define MAGIC_MACRO(x)  COMPOSE(x,_func)\n");
1268   fprintf(header, "enum {\n"
1269                   "#include \"gl_func_perso.h\"\n");
1270
1271   fprintf(client_stub, "/* This is a generated file by parse_gl_h.c - DO NOT EDIT ! */\n\n");
1272
1273   fprintf(server_stub, "/* This is a generated file by parse_gl_h.c - DO NOT EDIT ! */\n\n");
1274
1275   int i;
1276   for(i=0;i<funcDescCount;i++)
1277   {
1278     funcDesc[i].ok = 0;
1279     char* name = funcDesc[i].name;
1280     char* type = funcDesc[i].type;
1281     if ((strcmp(type, "void") == 0 || strcmp(type, "GLboolean") == 0 ||
1282          strcmp(type, "GLuint") == 0 || strcmp(type, "GLint") == 0 ||
1283          strcmp(type, "GLenum") == 0) || strcmp(type, "GLhandleARB") == 0 ||
1284          strcmp(type, "GLhalf") == 0 || strcmp(type, "GLhalfNV") == 0)
1285     {
1286       int pointer_of_unknown_size = 0;
1287       int j;
1288
1289       if (funcDesc[i].nargs == 1 && strcmp(funcDesc[i].args[0], "void") == 0)
1290       {
1291         funcDesc[i].nargs = 0;
1292       }
1293       for(j=0;j<funcDesc[i].nargs-1;j++)
1294       {
1295         if (!is_arg_of_length_depending_on_previous_args(&funcDesc[i], j) &&
1296             strstr(funcDesc[i].args[j], "const GLchar") == NULL &&
1297             strstr(funcDesc[i].args[j], "[16]") == NULL)
1298         {
1299           pointer_of_unknown_size |= strstr(funcDesc[i].args[j], "*") != NULL;
1300           pointer_of_unknown_size |= strstr(funcDesc[i].args[j], "[") != NULL;
1301         }
1302       }
1303
1304       if (pointer_of_unknown_size == 0)
1305       {
1306         char* signature_type_name;
1307         if (is_known_arg_vector(&funcDesc[i], &signature_type_name, NULL))
1308         {
1309           if (strstr(signature_type_name, "TYPE_OUT"))
1310             funcDesc[i].has_out_parameters = 1;
1311         }
1312         else
1313         {
1314           if (funcDesc[i].nargs-1 >= 0)
1315           {
1316             j = funcDesc[i].nargs-1;
1317             if (!is_arg_of_length_depending_on_previous_args(&funcDesc[i], j) &&
1318                 strstr(funcDesc[i].args[j], "const GLchar") == NULL &&
1319                 strstr(funcDesc[i].args[j], "[16]") == NULL)
1320             {
1321               pointer_of_unknown_size |= strstr(funcDesc[i].args[j], "*") != NULL;
1322               pointer_of_unknown_size |= strstr(funcDesc[i].args[j], "[") != NULL;
1323             }
1324           }
1325         }
1326       }
1327       if (pointer_of_unknown_size && funcDesc[i].nargs == 1)
1328       {
1329         if (strstr(funcDesc[i].name, "Matrixf") || strstr(funcDesc[i].name, "Matrixd"))
1330         {
1331           free(funcDesc[i].args[0]);
1332           if (strstr(funcDesc[i].name, "Matrixf"))
1333             funcDesc[i].args[0] = strdup("GLfloat m[16]");
1334           else
1335             funcDesc[i].args[0] = strdup("GLdouble m[16]");
1336           pointer_of_unknown_size = 0;
1337         }
1338         else if (strcmp(funcDesc[i].name, "glPolygonStipple") == 0)
1339         {
1340           free(funcDesc[i].args[0]);
1341           funcDesc[i].args[0] = strdup("const GLubyte mask[128]");
1342           pointer_of_unknown_size = 0;
1343         }
1344         else if (strcmp(funcDesc[i].name, "glGetPolygonStipple") == 0)
1345         {
1346           free(funcDesc[i].args[0]);
1347           funcDesc[i].args[0] = strdup("GLubyte mask[128]");
1348           funcDesc[i].has_out_parameters = 1;
1349           pointer_of_unknown_size = 0;
1350         }
1351       }
1352       if (just_for_server_side_func(name) || pointer_of_unknown_size == 0)
1353       {
1354         fprintf(header, "  %s_func,\n", funcDesc[i].name);
1355         funcDesc[i].ok = 1;
1356         if (just_for_server_side_func(name))
1357           funcDesc[i].just_for_server_side = 1;
1358         for(j=0;j<funcDesc[i].nargs;j++)
1359         {
1360           if (strstr(get_type_string(funcDesc[i].args[j]), "OUT"))
1361             funcDesc[i].has_out_parameters = 1;
1362         }
1363       }
1364       else
1365       {
1366         fprintf(stderr, "not handled either manually or automatically : %s\n", funcDesc[i].name);
1367       }
1368     }
1369   }
1370
1371   fprintf(header, "  GL_N_CALLS\n};\n");
1372
1373
1374   fprintf(server_stub, "void execute_func(int func_number, void **args, union gl_ret_type *pret)\n");
1375   fprintf(server_stub, "{\n");
1376   fprintf(server_stub, "  switch(func_number)\n");
1377   fprintf(server_stub, "  {\n");
1378
1379
1380   for(i=0;i<funcDescCount;i++)
1381   {
1382     if (funcDesc[i].ok)
1383     {
1384       fprintf(header, "static const int %s_signature[] = { %s, %d, ",
1385               funcDesc[i].name,
1386               get_type_string(funcDesc[i].type),
1387               funcDesc[i].has_out_parameters);
1388       fprintf(header, "%d", funcDesc[i].nargs);
1389       int j;
1390       char* signature_type_name;
1391       int n_args_to_check = is_known_arg_vector(&funcDesc[i], &signature_type_name, NULL) ? funcDesc[i].nargs - 1 : funcDesc[i].nargs;
1392
1393       for(j=0;j<n_args_to_check;j++)
1394       {
1395         if (is_arg_of_length_depending_on_previous_args(&funcDesc[i], j))
1396         {
1397           fprintf(header, ", %s_OF_LENGTH_DEPENDING_ON_PREVIOUS_ARGS", get_type_string(funcDesc[i].args[j]));
1398         }
1399         else
1400           fprintf(header, ", %s", get_type_string(funcDesc[i].args[j]));
1401       }
1402
1403       if (is_known_arg_vector(&funcDesc[i], &signature_type_name, NULL))
1404       {
1405         fprintf(header, ", %s", signature_type_name);
1406       }
1407       fprintf(header, "};\n");
1408
1409
1410       if (funcDesc[i].just_for_server_side == 0)
1411       {
1412         if (isExt(&funcDesc[i]))
1413           fprintf(client_stub, "GLAPI %s APIENTRY EXT_FUNC(%s) (", funcDesc[i].type, funcDesc[i].name);
1414         else
1415           fprintf(client_stub, "GLAPI %s APIENTRY %s(", funcDesc[i].type, funcDesc[i].name);
1416         fprintf_prototype_args(client_stub, &funcDesc[i]);
1417         fprintf(client_stub, ")\n");
1418         fprintf(client_stub, "{\n");
1419         if (strcmp(funcDesc[i].type, "void") != 0)
1420         {
1421           fprintf(client_stub, "  %s ret;\n", funcDesc[i].type);
1422           if (isExt(&funcDesc[i]))
1423             fprintf(client_stub, "  CHECK_PROC_WITH_RET(%s);\n", funcDesc[i].name);
1424         }
1425         else
1426         {
1427           if (isExt(&funcDesc[i]))
1428             fprintf(client_stub, "  CHECK_PROC(%s);\n", funcDesc[i].name);
1429         }
1430
1431         /*
1432         fprintf(client_stub, "  do_opengl_call(%s_func, %s",
1433                 funcDesc[i].name, (strcmp(funcDesc[i].type, "void") == 0) ? "NULL" : "&ret");
1434         for(j=0;j<funcDesc[i].nargs;j++)
1435         {
1436           fprintf(client_stub, ", arg_%d", j);
1437         }
1438         fprintf(client_stub, ");\n");
1439         */
1440
1441         if (funcDesc[i].nargs)
1442         {
1443           fprintf(client_stub, "  long args[] = { ");
1444           for(j=0;j<funcDesc[i].nargs;j++)
1445           {
1446             if (j > 0) fprintf(client_stub, ", ");
1447             if (strstr(funcDesc[i].args[j], "*"))
1448             {
1449               fprintf(client_stub, "POINTER_TO_ARG(arg_%d)", j);
1450             }
1451             else
1452             {
1453               const char* symbolic_type = get_type_string(funcDesc[i].args[j]);
1454               if (strcmp(symbolic_type, "TYPE_CHAR") == 0)
1455                 fprintf(client_stub, "CHAR_TO_ARG");
1456               else if (strcmp(symbolic_type, "TYPE_UNSIGNED_CHAR") == 0)
1457                 fprintf(client_stub, "UNSIGNED_CHAR_TO_ARG");
1458               else if (strcmp(symbolic_type, "TYPE_SHORT") == 0)
1459                 fprintf(client_stub, "SHORT_TO_ARG");
1460               else if (strcmp(symbolic_type, "TYPE_UNSIGNED_SHORT") == 0)
1461                 fprintf(client_stub, "UNSIGNED_SHORT_TO_ARG");
1462               else if (strcmp(symbolic_type, "TYPE_INT") == 0)
1463                 fprintf(client_stub, "INT_TO_ARG");
1464               else if (strcmp(symbolic_type, "TYPE_UNSIGNED_INT") == 0)
1465                 fprintf(client_stub, "UNSIGNED_INT_TO_ARG");
1466               else if (strcmp(symbolic_type, "TYPE_FLOAT") == 0)
1467                 fprintf(client_stub, "FLOAT_TO_ARG");
1468               else if (strcmp(symbolic_type, "TYPE_16FLOAT") == 0)
1469                 fprintf(client_stub, "POINTER_TO_ARG");
1470               else if (strcmp(symbolic_type, "TYPE_DOUBLE") == 0)
1471                 fprintf(client_stub, "DOUBLE_TO_ARG");
1472               else if ( strcmp(symbolic_type, "TYPE_16DOUBLE") == 0)
1473                 fprintf(client_stub, "POINTER_TO_ARG");
1474               else if ( strcmp(symbolic_type, "TYPE_128UCHAR") == 0 || strcmp(symbolic_type, "TYPE_OUT_128UCHAR") == 0)
1475                 fprintf(client_stub, "POINTER_TO_ARG");
1476               else
1477               {
1478                 fprintf(stderr, "Unknown : %s\n", symbolic_type);
1479                 assert(0);
1480               }
1481               fprintf(client_stub, "(arg_%d)", j);
1482             }
1483           }
1484           fprintf(client_stub, "};\n");
1485         }
1486
1487         fprintf(client_stub, "  do_opengl_call(%s_func, %s, %s, NULL);\n",
1488                 funcDesc[i].name, (strcmp(funcDesc[i].type, "void") == 0) ? "NULL" : "&ret",
1489                 (funcDesc[i].nargs) ? "args" : "NULL");
1490
1491         if (strcmp(funcDesc[i].type, "void") != 0)
1492         {
1493           fprintf(client_stub, "  return ret;\n");
1494         }
1495         fprintf(client_stub, "}\n\n");
1496       }
1497
1498       fprintf(server_stub, "    case %s_func:\n", funcDesc[i].name);
1499       fprintf(server_stub, "    {\n");
1500
1501       if (isExt(&funcDesc[i]))
1502       {
1503         fprintf(server_stub, "      GET_EXT_PTR(%s, %s, (", funcDesc[i].type, funcDesc[i].name);
1504         fprintf_prototype_args(server_stub, &funcDesc[i]);
1505         fprintf(server_stub, "));\n");
1506       }
1507
1508       fprintf(server_stub, "      ");
1509
1510       if (strcmp(funcDesc[i].type, "void") == 0)
1511         ;
1512       else if (strcmp(get_type_string(funcDesc[i].type), "TYPE_INT") == 0 ||
1513                strcmp(get_type_string(funcDesc[i].type), "TYPE_UNSIGNED_INT") == 0)
1514         fprintf(server_stub, "pret->i = ");
1515       else if (strcmp(get_type_string(funcDesc[i].type), "TYPE_CHAR") == 0 ||
1516                strcmp(get_type_string(funcDesc[i].type), "TYPE_UNSIGNED_CHAR") == 0)
1517         fprintf(server_stub, "pret->c = ");
1518       else
1519       {
1520         fprintf(stderr, "unknown ret type = %s\n", get_type_string(funcDesc[i].type));
1521         exit(-1);
1522       }
1523       /*if (strstr(funcDesc[i].name, "EXT"))
1524       {
1525         char* dup = strdup(funcDesc[i].name);
1526         *strstr(dup, "EXT") = 0;
1527         fprintf(server_stub, "%s(", dup);
1528         free(dup);
1529       }
1530       else*/
1531       {
1532         if (isExt(&funcDesc[i]))
1533           fprintf(server_stub, "ptr_func_%s(", funcDesc[i].name);
1534         else
1535           fprintf(server_stub, "%s(", funcDesc[i].name);
1536       }
1537       char* c_type_name;
1538       if (is_known_arg_vector(&funcDesc[i], NULL, &c_type_name))
1539       {
1540         for(j=0;j<funcDesc[i].nargs - 1;j++)
1541         {
1542           if (j != 0) fprintf(server_stub,", ");
1543           print_server_side_argument(server_stub, j, funcDesc[i].args[j]);
1544         }
1545         if (j != 0) fprintf(server_stub,", ");
1546         if (strstr(funcDesc[i].args[funcDesc[i].nargs - 1], "const"))
1547           fprintf(server_stub, "(const %s*)args[%d]", c_type_name, j);
1548         else
1549           fprintf(server_stub, "(%s*)args[%d]", c_type_name, j);
1550       }
1551       else
1552       {
1553         for(j=0;j<funcDesc[i].nargs;j++)
1554         {
1555           if (j != 0) fprintf(server_stub,", ");
1556           print_server_side_argument(server_stub, j, funcDesc[i].args[j]);
1557         }
1558       }
1559       fprintf(server_stub, ");\n");
1560
1561       fprintf(server_stub, "      break;\n");
1562       fprintf(server_stub, "    }\n");
1563     }
1564   }
1565
1566   fprintf(server_stub, "    default:\n");
1567   fprintf(server_stub, "      DEBUGF(\"unknown=%%d\", func_number);\n");
1568   fprintf(server_stub, "      break;\n");
1569   fprintf(server_stub, "  }\n");
1570   fprintf(server_stub, "}\n");
1571
1572   fprintf(header, "#undef MAGIC_MACRO\n");
1573   fprintf(header, "#define MAGIC_MACRO(x)  COMPOSE(x,_signature)\n");
1574   fprintf(header, "static const int* tab_opengl_calls[GL_N_CALLS] =\n");
1575   fprintf(header, "{\n");
1576   fprintf(header, "#include \"gl_func_perso.h\"\n");
1577   for(i=0;i<funcDescCount;i++)
1578   {
1579     if (funcDesc[i].ok)
1580     {
1581       fprintf(header, "  %s_signature,\n", funcDesc[i].name);
1582     }
1583   }
1584   fprintf(header, "};\n\n");
1585
1586   fprintf(header, "#undef MAGIC_MACRO\n");
1587   fprintf(header, "#define MAGIC_MACRO(x)  #x\n");
1588   fprintf(header, "static const char* tab_opengl_calls_name[GL_N_CALLS] =\n");
1589   fprintf(header, "{\n");
1590   fprintf(header, "#include \"gl_func_perso.h\"\n");
1591   for(i=0;i<funcDescCount;i++)
1592   {
1593     if (funcDesc[i].ok)
1594     {
1595       fprintf(header, "  \"%s\",\n", funcDesc[i].name);
1596     }
1597   }
1598   fprintf(header, "};\n\n");
1599
1600   fclose(header);
1601   fclose(server_stub);
1602   fclose(client_stub);
1603
1604   return 0;
1605 }