dlls/opengl32/make_opengl

   1 #!/usr/bin/perl -w
   2 use strict;
   3 use XML::LibXML;
   4
   5 # This script is called thus :
   6 #
   7 #   make_opengl [opengl_version]
   8 #
   9 #     - It needs files from the OpenGL extension registry:
  10 #
  11 #       https://raw.github.com/KhronosGroup/OpenGL-Registry/master/xml/gl.xml
  12 #       https://raw.github.com/KhronosGroup/OpenGL-Registry/master/xml/wgl.xml
  13 #
  14 #       If they are not found in the current directory the script will
  15 #       attempt to download them from there.
  16 #
  17 #     - opengl_version is the OpenGL version emulated by the library
  18 #       (can be 1.0 to 1.5). The default is 1.1.
  19 #
  20 # This script generates the three following files :
  21 #
  22 #     - opengl32.spec : the spec file giving all the exported functions
  23 #       of the OpenGL32.DLL library. These functions are the one an
  24 #       application can directly link to (and are all the functions
  25 #       defined in the OpenGL core for the version defined by
  26 #       'opengl_version').
  27 #
  28 #     - opengl_norm.c : this file contains the thunks for all OpenGL
  29 #       functions that are defined in 'opengl32.spec'. The corresponding
  30 #       functions NEED to be defined in Linux's libGL or the library
  31 #       won't be able to be linked in.
  32 #
  33 #     - opengl_ext.c : in this file are stored thunks for ALL possible
  34 #       OpenGL extensions (at least, all the extensions that are defined
  35 #       in the OpenGL extension registry). Contrary to 'opengl_norm.c',
  36 #       you do not need to have these extensions in your libGL to have
  37 #       OpenGL work (as they are resolved at run-time using
  38 #       glXGetProcAddressARB).
  39 #
  40 #     - include/wine/wgl_driver.h: definitions for the tables of OpenGL functions.
  41 #
  42 #
  43 # Copyright 2000 Lionel Ulmer
  44 # Copyright 2012 Alexandre Julliard
  45 #
  46 # This library is free software; you can redistribute it and/or
  47 # modify it under the terms of the GNU Lesser General Public
  48 # License as published by the Free Software Foundation; either
  49 # version 2.1 of the License, or (at your option) any later version.
  50 #
  51 # This library is distributed in the hope that it will be useful,
  52 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  53 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  54 # Lesser General Public License for more details.
  55 #
  56 # You should have received a copy of the GNU Lesser General Public
  57 # License along with this library; if not, write to the Free Software
  58 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  59 #
  60
  61 #
  62 # Files to generate
  63 #
  64 my $spec_file = "opengl32.spec";
  65 my $norm_file = "opengl_norm.c";
  66 my $ext_file  = "opengl_ext.c";
  67 my $wgl_driver_file = "../../include/wine/wgl_driver.h";
  68 my $wgl_file = "../../include/wine/wgl.h";
  69
  70 # If set to 1, generate TRACEs for each OpenGL function
  71 my $gen_traces = 1;
  72
  73 #
  74 # List of categories to put in the 'opengl_norm.c' file
  75 #
  76 my %cat_1_0 = ( "GL_VERSION_1_0" => 1 );
  77 my %cat_1_1 = ( %cat_1_0, "GL_VERSION_1_1" => 1 );
  78 my %cat_1_2 = ( %cat_1_1, "GL_VERSION_1_2" => 1 );
  79 my %cat_1_3 = ( %cat_1_2, "GL_VERSION_1_3" => 1 );
  80 my %cat_1_4 = ( %cat_1_3, "GL_VERSION_1_4" => 1 );
  81 my %cat_1_5 = ( %cat_1_4, "GL_VERSION_1_5" => 1 );
  82
  83 my %norm_categories = ();
  84
  85 #
  86 # This hash table gives the conversion between OpenGL types and
  87 # the .spec type and debug format
  88 #
  89 my %arg_types =
  90     (
  91      "GLbitfield" =>           [ "long",   "%d" ],
  92      "GLboolean" =>            [ "long",   "%d" ],
  93      "GLbyte" =>               [ "long",   "%d" ],
  94      "GLchar" =>               [ "long",   "%c" ],
  95      "GLcharARB" =>            [ "long",   "%c" ],
  96      "GLclampd" =>             [ "double", "%f" ],
  97      "GLclampf" =>             [ "float",  "%f" ],
  98      "GLclampx" =>             [ "long",   "%d" ],
  99      "GLdouble" =>             [ "double", "%f" ],
 100      "GLeglClientBufferEXT" => [ "ptr",    "%p" ],
 101      "GLeglImageOES" =>        [ "ptr",    "%p" ],
 102      "GLenum" =>               [ "long",   "%d" ],
 103      "GLfixed" =>              [ "long",   "%d" ],
 104      "GLfloat" =>              [ "float",  "%f" ],
 105      "GLhalfNV" =>             [ "long",   "%d" ],
 106      "GLhandleARB" =>          [ "long",   "%d" ],
 107      "GLint" =>                [ "long",   "%d" ],
 108      "GLint64" =>              [ "int64",  "wine_dbgstr_longlong(%s)" ],
 109      "GLint64EXT" =>           [ "int64",  "wine_dbgstr_longlong(%s)" ],
 110      "GLintptr" =>             [ "long",   "%ld" ],
 111      "GLintptrARB" =>          [ "long",   "%ld" ],
 112      "GLshort" =>              [ "long",   "%d" ],
 113      "GLsizei" =>              [ "long",   "%d" ],
 114      "GLsizeiptr" =>           [ "long",   "%ld" ],
 115      "GLsizeiptrARB" =>        [ "long",   "%ld" ],
 116      "GLstring" =>             [ "str",    "wine_dbgstr_a(%s)" ],
 117      "GLsync" =>               [ "ptr",    "%p" ],
 118      "GLubyte" =>              [ "long",   "%d" ],
 119      "GLuint" =>               [ "long",   "%d" ],
 120      "GLuint64" =>             [ "int64",  "wine_dbgstr_longlong(%s)" ],
 121      "GLuint64EXT" =>          [ "int64",  "wine_dbgstr_longlong(%s)" ],
 122      "GLushort" =>             [ "long",   "%d" ],
 123      "GLvdpauSurfaceNV" =>     [ "long",   "%ld" ],
 124      "GLDEBUGPROC" =>          [ "ptr",    "%p" ],
 125      "GLDEBUGPROCARB" =>       [ "ptr",    "%p" ],
 126      "GLDEBUGPROCAMD" =>       [ "ptr",    "%p" ],
 127      "GLDEBUGPROCKHR" =>       [ "ptr",    "%p" ],
 128      "GLVULKANPROCNV" =>       [ "ptr",    "%p" ],
 129      "HDC" =>                  [ "long",   "%p" ],
 130      "HGLRC" =>                [ "long",   "%p" ],
 131      "HPBUFFERARB" =>          [ "long",   "%p" ],
 132      "HENHMETAFILE" =>         [ "long",   "%p" ],
 133      "LPGLYPHMETRICSFLOAT" =>  [ "ptr",    "%p" ],
 134      "LPCSTR" =>               [ "str",    "wine_dbgstr_a(%s)" ],
 135      "UINT" =>                 [ "long",   "%u" ],
 136      "DWORD" =>                [ "long",   "%u" ],
 137      "BOOL" =>                 [ "long",   "%u" ],
 138      "FLOAT" =>                [ "float",  "%f" ],
 139     );
 140
 141 my %remap_types =
 142     (
 143      "HGLRC" => "struct wgl_context *",
 144      "HPBUFFERARB" => "struct wgl_pbuffer *",
 145     );
 146 #
 147 # Used to convert some types
 148 #
 149 sub ConvertType($)
 150 {
 151     my $arg = shift;
 152     my $ret = $arg->textContent();
 153     my @type = $arg->findnodes("./ptype");
 154
 155     if (@type)
 156     {
 157         my $type = $type[0]->textContent();
 158         $ret =~ s/$type/$remap_types{$type}/ if defined $remap_types{$type};
 159     }
 160     return $ret;
 161 }
 162
 163 #
 164 # This functions generates the thunk for a given function.
 165 #
 166 sub GenerateThunk($$$)
 167 {
 168     my ($name, $func_ref, $prefix) = @_;
 169     my $call_arg = "";
 170     my $trace_call_arg = "";
 171     my $trace_arg = "";
 172
 173     my $ret = get_func_proto( "%s WINAPI %s(%s)", $name, $func_ref, 0 );
 174     foreach my $arg (@{$func_ref->[1]}) {
 175         my $ptype = get_arg_type( $arg );
 176         my $pname = get_arg_name( $arg );
 177         my $param = $arg->textContent();
 178         $call_arg .= " " . $pname . ",";
 179         if ($param =~ /\*/ || $param =~ /\[/) {
 180             $trace_arg .= ", %p";
 181             $trace_call_arg .= ", " . $pname;
 182         } elsif (defined $arg_types{$ptype}) {
 183             my $format = ${$arg_types{$ptype}}[1];
 184             $trace_arg .= ", " . ($format =~ /^%/ ? $format : "%s");
 185             $trace_call_arg .= ", " . sprintf $format =~ /^%/ ? "%s" : $format, $pname;
 186         }
 187         else { printf "Unknown type %s in %s\n", $param, $name; }
 188     }
 189     $call_arg =~ s/,$/ /;
 190     $trace_arg =~ s/^, //;
 191     $ret .= "\n{\n";
 192     # special case for functions that take an HDC as first parameter
 193     if (@{$func_ref->[1]} && get_arg_type( ${$func_ref->[1]}[0] ) eq "HDC")
 194     {
 195         my $pname = get_arg_name( ${$func_ref->[1]}[0] );
 196         $ret .= "  const struct opengl_funcs *funcs = get_dc_funcs( $pname );\n";
 197         $ret .= "  TRACE( \"($trace_arg)\\n\"$trace_call_arg );\n" if $gen_traces;
 198         $ret .= "  if (!funcs || !funcs->$prefix.p_$name) return";
 199         $ret .= " 0" unless is_void_func( $func_ref );
 200         $ret .= ";\n";
 201     }
 202     else
 203     {
 204         $ret .= "  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;\n";
 205         $ret .= "  TRACE( \"($trace_arg)\\n\"$trace_call_arg );\n" if $gen_traces;
 206     }
 207     $ret .= "  ";
 208     $ret .= "return " unless is_void_func( $func_ref );
 209     $ret .= "funcs->$prefix.p_$name($call_arg);\n";
 210     $ret .= "}\n\n";
 211     return $ret;
 212 }
 213
 214 sub generate_null_func($$)
 215 {
 216     my ($name, $func_ref) = @_;
 217     my $ret;
 218
 219     return "" if $name eq "glDebugEntry";
 220
 221     $ret = get_func_proto( "static %s null_%s(%s)", $name, $func_ref, 1 );
 222     $ret .= " {";
 223     if ($name eq "glGetError")
 224     {
 225         $ret .= " return GL_INVALID_OPERATION;";
 226     }
 227     elsif (!is_void_func( $func_ref ))
 228     {
 229         $ret .= " return 0;";
 230     }
 231     $ret .= " }\n";
 232     return $ret;
 233 }
 234
 235 sub generate_spec_entry($$)
 236 {
 237     my ($name, $func) = @_;
 238     my $args=" ";
 239     foreach my $arg (@{$func->[1]})
 240     {
 241         my $ptype = get_arg_type( $arg );
 242         my $param = $arg->textContent();
 243         if ($param =~ /[[*]/) {
 244             $args .= "ptr ";
 245         } elsif (defined($arg_types{$ptype})) {
 246             $args .= "$@$arg_types{$ptype}[0] ";
 247         } else {
 248             die "No conversion for func $name type $param\n";
 249         }
 250     }
 251     $args = substr($args,1,-1);
 252     return "@ stdcall $_($args)";
 253 }
 254
 255 sub is_void_func($)
 256 {
 257     my $func = shift;
 258     return 0 if @{$func->[0]->findnodes("./ptype")};
 259     return $func->[0]->textContent() eq "void ";
 260 }
 261
 262 sub get_arg_type($)
 263 {
 264     my $p = shift;
 265     my @type = $p->findnodes("./ptype");
 266     return @type ? $type[0]->textContent() : "GLint";
 267 }
 268
 269 sub get_arg_name($)
 270 {
 271     my $p = shift;
 272     my @name = $p->findnodes("./name");
 273     return $name[0]->textContent();
 274 }
 275
 276 sub get_func_proto($$$$)
 277 {
 278     my ($format, $name, $func, $convert_args) = @_;
 279     die "unknown func $name" unless defined $func->[0];
 280     my $proto = $convert_args ? ConvertType( $func->[0] ) : $func->[0]->textContent();
 281     $proto =~ s/ $//;
 282     my $args = "";
 283     foreach my $arg (@{$func->[1]})
 284     {
 285         $args .= " " . ($convert_args ? ConvertType( $arg ) : $arg->textContent()) . ",";
 286     }
 287     $args =~ s/,$/ /;
 288     $args ||= "void";
 289     return sprintf $format, $proto, $name, $args;
 290 }
 291
 292 #
 293 # Extract and checks the number of arguments
 294 #
 295 if (@ARGV > 1) {
 296     my $name0=$0;
 297     $name0=~s%^.*/%%;
 298     die "Usage: $name0 [version]\n";
 299 }
 300 my $version = $ARGV[0] || "1.1";
 301 if ($version eq "1.0") {
 302     %norm_categories = %cat_1_0;
 303 } elsif ($version eq "1.1") {
 304     %norm_categories = %cat_1_1;
 305 } elsif ($version eq "1.2") {
 306     %norm_categories = %cat_1_2;
 307 } elsif ($version eq "1.3") {
 308     %norm_categories = %cat_1_3;
 309 } elsif ($version eq "1.4") {
 310     %norm_categories = %cat_1_4;
 311 } elsif ($version eq "1.5") {
 312     %norm_categories = %cat_1_5;
 313 } else {
 314     die "Incorrect OpenGL version.\n";
 315 }
 316
 317 #
 318 # Fetch the registry files
 319 #
 320 -f "gl.xml" || system "wget https://raw.github.com/KhronosGroup/OpenGL-Registry/master/xml/gl.xml" || die "cannot download gl.xml";
 321 -f "wgl.xml" || system "wget https://raw.github.com/KhronosGroup/OpenGL-Registry/master/xml/wgl.xml" || die "cannot download wgl.xml";
 322
 323
 324 #
 325 # Then, create the list of all OpenGL functions using the registry
 326 # files. This will create two hash-tables, one with all the function
 327 # whose category matches the one listed in '@norm_categories', the other
 328 # with all other functions.
 329 #
 330 # An element of the hash table is a reference to an array with these
 331 # elements :
 332 #
 333 #  - XML node of the function prototype
 334 #
 335 #  - reference to an array of XML nodes giving the list of arguments (an empty array
 336 #    for a 'void' function).
 337 #
 338 my %norm_functions;
 339 my %ext_functions;
 340 my %wgl_functions;
 341 my %gl_enums;
 342 my (%gl_types, @gl_types);  # also use an array to preserve declaration order
 343
 344 my %supported_wgl_functions =
 345     (
 346      "wglCopyContext" => 1,
 347      "wglCreateContext" => 1,
 348      "wglDeleteContext" => 1,
 349      "wglDescribePixelFormat" => 1,
 350      "wglGetPixelFormat" => 1,
 351      "wglGetProcAddress" => 1,
 352      "wglMakeCurrent" => 1,
 353      "wglSetPixelFormat" => 1,
 354      "wglShareLists" => 1,
 355      "wglSwapBuffers" => 1,
 356     );
 357
 358 my %remapped_wgl_functions =
 359     (
 360      "ChoosePixelFormat" => "wglChoosePixelFormat",
 361      "DescribePixelFormat" => "wglDescribePixelFormat",
 362      "GetPixelFormat" => "wglGetPixelFormat",
 363      "GetEnhMetaFilePixelFormat" => 0,
 364      "SetPixelFormat" => "wglSetPixelFormat",
 365      "SwapBuffers" => "wglSwapBuffers",
 366      "wglUseFontBitmaps" => 0,
 367      "wglUseFontOutlines" => 0,
 368     );
 369
 370 my %supported_wgl_extensions =
 371    (
 372     "WGL_ARB_create_context" => 1,
 373     "WGL_ARB_create_context_no_error" => 1,
 374     "WGL_ARB_create_context_profile" => 1,
 375     "WGL_ARB_extensions_string" => 1,
 376     "WGL_ARB_make_current_read" => 1,
 377     "WGL_ARB_multisample" => 1,
 378     "WGL_ARB_pbuffer" => 1,
 379     "WGL_ARB_pixel_format" => 1,
 380     "WGL_ARB_framebuffer_sRGB" => 1,
 381     "WGL_ARB_pixel_format_float" => 1,
 382     "WGL_ARB_render_texture" => 1,
 383     "WGL_ATI_pixel_format_float" => 1,
 384     "WGL_EXT_create_context_es2_profile" => 1,
 385     "WGL_EXT_extensions_string" => 1,
 386     "WGL_EXT_framebuffer_sRGB" => 1,
 387     "WGL_EXT_pixel_format_packed_float" => 1,
 388     "WGL_EXT_swap_control" => 1,
 389     "WGL_EXT_swap_control_tear" => 1,
 390     "WGL_NV_float_buffer" => 1,
 391     "WGL_NV_render_depth_texture" => 1,
 392     "WGL_NV_render_texture_rectangle" => 1,
 393     "WGL_NV_vertex_array_range" => 1,
 394     "WGL_WINE_pixel_format_passthrough" => 1,
 395     "WGL_WINE_query_renderer" => 1,
 396    );
 397
 398 my %supported_apis =
 399     (
 400      "gl" => 1,
 401     );
 402
 403 sub is_supported_api($)
 404 {
 405     my $api = shift;
 406     foreach my $i (split /\|/, $api)
 407     {
 408         return 1 if defined $supported_apis{$i};
 409     }
 410     return 0;
 411 }
 412
 413 # some functions need a hand-written wrapper
 414 sub needs_wrapper($$)
 415 {
 416     my %funcs =
 417         (
 418          "glDebugEntry" => 1,
 419          "glDebugMessageCallback" => 1,
 420          "glDebugMessageCallbackAMD" => 1,
 421          "glDebugMessageCallbackARB" => 1,
 422          "glGetIntegerv" => 1,
 423          "glGetString" => 1,
 424          "glGetStringi" => 1,
 425          "wglGetCurrentReadDCARB" => 1,
 426         );
 427     my ($name, $func) = @_;
 428
 429     return 1 if defined $funcs{$name};
 430     # check if return value needs special handling
 431     (my $type = $func->[0]->textContent()) =~ s/ $//;
 432     return 1 if defined $remap_types{$type};
 433     # check if one of the arguments needs special handling
 434     foreach (@{$func->[1]})
 435     {
 436         $type = get_arg_type( $_ );
 437         return 1 if defined $remap_types{$type};
 438     }
 439     return 0;
 440 }
 441
 442 sub parse_file($)
 443 {
 444     my $file = shift;
 445     my $xml = XML::LibXML->load_xml( location => $file );
 446     my %functions;
 447     my %enums;
 448
 449     # save all functions
 450     foreach my $command ($xml->findnodes("/registry/commands/command"))
 451     {
 452         my $proto = @{$command->findnodes("./proto")}[0];
 453         my $name = @{$command->findnodes("./proto/name")}[0];
 454         $proto->removeChild( $name );
 455         my @params = $command->findnodes("./param");
 456         $functions{$name->textContent()} = [ $proto, \@params ];
 457     }
 458
 459     # save all enums
 460     foreach my $enum ($xml->findnodes("/registry/enums/enum"))
 461     {
 462         $enums{$enum->{name}} = $enum->{value};
 463     }
 464
 465     # save all types
 466     foreach my $type ($xml->findnodes("/registry/types/type"))
 467     {
 468         next if $type->{api};
 469         my $name = @{$type->findnodes("./name")}[0];
 470         next unless $name;
 471         $name = $name->textContent;
 472         push @gl_types, $name unless $gl_types{$name};
 473         $gl_types{$name} = $type;
 474     }
 475
 476     # generate norm functions
 477     foreach my $feature ($xml->findnodes("/registry/feature"))
 478     {
 479         if ($feature->{api} eq "wgl")
 480         {
 481             foreach my $cmd ($feature->findnodes("./require/command"))
 482             {
 483                 my $name = $cmd->{name};
 484                 if (defined $remapped_wgl_functions{$name})
 485                 {
 486                     next unless $remapped_wgl_functions{$name};
 487                     $name = $remapped_wgl_functions{$name};
 488                 }
 489                 $wgl_functions{$name} = $functions{$cmd->{name}};
 490             }
 491         }
 492         next unless defined $norm_categories{$feature->{name}};
 493         foreach my $cmd ($feature->findnodes("./require/command"))
 494         {
 495             $norm_functions{$cmd->{name}} = $functions{$cmd->{name}};
 496         }
 497         foreach my $enum ($feature->findnodes("./require/enum"))
 498         {
 499             $gl_enums{$enum->{name}} = $enums{$enum->{name}};
 500         }
 501     }
 502
 503     # generate extension functions from norm functions, if they are newer than the category
 504     foreach my $feature ($xml->findnodes("/registry/feature"))
 505     {
 506         next if defined $norm_categories{$feature->{name}};
 507         next unless is_supported_api( $feature->{api} );
 508         foreach my $cmd ($feature->findnodes("./require/command"))
 509         {
 510             my $name = $cmd->{name};
 511             next if $norm_functions{$name} || $ext_functions{$name};
 512             $ext_functions{$name} = [ $functions{$name}[0], $functions{$name}[1], [ $feature->{name} ] ];
 513         }
 514         foreach my $enum ($feature->findnodes("./require/enum"))
 515         {
 516             $gl_enums{$enum->{name}} = $enums{$enum->{name}};
 517         }
 518     }
 519
 520     # generate extension functions
 521     foreach my $ext ($xml->findnodes("/registry/extensions/extension"))
 522     {
 523         if ($ext->{supported} eq "wgl")
 524         {
 525             next unless defined $supported_wgl_extensions{$ext->{name}};
 526             foreach my $cmd ($ext->findnodes("./require/command"))
 527             {
 528                 my $name = $cmd->{name};
 529                 $ext_functions{$name} = [ $functions{$name}[0], $functions{$name}[1], [ $ext->{name} ] ];
 530             }
 531             foreach my $enum ($ext->findnodes("./require/enum"))
 532             {
 533                 $gl_enums{$enum->{name}} = $enums{$enum->{name}};
 534             }
 535             next;
 536         }
 537         next unless is_supported_api( $ext->{supported} );
 538         foreach my $req ($ext->findnodes("./require"))
 539         {
 540             next unless !$req->{api} || $req->{api} eq "gl";
 541             foreach my $cmd ($req->findnodes("./command"))
 542             {
 543                 my $name = $cmd->{name};
 544                 next if $norm_functions{$name};
 545                 if (!$ext_functions{$name})
 546                 {
 547                     $ext_functions{$name} = [ $functions{$name}[0], $functions{$name}[1], [ $ext->{name} ] ];
 548                 }
 549                 else
 550                 {
 551                     push @{$ext_functions{$name}->[2]}, $ext->{name};
 552                 }
 553             }
 554         }
 555         foreach my $enum ($ext->findnodes("./require/enum"))
 556         {
 557             $gl_enums{$enum->{name}} = $enums{$enum->{name}};
 558         }
 559     }
 560 }
 561
 562 parse_file( "gl.xml" );
 563 parse_file( "wgl.xml" );
 564 parse_file( "winegl.xml" );
 565
 566 #
 567 # Get the current wgl_driver.h version
 568 #
 569 my $wgl_version = 0;
 570 open HEADER, "<$wgl_driver_file" or die "cannot open $wgl_driver_file";
 571 while (<HEADER>)
 572 {
 573     next unless /^#define WINE_WGL_DRIVER_VERSION (\d+)/;
 574     $wgl_version = $1;
 575     last;
 576 }
 577 close HEADER;
 578
 579 #
 580 # Generate the wgl_driver.h file
 581 #
 582 open HEADER, ">$wgl_driver_file" or die "cannot create $wgl_driver_file";
 583 print HEADER "/* Automatically generated from http://www.opengl.org/registry files; DO NOT EDIT! */\n\n";
 584 print HEADER "#ifndef __WINE_WGL_DRIVER_H\n";
 585 print HEADER "#define __WINE_WGL_DRIVER_H\n\n";
 586 print HEADER "#ifndef WINE_GLAPI\n";
 587 print HEADER "#define WINE_GLAPI\n";
 588 print HEADER "#endif\n\n";
 589
 590 printf HEADER "#define WINE_WGL_DRIVER_VERSION %u\n\n", $wgl_version + 1;
 591
 592 print HEADER "struct wgl_context;\n";
 593 print HEADER "struct wgl_pbuffer;\n\n";
 594
 595 print HEADER "struct opengl_funcs\n{\n";
 596 print HEADER "    struct\n    {\n";
 597 foreach (sort keys %wgl_functions)
 598 {
 599     next unless defined $supported_wgl_functions{$_};
 600     print HEADER get_func_proto("        %-10s (WINE_GLAPI *p_%s)(%s);\n", $_, $wgl_functions{$_}, 1);
 601 }
 602 print HEADER "    } wgl;\n\n";
 603
 604 print HEADER "    struct\n    {\n";
 605 foreach (sort keys %norm_functions)
 606 {
 607     next if $_ eq "glDebugEntry";
 608     print HEADER get_func_proto("        %-10s (WINE_GLAPI *p_%s)(%s);\n", $_, $norm_functions{$_}, 1);
 609 }
 610 print HEADER "    } gl;\n\n";
 611
 612 print HEADER "    struct\n    {\n";
 613 foreach (sort keys %ext_functions)
 614 {
 615     print HEADER get_func_proto("        %-10s (WINE_GLAPI *p_%s)(%s);\n", $_, $ext_functions{$_}, 1);
 616 }
 617 print HEADER "    } ext;\n";
 618 print HEADER "};\n\n";
 619
 620 print HEADER "#define ALL_WGL_FUNCS";
 621 foreach (sort keys %norm_functions)
 622 {
 623     next if $_ eq "glDebugEntry";
 624     printf HEADER " \\\n    USE_GL_FUNC(\%s)", $_;
 625 }
 626 print HEADER "\n\n";
 627
 628 print HEADER "extern struct opengl_funcs * CDECL __wine_get_wgl_driver( HDC hdc, UINT version );\n";
 629 print HEADER "extern BOOL CDECL __wine_set_pixel_format( HWND hwnd, int format );\n\n";
 630 print HEADER "#endif /* __WINE_WGL_DRIVER_H */\n";
 631 close HEADER;
 632
 633 #
 634 # Generate the wgl.h file
 635 #
 636 open HEADER, ">$wgl_file" or die "cannot create $wgl_file";
 637 print HEADER "/* Automatically generated from http://www.opengl.org/registry files; DO NOT EDIT! */\n\n";
 638 print HEADER "#ifndef __WINE_WGL_H\n";
 639 print HEADER "#define __WINE_WGL_H\n\n";
 640
 641 print HEADER "#ifndef GLAPIENTRY\n";
 642 print HEADER "#define GLAPIENTRY __stdcall\n";
 643 print HEADER "#endif\n\n";
 644
 645 foreach (@gl_types)
 646 {
 647     printf HEADER $gl_types{$_}->textContent() . "\n";
 648 }
 649 print HEADER "\n";
 650
 651 my $maxlen = 1;
 652 foreach (keys %gl_enums) { $maxlen = length($_) if length($_) > $maxlen; }
 653 foreach (sort keys %gl_enums)
 654 {
 655     printf HEADER "#define %-*s %s\n", $maxlen, $_, $gl_enums{$_};
 656 }
 657 print HEADER "\n";
 658
 659 foreach (sort keys %norm_functions)
 660 {
 661     printf HEADER "%s;\n", get_func_proto("%-10s GLAPIENTRY %s(%s)", $_, $norm_functions{$_}, 0);
 662 }
 663
 664 print HEADER "\n#endif /* __WINE_WGL_H */\n";
 665 close HEADER;
 666
 667 #
 668 # Now, generate the output files. First, the spec file.
 669 #
 670 open(SPEC, ">$spec_file") or die "cannot create $spec_file";
 671
 672 foreach (sort keys %norm_functions) {
 673     printf SPEC "%s\n", generate_spec_entry( $_, $norm_functions{$_} );
 674 }
 675 foreach (sort keys %wgl_functions) {
 676     printf SPEC "%s\n", generate_spec_entry( $_, $wgl_functions{$_} );
 677 }
 678
 679 close(SPEC);
 680
 681 my $file_header =
 682 "/* Automatically generated from http://www.opengl.org/registry files; DO NOT EDIT! */\n\n" .
 683 "#include \"config.h\"\n" .
 684 "#include <stdarg.h>\n" .
 685 "#include \"winternl.h\"\n" .
 686 "#include \"opengl_ext.h\"\n" .
 687 "#include \"wine/debug.h\"\n\n";
 688
 689 $file_header .= "WINE_DEFAULT_DEBUG_CHANNEL(opengl);\n\n" if $gen_traces;
 690
 691 #
 692 # After the spec file, the opengl_norm.c file
 693 #
 694 open(NORM, ">$norm_file") or die "cannot create $norm_file";
 695 print NORM $file_header;
 696
 697 foreach (sort keys %norm_functions) {
 698     next if needs_wrapper( $_, $norm_functions{$_} );
 699     print NORM GenerateThunk($_, $norm_functions{$_}, "gl");
 700 }
 701
 702 foreach (sort keys %wgl_functions) {
 703     next unless defined $supported_wgl_functions{$_};
 704     print NORM generate_null_func($_, $wgl_functions{$_});
 705 }
 706 foreach (sort keys %norm_functions) {
 707     print NORM generate_null_func($_, $norm_functions{$_});
 708 }
 709 foreach (sort keys %ext_functions) {
 710     print NORM generate_null_func($_, $ext_functions{$_});
 711 }
 712
 713 print NORM "\nstruct opengl_funcs null_opengl_funcs =\n{\n    {\n";
 714 foreach (sort keys %wgl_functions)
 715 {
 716     next unless defined $supported_wgl_functions{$_};
 717     print NORM "        null_$_,\n";
 718 }
 719 print NORM "    },\n    {\n";
 720 foreach (sort keys %norm_functions) { print NORM "        null_$_,\n" unless $_ eq "glDebugEntry"; }
 721 print NORM "    },\n    {\n";
 722 foreach (sort keys %ext_functions) { print NORM "        null_$_,\n"; }
 723 print NORM "    }\n};\n";
 724
 725 close(NORM);
 726
 727 #
 728 # Finally, more complex, the opengl_ext.c file
 729 #
 730 open(EXT, ">$ext_file") or die "cannot create $ext_file";
 731 print EXT $file_header;
 732
 733 # The thunks themselves....
 734 my $count = keys %ext_functions;
 735 my $wrappers = "";
 736 print EXT "const int extension_registry_size = $count;\n\n";
 737 foreach (sort keys %ext_functions) {
 738     if (needs_wrapper( $_, $ext_functions{$_} ))
 739     {
 740         $wrappers .= get_func_proto("extern %s WINAPI %s(%s) DECLSPEC_HIDDEN;\n", $_, $ext_functions{$_}, 0);
 741     }
 742     else
 743     {
 744         print EXT "static " . GenerateThunk($_, $ext_functions{$_}, "ext");
 745     }
 746 }
 747 print EXT $wrappers;
 748
 749 # Then the table giving the string <-> function correspondence */
 750 print EXT "\nconst OpenGL_extension extension_registry[$count] = {\n";
 751 my $i = 0;
 752 foreach (sort keys %ext_functions) {
 753     my $func_ref = $ext_functions{$_};
 754     printf EXT "  { \"%s\", \"%s\", %s }", $_, join(" ", sort @{$func_ref->[2]}), $_;
 755     if ($i != $count-1) {
 756         print EXT ",";
 757     }
 758     $i++;
 759     print EXT "\n";
 760 }
 761 print EXT "};\n";
 762
 763 close(EXT);