git.oblomov.eu Git - wine/blob - dlls/opengl32/make_opengl

   1 #!/usr/bin/perl -w
   2 use strict;
   3
   4 # This script is called thus :
   5 #
   6 #   make_opengl [opengl_version]
   7 #
   8 #     - It needs files from the OpenGL extension registry:
   9 #
  10 #       http://www.opengl.org/registry/api/gl.spec
  11 #       http://www.opengl.org/registry/api/gl.tm
  12 #       http://www.opengl.org/registry/api/wgl.tm
  13 #       http://www.opengl.org/registry/api/wglext.spec
  14 #
  15 #       If they are not found in the current directory the script will
  16 #       attempt to download them from there.
  17 #
  18 #     - opengl_version is the OpenGL version emulated by the library
  19 #       (can be 1.0 to 1.5). The default is 1.1.
  20 #
  21 # This script generates the three following files :
  22 #
  23 #     - opengl32.spec : the spec file giving all the exported functions
  24 #       of the OpenGL32.DLL library. These functions are the one an
  25 #       application can directly link to (and are all the functions
  26 #       defined in the OpenGL core for the version defined by
  27 #       'opengl_version').
  28 #
  29 #     - opengl_norm.c : this file contains the thunks for all OpenGL
  30 #       functions that are defined in 'opengl32.spec'. The corresponding
  31 #       functions NEED to be defined in Linux's libGL or the library
  32 #       won't be able to be linked in.
  33 #
  34 #     - opengl_ext.c : in this file are stored thunks for ALL possible
  35 #       OpenGL extensions (at least, all the extensions that are defined
  36 #       in the OpenGL extension registry). Contrary to 'opengl_norm.c',
  37 #       you do not need to have these extensions in your libGL to have
  38 #       OpenGL work (as they are resolved at run-time using
  39 #       glXGetProcAddressARB).
  40 #
  41 #     - include/wine/wgl_driver.h: definitions for the tables of OpenGL functions.
  42 #
  43 #
  44 # Copyright 2000 Lionel Ulmer
  45 # Copyright 2012 Alexandre Julliard
  46 #
  47 # This library is free software; you can redistribute it and/or
  48 # modify it under the terms of the GNU Lesser General Public
  49 # License as published by the Free Software Foundation; either
  50 # version 2.1 of the License, or (at your option) any later version.
  51 #
  52 # This library is distributed in the hope that it will be useful,
  53 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  54 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  55 # Lesser General Public License for more details.
  56 #
  57 # You should have received a copy of the GNU Lesser General Public
  58 # License along with this library; if not, write to the Free Software
  59 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  60 #
  61
  62 #
  63 # Files to generate
  64 #
  65 my $spec_file = "opengl32.spec";
  66 my $norm_file = "opengl_norm.c";
  67 my $ext_file  = "opengl_ext.c";
  68
  69 # Set to 0 for removing the ENTER / LEAVE GL calls
  70 my $gen_thread_safe = 0;
  71 # Prefix used for the local variables
  72 my $ext_prefix = "func_";
  73 # If set to 1, generate TRACEs for each OpenGL function
  74 my $gen_traces = 1;
  75
  76 #
  77 # List of categories to put in the 'opengl_norm.c' file
  78 #
  79 my %cat_1_0 = ( "display-list" => 1,
  80              "drawing" => 1,
  81              "drawing-control" => 1,
  82              "feedback" => 1,
  83              "framebuf" => 1,
  84              "misc" => 1,
  85              "modeling" => 1,
  86              "pixel-op" => 1,
  87              "pixel-rw" => 1,
  88              "state-req" => 1,
  89              "xform" => 1,
  90              "VERSION_1_0" => 1,
  91              "VERSION_1_0_DEPRECATED" => 1 );
  92 my %cat_1_1 = ( %cat_1_0,
  93              "VERSION_1_1" => 1,
  94              "VERSION_1_1_DEPRECATED" => 1 );
  95 my %cat_1_2 = ( %cat_1_1,
  96              "VERSION_1_2" => 1,
  97              "VERSION_1_2_DEPRECATED" => 1 );
  98 my %cat_1_3 = ( %cat_1_2,
  99              "VERSION_1_3" => 1,
 100              "VERSION_1_3_DEPRECATED" => 1 );
 101 my %cat_1_4 = ( %cat_1_3,
 102              "VERSION_1_4" => 1,
 103              "VERSION_1_4_DEPRECATED" => 1 );
 104 my %cat_1_5 = ( %cat_1_4,
 105              "VERSION_1_5" => 1,
 106              "VERSION_1_5_DEPRECATED" => 1 );
 107
 108 my %norm_categories = ();
 109
 110 #
 111 # This hash table gives the conversion between OpenGL types and what
 112 # is used by the TRACE printfs
 113 #
 114 my %debug_conv =
 115     ("GLbitfield" => "%d",
 116      "GLboolean" => "%d",
 117      "GLbyte" => "%d",
 118      "GLclampd" => "%f",
 119      "GLclampf" => "%f",
 120      "GLdouble" => "%f",
 121      "GLenum" => "%d",
 122      "GLfloat" => "%f",
 123      "GLint" => "%d",
 124      "GLshort" => "%d",
 125      "GLsizei" => "%d",
 126      "GLstring" => "%s",
 127      "GLubyte" => "%d",
 128      "GLuint" => "%d",
 129      "GLushort" => "%d",
 130      "GLhalfNV" => "%d",
 131      "GLintptrARB" => "%ld",
 132      "GLsizeiptrARB" => "%ld",
 133      "GLintptr" => "%ld",
 134      "GLsizeiptr" => "%ld",
 135      "GLhandleARB" => "%d",
 136      "GLcharARB" => "%c",
 137      "GLvoid" => "(void)",
 138      "_GLfuncptr" => "%p",
 139      "GLDEBUGPROC" => "%p",
 140      "GLDEBUGPROCARB" => "%p",
 141      "GLDEBUGPROCAMD" => "%p",
 142      "GLvdpauSurfaceNV" => "%ld",
 143      "int" => "%d",
 144      "unsigned int" => "%u",
 145      "UINT" => "%u",
 146      "DWORD" => "%u",
 147      "BOOL" => "%u",
 148      "INT64" => "%s,wine_dbgstr_longlong(%s)",
 149      "UINT64" => "%s,wine_dbgstr_longlong(%s)",
 150      "LPVOID" => "%p",
 151      "HANDLE" => "%p",
 152      "HDC" => "%p",
 153      "HGLRC" => "%p",
 154      "HPBUFFERARB" => "%p",
 155      "HPBUFFEREXT" => "%p",
 156     );
 157
 158 #
 159 # This hash table gives the conversion between OpenGL types and what
 160 # is used in the .spec and header files.
 161 #
 162 my %arg_conv =
 163     ("GLbitfield" =>       [ "long", "unsigned int" ],
 164      "GLboolean" =>        [ "long", "unsigned char" ],
 165      "GLbyte" =>           [ "long", "signed char" ],
 166      "GLchar" =>           [ "long", "char" ],
 167      "GLclampd" =>         [ "double", "double" ],
 168      "GLclampf" =>         [ "float", "float" ],
 169      "GLdouble" =>         [ "double", "double" ],
 170      "GLenum" =>           [ "long", "unsigned int" ],
 171      "GLfloat" =>          [ "float", "float" ],
 172      "GLint" =>            [ "long", "int" ],
 173      "GLint64" =>          [ "int64", "INT64" ],
 174      "GLintptr" =>         [ "long", "INT_PTR" ],
 175      "GLshort" =>          [ "long", "short" ],
 176      "GLsizei" =>          [ "long", "int" ],
 177      "GLsizeiptr" =>       [ "long", "INT_PTR" ],
 178      "GLstring" =>         [ "str", "const unsigned char *" ],
 179      "GLsync" =>           [ "ptr", "struct __GLsync *" ],
 180      "GLubyte" =>          [ "long", "unsigned char" ],
 181      "GLuint" =>           [ "long", "unsigned int" ],
 182      "GLuint64" =>         [ "int64", "UINT64" ],
 183      "GLushort" =>         [ "long", "unsigned short" ],
 184      "GLvoid" =>           [ "void", "void" ],
 185      "GLcharARB" =>        [ "long", "char" ],
 186      "GLhandleARB" =>      [ "long", "unsigned int" ],
 187      "GLintptrARB" =>      [ "long", "INT_PTR" ],
 188      "GLsizeiptrARB" =>    [ "long", "INT_PTR" ],
 189      "GLhalfNV" =>         [ "long", "unsigned short" ],
 190      "GLvdpauSurfaceNV" => [ "long", "INT_PTR" ]);
 191
 192 #
 193 # Used to convert some types
 194 #
 195 sub ConvertType($)
 196 {
 197     my ($type) = @_;
 198
 199     my %hash = (
 200               "struct _cl_context" => "void",
 201               "struct _cl_event" => "void",
 202               "HGLRC" => "struct wgl_context *",
 203               "GLDEBUGPROC" => "void *",
 204               "GLDEBUGPROCARB" => "void *",
 205               "GLDEBUGPROCAMD" => "void *",
 206               "HPBUFFERARB" => "struct wgl_pbuffer *",
 207               "HPBUFFEREXT" => "struct wgl_pbuffer *",
 208         );
 209
 210     foreach my $org (reverse sort keys %hash) {
 211         if ($type =~ /$org/) {
 212             my ($before, $after) = ($type =~ /^(.*)$org(.*)$/);
 213             return "$before$hash{$org}$after";
 214         }
 215     }
 216     return $type;
 217 }
 218
 219 #
 220 # Used to convert some variable names
 221 #
 222 sub ConvertVarName($)
 223 {
 224     my ($type) = @_;
 225
 226     my %hash = ( "near" => "nearParam",
 227                  "far"  => "farParam" );
 228
 229     foreach my $org (keys %hash) {
 230         if ($type =~ /$org/) {
 231             my ($before, $after) = ($type =~ /^(.*)$org(.*)$/);
 232             return "$before$hash{$org}$after";
 233         }
 234     }
 235     return $type;
 236 }
 237
 238 #
 239 # This functions generates the thunk for a given function.
 240 #
 241 sub GenerateThunk($$$$)
 242 {
 243     my ($name, $func_ref, $comment, $prefix) = @_;
 244     my $ret = "";
 245     my $call_arg = "";
 246     my $trace_call_arg = "";
 247     my $trace_arg = "";
 248
 249     return "" if $name eq "glDebugEntry";
 250     return "" if $name eq "glGetString";
 251     return "" if $func_ref->[2] && $func_ref->[2] =~ /WGL_/;
 252
 253     # If for opengl_norm.c, generate a nice heading otherwise Patrik won't be happy :-)
 254     # Patrik says: Well I would be even happier if a (OPENGL32.@) was added as well. Done. :-)
 255     if ($comment eq 1) {
 256         $ret = "$ret/***********************************************************************\n";
 257         $ret = "$ret *              $name (OPENGL32.\@)\n";
 258         $ret = "$ret */\n";
 259     }
 260     $ret = $ret . ConvertType($func_ref->[0]) . " WINAPI $name( ";
 261     for (my $i = 0; $i < @{$func_ref->[1]}; $i++) {
 262         ## Quick debug code :-)
 263         ## print $func_ref->[1]->[$i]->[1] . "\n";
 264         my $type = $func_ref->[1]->[$i]->[0];
 265         my $name = ConvertVarName($func_ref->[1]->[$i]->[1]);
 266         $ret .= ConvertType($type) . " $name";
 267         $call_arg .= $name;
 268         if ($type =~ /\*/) {
 269             $trace_arg .= "%p";
 270             $trace_call_arg .= $name;
 271         } elsif (defined $debug_conv{$type}) {
 272             if ($debug_conv{$type} =~ /(.*),(.*)/)
 273             {
 274                 $trace_arg .= $1;
 275                 $trace_call_arg .= sprintf $2, $name;
 276             }
 277             else
 278             {
 279                 $trace_arg .= $debug_conv{$type};
 280                 $trace_call_arg .= $name;
 281             }
 282         }
 283         else { printf "Unknown type %s\n", $type; }
 284         if ($i+1 < @{$func_ref->[1]}) {
 285             $ret .= ", ";
 286             $call_arg .= ", ";
 287             $trace_call_arg .= ", ";
 288             $trace_arg .= ", ";
 289         } else {
 290             $ret .= " ";
 291             $call_arg .= " ";
 292             $trace_call_arg .= " ";
 293         }
 294     }
 295     $ret .= 'void ' if (!@{$func_ref->[1]});
 296     $ret .= ") {\n";
 297     $ret .= "  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;\n";
 298     if ($func_ref->[0] ne "void" && $gen_thread_safe) {
 299         $ret = "$ret  " . ConvertType($func_ref->[0]) . " ret_value;\n";
 300     }
 301     if ($gen_traces) {
 302         $ret = "$ret  TRACE(\"($trace_arg)\\n\"";
 303         if ($trace_arg ne "") {
 304             $ret .= ", $trace_call_arg";
 305         }
 306         $ret = "$ret);\n";
 307     }
 308     if ($gen_thread_safe) {
 309         $ret .= "  ENTER_GL();\n";
 310         $ret .= "  ";
 311         if ($func_ref->[0] ne "void") {
 312             $ret .= "ret_value = ";
 313         }
 314         $ret .= "funcs->$prefix.p_$name( $call_arg);\n";
 315         $ret .= "  LEAVE_GL();\n";
 316         if ($func_ref->[0] ne "void") {
 317             $ret .= "  return ret_value;\n"
 318         }
 319     }
 320     else {
 321         $ret .= "  ";
 322         if ($func_ref->[0] ne "void") {
 323             $ret .= "return ";
 324         }
 325         $ret .= "funcs->$prefix.p_$name( $call_arg);\n";
 326     }
 327     $ret = "$ret}\n";
 328
 329     # Return this string....
 330     return $ret;
 331 }
 332
 333 sub generate_null_func($$)
 334 {
 335     my ($name, $func_ref) = @_;
 336     my $ret;
 337
 338     return "" if $name eq "glDebugEntry";
 339
 340     $ret = "static " . ConvertType($func_ref->[0]) . " null_$name( ";
 341     for (my $i = 0; $i < @{$func_ref->[1]}; $i++) {
 342         my $type = $func_ref->[1]->[$i]->[0];
 343         my $name = ConvertVarName($func_ref->[1]->[$i]->[1]);
 344         $ret .= ConvertType($type) . " $name";
 345         $ret .= "," if ($i+1 < @{$func_ref->[1]});
 346         $ret .= " ";
 347     }
 348     $ret .= 'void ' if (!@{$func_ref->[1]});
 349     $ret .= ") {";
 350     if ($name eq "glGetError")
 351     {
 352         $ret .= " return GL_INVALID_OPERATION;";
 353     }
 354     elsif ($func_ref->[0] ne "void")
 355     {
 356         $ret .= " return 0;";
 357     }
 358     $ret .= " }\n";
 359     return $ret;
 360 }
 361
 362 sub get_func_proto($$$)
 363 {
 364     my ($format, $name, $func) = @_;
 365     my $ret = sprintf "%-10s", ConvertType($func->[0]);
 366     $ret .= " " . sprintf($format,$name) . "(";
 367     for (my $i = 0; $i < @{$func->[1]}; $i++)
 368     {
 369         $ret .= ConvertType($func->[1]->[$i]->[0]);
 370         $ret .= "," if ($i+1 < @{$func->[1]});
 371     }
 372     $ret .= "void" unless @{$func->[1]};
 373     $ret .= ")";
 374     return $ret;
 375 }
 376
 377 #
 378 # Extract and checks the number of arguments
 379 #
 380 if (@ARGV > 1) {
 381     my $name0=$0;
 382     $name0=~s%^.*/%%;
 383     die "Usage: $name0 [version]\n";
 384 }
 385 my $version = $ARGV[0] || "1.1";
 386 if ($version eq "1.0") {
 387     %norm_categories = %cat_1_0;
 388 } elsif ($version eq "1.1") {
 389     %norm_categories = %cat_1_1;
 390 } elsif ($version eq "1.2") {
 391     %norm_categories = %cat_1_2;
 392 } elsif ($version eq "1.3") {
 393     %norm_categories = %cat_1_3;
 394 } elsif ($version eq "1.4") {
 395     %norm_categories = %cat_1_4;
 396 } elsif ($version eq "1.5") {
 397     %norm_categories = %cat_1_5;
 398 } else {
 399     die "Incorrect OpenGL version.\n";
 400 }
 401
 402 #
 403 # Fetch the registry files
 404 #
 405 -f "gl.spec" || system "wget http://www.opengl.org/registry/api/gl.spec" || die "cannot download gl.spec";
 406 -f "gl.tm" || system "wget http://www.opengl.org/registry/api/gl.tm" || die "cannot download gl.tm";
 407 -f "wgl.tm" || system "wget http://www.opengl.org/registry/api/wgl.tm" || die "cannot download wgl.tm";
 408 -f "wglext.spec" || system "wget http://www.opengl.org/registry/api/wglext.spec" || die "cannot download wglext.spec";
 409 -f "enum.spec" || system "wget http://www.opengl.org/registry/api/enum.spec" || die "cannot download enum.spec";
 410 -f "enumext.spec" || system "wget http://www.opengl.org/registry/api/enumext.spec" || die "cannot download enumext.spec";
 411
 412 #
 413 # First, create a mapping between the pseudo types used in the spec file
 414 # and OpenGL types using the 'gl.tm' file.
 415 #
 416 my %pseudo_to_opengl = ();
 417
 418 sub load_types($)
 419 {
 420     my $file = shift;
 421     open TYPES, "<$file" or die "Could not open $file";
 422     while (my $line = <TYPES>) {
 423         if ($line !~ /\w*\#/) {
 424             my ($pseudo, $opengl) = ($line =~ /(\w*),\*,\*,\s*(.*),\*,\*/);
 425             $pseudo_to_opengl{$pseudo} = $opengl;
 426         }
 427     }
 428     close TYPES;
 429 }
 430
 431 load_types( "wgl.tm" );
 432 load_types( "gl.tm" );
 433
 434 # This is to override the 'void' -> '*' bogus conversion
 435 $pseudo_to_opengl{"void"} = "void";
 436 $pseudo_to_opengl{"sync"} = "GLvoid*";
 437 $pseudo_to_opengl{"Int64"} = "INT64";
 438 $pseudo_to_opengl{"UInt64"} = "UINT64";
 439 $pseudo_to_opengl{"Int64EXT"} = "INT64";
 440 $pseudo_to_opengl{"UInt64EXT"} = "UINT64";
 441
 442 #
 443 # Then, create the list of all OpenGL functions using the 'gl.spec'
 444 # file. This will create two hash-tables, one with all the function
 445 # whose category matches the one listed in '@norm_categories', the other
 446 # with all other functions.
 447 #
 448 # An element of the hash table is a reference to an array with these
 449 # elements :
 450 #
 451 #  - function name
 452 #
 453 #  - return type
 454 #
 455 #  - reference to an array giving the list of arguments (an empty array
 456 #    for a 'void' function).
 457 #
 458 # The list of arguments is itself an array of reference to arrays. Each
 459 # of these arrays represents the argument type and the argument name.
 460 #
 461 # An example :
 462 #
 463 # void glBitmap( GLsizei width, GLsizei height,
 464 #                GLfloat xorig, GLfloat yorig,
 465 #                GLfloat xmove, GLfloat ymove,
 466 #                const GLubyte *bitmap );
 467 #
 468 # Would give something like that :
 469 #
 470 # [ "glBitmap",
 471 #   "void",
 472 #   [ [ "GLsizei", "width" ],
 473 #     [ "GLsizei", "height" ],
 474 #     [ "GLfloat", "xorig" ],
 475 #     [ "GLfloat", "yorig" ],
 476 #     [ "GLfloat", "xmove" ],
 477 #     [ "GLfloat", "ymove" ],
 478 #     [ "GLubyte *", "bitmap"] ] ];
 479 #
 480 my %norm_functions = ( "glDebugEntry" => [ "GLint", [[ "GLint", "unknown1" ],
 481                                                      [ "GLint", "unknown2" ]] ] );
 482
 483 #
 484 # This stores various extensions NOT part of the GL extension registry but still
 485 # implemented by most OpenGL libraries out there...
 486 #
 487
 488 my %ext_functions  =
 489    (
 490     "glDeleteBufferRegion" => [ "void", [ [ "GLenum", "region" ] ], "GL_KTX_buffer_region" ],
 491     "glReadBufferRegion" => [ "void", [ [ "GLenum", "region" ],
 492                                         [ "GLint", "x" ],
 493                                         [ "GLint", "y" ],
 494                                         [ "GLsizei", "width" ],
 495                                         [ "GLsizei", "height" ] ], "GL_KTX_buffer_region" ],
 496     "glDrawBufferRegion" => [ "void", [ [ "GLenum", "region" ],
 497                                         [ "GLint", "x" ],
 498                                         [ "GLint", "y" ],
 499                                         [ "GLsizei", "width" ],
 500                                         [ "GLsizei", "height" ],
 501                                         [ "GLint", "xDest" ],
 502                                         [ "GLint", "yDest" ] ], "GL_KTX_buffer_region" ],
 503     "glBufferRegionEnabled" => [ "GLuint", [ ], "GL_KTX_buffer_region" ],
 504     "glNewBufferRegion" => [ "GLuint", [ [ "GLenum", "type" ] ], "GL_KTX_buffer_region" ],
 505     "glMTexCoord2fSGIS" => [ "void", [ [ "GLenum", "target" ],
 506                                        [ "GLfloat", "s" ],
 507                                        [ "GLfloat", "t" ] ], "GL_SGIS_multitexture" ],
 508     "glMTexCoord2fvSGIS" => [ "void", [ [ "GLenum", "target" ],
 509                                         [ "GLfloat *", "v" ] ], "GL_SGIS_multitexture" ],
 510     "glMultiTexCoord1dSGIS" => [ "void", [ [ "GLenum", "target" ],
 511                                            [ "GLdouble", "s" ] ],  "GL_SGIS_multitexture" ],
 512     "glMultiTexCoord1dvSGIS" => [ "void", [ [ "GLenum", "target" ],
 513                                             [ "GLdouble *", "v" ] ], "GL_SGIS_multitexture" ],
 514     "glMultiTexCoord1fSGIS" => [ "void", [ [ "GLenum", "target" ],
 515                                            [ "GLfloat", "s" ] ], "GL_SGIS_multitexture" ],
 516     "glMultiTexCoord1fvSGIS" => [ "void", [ [ "GLenum", "target" ],
 517                                             [ "const GLfloat *", "v" ] ], "GL_SGIS_multitexture" ],
 518     "glMultiTexCoord1iSGIS" => [ "void", [ [ "GLenum", "target" ],
 519                                            [ "GLint", "s" ] ], "GL_SGIS_multitexture" ],
 520     "glMultiTexCoord1ivSGIS" => [ "void", [ [ "GLenum", "target" ],
 521                                             [ "GLint *", "v" ] ], "GL_SGIS_multitexture" ],
 522     "glMultiTexCoord1sSGIS" => [ "void", [ [ "GLenum", "target" ],
 523                                            [ "GLshort", "s" ] ], "GL_SGIS_multitexture" ],
 524     "glMultiTexCoord1svSGIS" => [ "void", [ [ "GLenum", "target" ],
 525                                             [ "GLshort *", "v" ] ], "GL_SGIS_multitexture" ],
 526     "glMultiTexCoord2dSGIS" => [ "void", [ [ "GLenum", "target" ],
 527                                            [ "GLdouble", "s"],
 528                                            [ "GLdouble", "t" ] ], "GL_SGIS_multitexture" ],
 529     "glMultiTexCoord2dvSGIS" => [ "void", [ [ "GLenum", "target" ],
 530                                             [ "GLdouble *", "v" ] ], "GL_SGIS_multitexture" ],
 531     "glMultiTexCoord2fSGIS" => [ "void", [ [ "GLenum", "target" ],
 532                                            [ "GLfloat", "s" ],
 533                                            [ "GLfloat", "t" ] ], "GL_SGIS_multitexture" ],
 534     "glMultiTexCoord2fvSGIS" => [ "void", [ [ "GLenum", "target" ],
 535                                             [ "GLfloat *", "v" ] ], "GL_SGIS_multitexture" ],
 536     "glMultiTexCoord2iSGIS" => [ "void", [ [ "GLenum", "target" ],
 537                                            [ "GLint", "s" ],
 538                                            [ "GLint", "t" ] ], "GL_SGIS_multitexture" ],
 539     "glMultiTexCoord2ivSGIS" => [ "void", [ [ "GLenum", "target" ],
 540                                             [ "GLint *", "v" ] ], "GL_SGIS_multitexture" ],
 541     "glMultiTexCoord2sSGIS" => [ "void", [ [ "GLenum", "target" ],
 542                                            [ "GLshort", "s" ],
 543                                            [ "GLshort", "t" ] ], "GL_SGIS_multitexture" ],
 544     "glMultiTexCoord2svSGIS" => [ "void", [ [ "GLenum", "target" ],
 545                                             [ "GLshort *", "v" ] ], "GL_SGIS_multitexture" ],
 546     "glMultiTexCoord3dSGIS" => [ "void", [ [ "GLenum", "target" ],
 547                                            [ "GLdouble", "s" ],
 548                                            [ "GLdouble", "t" ],
 549                                            [ "GLdouble", "r" ] ], "GL_SGIS_multitexture" ],
 550     "glMultiTexCoord3dvSGIS" => [ "void", [ [ "GLenum", "target" ],
 551                                             [ "GLdouble *", "v" ] ], "GL_SGIS_multitexture" ],
 552     "glMultiTexCoord3fSGIS" => [ "void", [ [ "GLenum", "target" ],
 553                                            [ "GLfloat", "s" ],
 554                                            [ "GLfloat", "t" ],
 555                                            [ "GLfloat", "r" ] ], "GL_SGIS_multitexture" ],
 556     "glMultiTexCoord3fvSGIS" => [ "void", [ [ "GLenum", "target" ],
 557                                             [ "GLfloat *", "v" ] ], "GL_SGIS_multitexture" ],
 558     "glMultiTexCoord3iSGIS" => [ "void", [ [ "GLenum", "target" ],
 559                                            [ "GLint", "s" ],
 560                                            [ "GLint", "t" ],
 561                                            [ "GLint", "r" ] ], "GL_SGIS_multitexture" ],
 562     "glMultiTexCoord3ivSGIS" => [ "void", [ [ "GLenum", "target" ],
 563                                             [ "GLint *", "v" ] ], "GL_SGIS_multitexture" ],
 564     "glMultiTexCoord3sSGIS" => [ "void", [ [ "GLenum", "target" ],
 565                                            [ "GLshort", "s" ],
 566                                            [ "GLshort", "t" ],
 567                                            [ "GLshort", "r" ] ], "GL_SGIS_multitexture" ],
 568     "glMultiTexCoord3svSGIS" => [ "void", [ [ "GLenum", "target" ],
 569                                             [ "GLshort *", "v" ] ], "GL_SGIS_multitexture" ],
 570     "glMultiTexCoord4dSGIS" => [ "void", [ [ "GLenum", "target" ],
 571                                            [ "GLdouble", "s" ],
 572                                            [ "GLdouble", "t" ],
 573                                            [ "GLdouble", "r" ],
 574                                            [ "GLdouble", "q" ] ], "GL_SGIS_multitexture" ],
 575     "glMultiTexCoord4dvSGIS" => [ "void", [ [ "GLenum", "target" ],
 576                                             [ "GLdouble *", "v" ] ], "GL_SGIS_multitexture" ],
 577     "glMultiTexCoord4fSGIS" => [ "void", [ [ "GLenum", "target" ],
 578                                            [ "GLfloat", "s" ],
 579                                            [ "GLfloat", "t" ],
 580                                            [ "GLfloat", "r" ],
 581                                            [ "GLfloat", "q" ] ], "GL_SGIS_multitexture" ],
 582     "glMultiTexCoord4fvSGIS" => [ "void", [ [ "GLenum", "target" ],
 583                                             [ "GLfloat *", "v" ] ], "GL_SGIS_multitexture" ],
 584     "glMultiTexCoord4iSGIS" => [ "void", [ [ "GLenum", "target" ],
 585                                            [ "GLint", "s" ],
 586                                            [ "GLint", "t" ],
 587                                            [ "GLint", "r" ],
 588                                            [ "GLint", "q" ] ], "GL_SGIS_multitexture" ],
 589     "glMultiTexCoord4ivSGIS" => [ "void", [ [ "GLenum", "target" ],
 590                                             [ "GLint *", "v" ] ], "GL_SGIS_multitexture" ],
 591     "glMultiTexCoord4sSGIS" => [ "void", [ [ "GLenum", "target" ],
 592                                            [ "GLshort", "s" ],
 593                                            [ "GLshort", "t" ],
 594                                            [ "GLshort", "r" ],
 595                                            [ "GLshort", "q" ] ], "GL_SGIS_multitexture" ],
 596     "glMultiTexCoord4svSGIS" => [ "void", [ [ "GLenum", "target" ],
 597                                             [ "GLshort *", "v" ] ], "GL_SGIS_multitexture" ],
 598     "glMultiTexCoordPointerSGIS" => [ "void", [ [ "GLenum", "target" ],
 599                                                 [ "GLint", "size" ],
 600                                                 [ "GLenum", "type" ],
 601                                                 [ "GLsizei", "stride" ],
 602                                                 [ "GLvoid *", "pointer" ] ], "GL_SGIS_multitexture" ],
 603     "glSelectTextureSGIS" => [ "void", [ [ "GLenum", "target" ] ], "GL_SGIS_multitexture" ],
 604     "glSelectTextureCoordSetSGIS" => [ "void", [ [ "GLenum", "target" ] ], "GL_SGIS_multitexture" ],
 605     "glDeleteObjectBufferATI" => [ "void", [ [ "GLuint", "buffer" ] ], "GL_ATI_vertex_array_object" ],
 606     "wglSetPixelFormatWINE" => [ "BOOL", [ [ "HDC", "hdc" ],
 607                                            [ "int", "format" ] ], "WGL_WINE_pixel_format_passthrough" ],
 608    );
 609
 610
 611 my %wgl_functions =
 612    (
 613     "wglCopyContext" => [ "BOOL", [ [ "struct wgl_context *", "src" ],
 614                                     [ "struct wgl_context *", "dst" ],
 615                                     [ "UINT", "mask" ] ] ],
 616     "wglCreateContext" => [ "struct wgl_context *", [ [ "HDC", "hdc" ] ] ],
 617     "wglDeleteContext" => [ "void", [ [ "struct wgl_context *", "context" ] ] ],
 618     "wglDescribePixelFormat" => [ "INT", [ [ "HDC", "hdc" ],
 619                                            [ "INT", "format" ],
 620                                            [ "UINT", "size" ],
 621                                            [ "PIXELFORMATDESCRIPTOR *", "descr" ] ] ],
 622     "wglGetPixelFormat" => [ "INT", [ [ "HDC", "hdc" ] ] ],
 623     "wglGetProcAddress" => [ "PROC", [ [ "LPCSTR", "name" ] ] ],
 624     "wglMakeCurrent" => [ "BOOL", [ [ "HDC", "hdc" ],
 625                                     [ "struct wgl_context *", "context" ] ] ],
 626     "wglSetPixelFormat" => [ "BOOL", [ [ "HDC", "hdc" ],
 627                                        [ "INT", "format" ],
 628                                        [ "const PIXELFORMATDESCRIPTOR *", "descr" ] ] ],
 629     "wglShareLists" => [ "BOOL", [ [ "struct wgl_context *", "org" ],
 630                                    [ "struct wgl_context *", "dst" ] ] ],
 631     "wglSwapBuffers" => [ "BOOL", [ [ "HDC", "hdc" ] ] ],
 632    );
 633
 634 my %supported_wgl_extensions =
 635    (
 636     "WGL_ARB_create_context" => 1,
 637     "WGL_ARB_extensions_string" => 1,
 638     "WGL_ARB_make_current_read" => 1,
 639     "WGL_ARB_pbuffer" => 1,
 640     "WGL_ARB_pixel_format" => 1,
 641     "WGL_ARB_render_texture" => 1,
 642     "WGL_EXT_extensions_string" => 1,
 643     "WGL_EXT_swap_control" => 1,
 644     "WGL_NV_vertex_array_range" => 1,
 645     "WGL_WINE_pixel_format_passthrough" => 1,
 646    );
 647
 648 sub parse_registry_file($)
 649 {
 650     my $file = shift;
 651     my @arg_names;
 652     my %arg_types;
 653     open REGISTRY, "<$file" or die "cannot open $file";
 654     while (my $line = <REGISTRY>) {
 655         next unless ($line =~ /^\w*\(.*\)/);
 656
 657         # Get the function name (NOTE: the 'gl' prefix needs to be added later)
 658         my ($funcname, $args) = ($line =~ /^(\w*)\((.*)\)/);
 659         # and the argument names
 660         @arg_names = split /\s*,\s*/, $args;
 661
 662         # After get :
 663         #  - the return type
 664         #  - category (the extension the function is part of)
 665         #  - the argument types
 666         #  - the category the function belongs
 667         %arg_types = ();
 668         my $category = "";
 669         my $ret_type = "";
 670         while (1) {
 671             $line = <REGISTRY>;
 672             unless (defined($line)) {
 673                 last;
 674             } elsif ($line =~ /^\s*$/) {
 675                 if (($category eq "") || ($ret_type eq "")) {
 676                     die "Missing 'category' line in function $funcname.\n";
 677                 }
 678                 last;
 679             } elsif ($line =~ /\t*return\t+(\w*)/) {
 680                 ($ret_type) = ($line =~ /\t*return\s*(\w*)/);
 681                 $ret_type = $pseudo_to_opengl{$ret_type};
 682                 unless (defined($ret_type)) {
 683                     die "Unsupported return type in function $funcname\n";
 684                 }
 685             } elsif ($line =~ /^\t*category/) {
 686                 ($category) = ($line =~ /^\t*category\s*([\w-]*)/);
 687             } elsif ($line =~ /^\t*param/) {
 688                 my ($name, $base_type, $dir, $ext) = ($line =~ /\t*param\s*(\w*)\s*(\w*) (in|out)\s+(.*)/);
 689                 my $ptr = 0;
 690                 unless (defined($name)) {
 691                     chomp $line;
 692                     die "Broken spec file line $line in function $funcname\n";
 693                 }
 694
 695                 if ($ext =~ /array/) {
 696                     # This is a pointer
 697                     $ptr = 1;
 698                 } elsif ($ext =~ /reference/) {
 699                     # This is a pointer
 700                     $ptr = 1;
 701                 } elsif ($ext =~ /value/) {
 702                     # And this a 'normal' value
 703                     $ptr = 0;
 704                 } else {
 705                     chomp $line;
 706                     die "Unsupported type : $line in function $funcname\n";
 707                 }
 708                 # Get the 'real' type and append a '*' in case of a pointer
 709                 my $type = $pseudo_to_opengl{$base_type};
 710                 unless (defined($type)) {
 711                     chomp $line;
 712                     die "Unsupported return type in function $funcname for type $base_type (line $line)\n";
 713                 }
 714                 if ($ptr) {
 715                     $type .= "*";
 716                     $type = "const $type" if $dir eq "in";
 717                 }
 718
 719                 $arg_types{$name} = $type;
 720             }
 721         }
 722
 723         # Now, build the argument reference
 724         my $arg_ref = [ ];
 725         for (my $i = 0; $i < @arg_names; $i++) {
 726             unless (defined($arg_types{$arg_names[$i]})) {
 727                 print "@arg_names\n";
 728                 foreach (sort keys %arg_types) {
 729                     print "$_ => $arg_types{$_}\n";
 730                 }
 731                 die "Undefined type for $arg_names[$i] in function $funcname\n";
 732             }
 733
 734             push @$arg_ref, [ $arg_types{$arg_names[$i]}, $arg_names[$i] ];
 735         }
 736
 737         # Now, put in one or the other hash table
 738         if ($norm_categories{$category}) {
 739             $norm_functions{"gl$funcname"} = [ $ret_type, $arg_ref ];
 740         } elsif ($file =~ /^wgl/) {
 741             if (defined $supported_wgl_extensions{"WGL_$category"}) {
 742                 $ext_functions{"wgl$funcname"} = [ $ret_type, $arg_ref, "WGL_$category" ];
 743             }
 744         } else {
 745             $ext_functions{"gl$funcname"} = [ $ret_type, $arg_ref, "GL_$category" ];
 746         }
 747     }
 748     close REGISTRY;
 749 }
 750
 751 sub parse_enum_file($$)
 752 {
 753     my ($file, $enums) = @_;
 754     open FILE, "<$file" or die "cannot open $file";
 755     while (<FILE>)
 756     {
 757         chomp;
 758         next if /^#/;
 759         if (/^\t([0-9A-Z_]+)\s*=\s*(((0x[0-9A-Fa-f]+)|([0-9]+))([uUlL]+)?)/)
 760         {
 761             ${$enums}{"GL_$1"} = $2;
 762             next;
 763         }
 764     }
 765     close FILE;
 766 }
 767
 768 parse_registry_file( "gl.spec" );
 769 parse_registry_file( "wglext.spec" );
 770
 771 my %enums = ();
 772 parse_enum_file( "enum.spec", \%enums );
 773 parse_enum_file( "enumext.spec", \%enums );
 774
 775 #
 776 # Get the current wgl_driver.h version
 777 #
 778 my $wgl_version = 0;
 779 open HEADER, "<../../include/wine/wgl_driver.h" or die "cannot open wgl_driver.h";
 780 while (<HEADER>)
 781 {
 782     next unless /^#define WINE_WGL_DRIVER_VERSION (\d+)/;
 783     $wgl_version = $1;
 784     last;
 785 }
 786 close HEADER;
 787
 788 #
 789 # Generate the wgl_driver.h file
 790 #
 791 open HEADER, ">../../include/wine/wgl_driver.h" or die "cannot create wgl_driver.h";
 792 print HEADER "/* Automatically generated from http://www.opengl.org/registry/api files; DO NOT EDIT! */\n\n";
 793 print HEADER "#ifndef __WINE_WGL_DRIVER_H\n";
 794 print HEADER "#define __WINE_WGL_DRIVER_H\n\n";
 795 print HEADER "#ifndef WINE_GLAPI\n";
 796 print HEADER "#define WINE_GLAPI\n";
 797 print HEADER "#endif\n\n";
 798
 799 printf HEADER "#define WINE_WGL_DRIVER_VERSION %u\n\n", $wgl_version + 1;
 800
 801 print HEADER "struct wgl_context;\n";
 802 print HEADER "struct wgl_pbuffer;\n\n";
 803
 804 print HEADER "struct opengl_funcs\n{\n";
 805 print HEADER "    struct\n    {\n";
 806 foreach (sort keys %wgl_functions)
 807 {
 808     printf HEADER "        %s;\n", get_func_proto("(WINE_GLAPI *p_%s)", $_, $wgl_functions{$_});
 809 }
 810 print HEADER "    } wgl;\n\n";
 811
 812 print HEADER "    struct\n    {\n";
 813 foreach (sort keys %norm_functions)
 814 {
 815     next if $_ eq "glDebugEntry";
 816     printf HEADER "        %s;\n", get_func_proto("(WINE_GLAPI *p_%s)", $_, $norm_functions{$_});
 817 }
 818 print HEADER "    } gl;\n\n";
 819
 820 print HEADER "    struct\n    {\n";
 821 foreach (sort keys %ext_functions)
 822 {
 823     printf HEADER "        %s;\n", get_func_proto("(WINE_GLAPI *p_%s)", $_, $ext_functions{$_});
 824 }
 825 print HEADER "    } ext;\n";
 826 print HEADER "};\n\n";
 827
 828 print HEADER "#define ALL_WGL_FUNCS";
 829 foreach (sort keys %norm_functions)
 830 {
 831     next if $_ eq "glDebugEntry";
 832     printf HEADER " \\\n    USE_GL_FUNC(\%s)", $_;
 833 }
 834 print HEADER "\n\n";
 835
 836 print HEADER "extern struct opengl_funcs * CDECL __wine_get_wgl_driver( HDC hdc, UINT version );\n";
 837 print HEADER "extern BOOL CDECL __wine_set_pixel_format( HWND hwnd, int format );\n\n";
 838 print HEADER "#endif /* __WINE_WGL_DRIVER_H */\n";
 839 close HEADER;
 840
 841 #
 842 # Generate the wgl.h file
 843 #
 844 open HEADER, ">../../include/wine/wgl.h" or die "cannot create wgl.h";
 845 print HEADER "/* Automatically generated from http://www.opengl.org/registry/api files; DO NOT EDIT! */\n\n";
 846 print HEADER "#ifndef __WINE_WGL_H\n";
 847 print HEADER "#define __WINE_WGL_H\n\n";
 848
 849 print HEADER "#ifndef GLAPIENTRY\n";
 850 print HEADER "#define GLAPIENTRY __stdcall\n";
 851 print HEADER "#endif\n\n";
 852
 853 foreach (sort keys %arg_conv)
 854 {
 855     printf HEADER "typedef %-22s %s;\n", $arg_conv{$_}[1], $_;
 856 }
 857 print HEADER "\n";
 858
 859 my $maxlen = 1;
 860 foreach (keys %enums) { $maxlen = length($_) if length($_) > $maxlen; }
 861 foreach (sort keys %enums)
 862 {
 863     printf HEADER "#define %-*s %s\n", $maxlen, $_, $enums{$_};
 864 }
 865 print HEADER "\n";
 866
 867 foreach (sort keys %norm_functions)
 868 {
 869     printf HEADER "%s;\n", get_func_proto("GLAPIENTRY %s", $_, $norm_functions{$_});
 870 }
 871
 872 print HEADER "\n#endif /* __WINE_WGL_H */\n";
 873 close HEADER;
 874
 875 #
 876 # Now, generate the output files. First, the spec file.
 877 #
 878 open(SPEC, ">$spec_file");
 879
 880 foreach (sort keys %norm_functions) {
 881     my $args=" ";
 882     for (my $i = 0; $i < @{$norm_functions{$_}->[1]}; $i++) {
 883         my $type = $norm_functions{$_}->[1]->[$i]->[0];
 884         if ($type =~ /\*/) {
 885             $args .= "ptr ";
 886         } elsif (defined($arg_conv{$type})) {
 887             $args .= "$@$arg_conv{$type}[0] ";
 888         } else {
 889             die "No conversion for GL type $type...\n";
 890         }
 891     }
 892     $args = substr($args,1,-1);
 893     print SPEC "@ stdcall $_($args)\n";
 894 }
 895
 896 print SPEC "@ stdcall wglChoosePixelFormat(long ptr)
 897 @ stdcall wglCopyContext(long long long)
 898 @ stdcall wglCreateContext(long)
 899 @ stdcall wglCreateLayerContext(long long)
 900 @ stdcall wglDeleteContext(long)
 901 @ stdcall wglDescribeLayerPlane(long long long long ptr)
 902 @ stdcall wglDescribePixelFormat(long long long ptr)
 903 @ stdcall wglGetCurrentContext()
 904 @ stdcall wglGetCurrentDC()
 905 @ stub    wglGetDefaultProcAddress
 906 @ stdcall wglGetLayerPaletteEntries(long long long long ptr)
 907 @ stdcall wglGetPixelFormat(long)
 908 @ stdcall wglGetProcAddress(str)
 909 @ stdcall wglMakeCurrent(long long)
 910 @ stdcall wglRealizeLayerPalette(long long long)
 911 @ stdcall wglSetLayerPaletteEntries(long long long long ptr)
 912 @ stdcall wglSetPixelFormat(long long ptr)
 913 @ stdcall wglShareLists(long long)
 914 @ stdcall wglSwapBuffers(long)
 915 @ stdcall wglSwapLayerBuffers(long long)
 916 @ stdcall wglUseFontBitmapsA(long long long long)
 917 @ stdcall wglUseFontBitmapsW(long long long long)
 918 @ stdcall wglUseFontOutlinesA(long long long long long long long ptr)
 919 @ stdcall wglUseFontOutlinesW(long long long long long long long ptr)
 920 ";
 921
 922 close(SPEC);
 923
 924 #
 925 # After the spec file, the opengl_norm.c file
 926 #
 927 open(NORM, ">$norm_file");
 928 print NORM "
 929 /* Auto-generated file... Do not edit ! */
 930
 931 #include \"config.h\"
 932 #include <stdarg.h>
 933 #include \"winternl.h\"
 934 #include \"wingdi.h\"
 935 #include \"wine/wgl.h\"
 936 #include \"wine/wgl_driver.h\"
 937 #include \"wine/debug.h\"
 938
 939 WINE_DEFAULT_DEBUG_CHANNEL(opengl);
 940 ";
 941
 942 foreach (sort keys %norm_functions) {
 943     my $string = GenerateThunk($_, $norm_functions{$_}, 1, "gl");
 944     print NORM "\n$string" if $string;
 945 }
 946
 947 foreach (sort keys %wgl_functions) {
 948     print NORM generate_null_func($_, $wgl_functions{$_});
 949 }
 950 foreach (sort keys %norm_functions) {
 951     print NORM generate_null_func($_, $norm_functions{$_});
 952 }
 953 foreach (sort keys %ext_functions) {
 954     print NORM generate_null_func($_, $ext_functions{$_});
 955 }
 956
 957 print NORM "\nstruct opengl_funcs null_opengl_funcs =\n{\n    {\n";
 958 foreach (sort keys %wgl_functions) { print NORM "        null_$_,\n"; }
 959 print NORM "    },\n    {\n";
 960 foreach (sort keys %norm_functions) { print NORM "        null_$_,\n" unless $_ eq "glDebugEntry"; }
 961 print NORM "    },\n    {\n";
 962 foreach (sort keys %ext_functions) { print NORM "        null_$_,\n"; }
 963 print NORM "    }\n};\n";
 964
 965 close(NORM);
 966
 967 #
 968 # Finally, more complex, the opengl_ext.c file
 969 #
 970 open(EXT, ">$ext_file");
 971 print EXT "
 972 /* Auto-generated file... Do not edit ! */
 973
 974 #include \"config.h\"
 975 #include <stdarg.h>
 976 #include \"opengl_ext.h\"
 977 #include \"winternl.h\"
 978 #include \"wingdi.h\"
 979 #include \"wine/wgl.h\"
 980 #define WGL_WGLEXT_PROTOTYPES
 981 #include \"wine/wglext.h\"
 982 #include \"wine/wgl_driver.h\"
 983 #include \"wine/debug.h\"
 984
 985 WINE_DEFAULT_DEBUG_CHANNEL(opengl);
 986
 987 ";
 988
 989 # The thunks themselves....
 990 my $count = keys %ext_functions;
 991 print EXT "const int extension_registry_size = $count;\n";
 992 foreach (sort keys %ext_functions) {
 993     my $string = GenerateThunk($_, $ext_functions{$_}, 0, "ext");
 994     print EXT "\nstatic $string" if $string;
 995 }
 996
 997 # Then the table giving the string <-> function correspondence */
 998 print EXT "\nconst OpenGL_extension extension_registry[$count] = {\n";
 999 my $i = 0;
1000 foreach (sort keys %ext_functions) {
1001     my $func_ref = $ext_functions{$_};
1002     print EXT "  { \"$_\", \"$func_ref->[2]\", $_ }";
1003     if ($i != $count-1) {
1004         print EXT ",";
1005     }
1006     $i++;
1007     print EXT "\n";
1008 }
1009 print EXT "};\n";
1010
1011 close(EXT);