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