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 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 #     - include/wine/wgl_driver.h: definitions for the tables of OpenGL functions.
  29 #
  30 #
  31 # Copyright 2000 Lionel Ulmer
  32 # Copyright 2012 Alexandre Julliard
  33 #
  34 # This library is free software; you can redistribute it and/or
  35 # modify it under the terms of the GNU Lesser General Public
  36 # License as published by the Free Software Foundation; either
  37 # version 2.1 of the License, or (at your option) any later version.
  38 #
  39 # This library is distributed in the hope that it will be useful,
  40 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  41 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  42 # Lesser General Public License for more details.
  43 #
  44 # You should have received a copy of the GNU Lesser General Public
  45 # License along with this library; if not, write to the Free Software
  46 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  47 #
  48
  49 #
  50 # Files to generate
  51 #
  52 my $spec_file = "opengl32.spec";
  53 my $wgl_driver_file = "../../include/wine/wgl_driver.h";
  54 my $wgl_file = "../../include/wine/wgl.h";
  55
  56 # If set to 1, generate TRACEs for each OpenGL function
  57 my $gen_traces = 1;
  58
  59 #
  60 # List of norm categories
  61 #
  62 my %cat_1_0 = ( "GL_VERSION_1_0" => 1 );
  63 my %cat_1_1 = ( %cat_1_0, "GL_VERSION_1_1" => 1 );
  64 my %cat_1_2 = ( %cat_1_1, "GL_VERSION_1_2" => 1 );
  65 my %cat_1_3 = ( %cat_1_2, "GL_VERSION_1_3" => 1 );
  66 my %cat_1_4 = ( %cat_1_3, "GL_VERSION_1_4" => 1 );
  67 my %cat_1_5 = ( %cat_1_4, "GL_VERSION_1_5" => 1 );
  68
  69 my %norm_categories = ();
  70
  71 #
  72 # This hash table gives the conversion between OpenGL types and
  73 # the .spec type and debug format
  74 #
  75 my %arg_types =
  76     (
  77      "GLbitfield" =>           [ "long",   "%d" ],
  78      "GLboolean" =>            [ "long",   "%d" ],
  79      "GLbyte" =>               [ "long",   "%d" ],
  80      "GLchar" =>               [ "long",   "%c" ],
  81      "GLcharARB" =>            [ "long",   "%c" ],
  82      "GLclampd" =>             [ "double", "%f" ],
  83      "GLclampf" =>             [ "float",  "%f" ],
  84      "GLclampx" =>             [ "long",   "%d" ],
  85      "GLdouble" =>             [ "double", "%f" ],
  86      "GLeglClientBufferEXT" => [ "ptr",    "%p" ],
  87      "GLeglImageOES" =>        [ "ptr",    "%p" ],
  88      "GLenum" =>               [ "long",   "%d" ],
  89      "GLfixed" =>              [ "long",   "%d" ],
  90      "GLfloat" =>              [ "float",  "%f" ],
  91      "GLhalfNV" =>             [ "long",   "%d" ],
  92      "GLhandleARB" =>          [ "long",   "%d" ],
  93      "int" =>                  [ "long",   "%d" ],
  94      "GLint" =>                [ "long",   "%d" ],
  95      "GLint64" =>              [ "int64",  "wine_dbgstr_longlong(%s)" ],
  96      "GLint64EXT" =>           [ "int64",  "wine_dbgstr_longlong(%s)" ],
  97      "GLintptr" =>             [ "long",   "%Id" ],
  98      "GLintptrARB" =>          [ "long",   "%Id" ],
  99      "GLshort" =>              [ "long",   "%d" ],
 100      "GLsizei" =>              [ "long",   "%d" ],
 101      "GLsizeiptr" =>           [ "long",   "%Id" ],
 102      "GLsizeiptrARB" =>        [ "long",   "%Id" ],
 103      "GLstring" =>             [ "str",    "wine_dbgstr_a(%s)" ],
 104      "GLsync" =>               [ "ptr",    "%p" ],
 105      "GLubyte" =>              [ "long",   "%d" ],
 106      "GLuint" =>               [ "long",   "%d" ],
 107      "GLuint64" =>             [ "int64",  "wine_dbgstr_longlong(%s)" ],
 108      "GLuint64EXT" =>          [ "int64",  "wine_dbgstr_longlong(%s)" ],
 109      "GLushort" =>             [ "long",   "%d" ],
 110      "GLvdpauSurfaceNV" =>     [ "long",   "%Id" ],
 111      "GLDEBUGPROC" =>          [ "ptr",    "%p" ],
 112      "GLDEBUGPROCARB" =>       [ "ptr",    "%p" ],
 113      "GLDEBUGPROCAMD" =>       [ "ptr",    "%p" ],
 114      "GLDEBUGPROCKHR" =>       [ "ptr",    "%p" ],
 115      "GLVULKANPROCNV" =>       [ "ptr",    "%p" ],
 116      "HDC" =>                  [ "long",   "%p" ],
 117      "HGLRC" =>                [ "long",   "%p" ],
 118      "HPBUFFERARB" =>          [ "long",   "%p" ],
 119      "HENHMETAFILE" =>         [ "long",   "%p" ],
 120      "LPGLYPHMETRICSFLOAT" =>  [ "ptr",    "%p" ],
 121      "LPCSTR" =>               [ "str",    "wine_dbgstr_a(%s)" ],
 122      "UINT" =>                 [ "long",   "%u" ],
 123      "DWORD" =>                [ "long",   "%lu" ],
 124      "BOOL" =>                 [ "long",   "%u" ],
 125      "FLOAT" =>                [ "float",  "%f" ],
 126     );
 127
 128 my %remap_types =
 129     (
 130      "HGLRC" => "struct wgl_context *",
 131      "HPBUFFERARB" => "struct wgl_pbuffer *",
 132     );
 133
 134 my %khronos_types =
 135     (
 136      "double" => "double DECLSPEC_ALIGN(8)",
 137      "khronos_int8_t" => "signed char",
 138      "khronos_uint8_t" => "unsigned char",
 139      "khronos_int16_t" => "short",
 140      "khronos_uint16_t" => "unsigned short",
 141      "khronos_int32_t" => "int",
 142      "khronos_uint32_t" => "unsigned int",
 143      "khronos_float_t" => "float",
 144     );
 145
 146 my %manual_win_functions =
 147     (
 148      "glDebugEntry" => 1,
 149      "wglChoosePixelFormat" => 1,
 150      "wglCreateLayerContext" => 1,
 151      "wglDescribeLayerPlane" => 1,
 152      "wglGetCurrentContext" => 1,
 153      "wglGetCurrentDC" => 1,
 154      "wglGetDefaultProcAddress" => 1,
 155      "wglGetLayerPaletteEntries" => 1,
 156      "wglRealizeLayerPalette" => 1,
 157      "wglSetLayerPaletteEntries" => 1,
 158      "wglSwapLayerBuffers" => 1,
 159      "wglUseFontBitmapsA" => 1,
 160      "wglUseFontBitmapsW" => 1,
 161      "wglUseFontOutlinesA" => 1,
 162      "wglUseFontOutlinesW" => 1,
 163     );
 164 my %manual_win_thunks =
 165     (
 166      "glGetString" => 1,
 167      "glGetStringi" => 1,
 168      "glMapBuffer" => 1,
 169      "glMapBufferARB" => 1,
 170      "glMapBufferRange" => 1,
 171      "glMapNamedBuffer" => 1,
 172      "glMapNamedBufferEXT" => 1,
 173      "glMapNamedBufferRange" => 1,
 174      "glMapNamedBufferRangeEXT" => 1,
 175      "glUnmapBuffer" => 1,
 176      "glUnmapBufferARB" => 1,
 177      "glUnmapNamedBuffer" => 1,
 178      "glUnmapNamedBufferEXT" => 1,
 179      "wglGetCurrentReadDCARB" => 1,
 180      "wglGetExtensionsStringARB" => 1,
 181      "wglGetExtensionsStringEXT" => 1,
 182      "wglGetPixelFormat" => 1,
 183      "wglGetProcAddress" => 1,
 184      "wglQueryCurrentRendererStringWINE" => 1,
 185      "wglQueryRendererStringWINE" => 1,
 186      "wglSwapBuffers" => 1,
 187     );
 188 my %manual_wow64_thunks =
 189     (
 190      "glClientWaitSync" => 1,
 191      "glDeleteSync" => 1,
 192      "glFenceSync" => 1,
 193      "glGetBufferPointerv" => 1,
 194      "glGetBufferPointervARB" => 1,
 195      "glGetNamedBufferPointerv" => 1,
 196      "glGetNamedBufferPointervEXT" => 1,
 197      "glGetString" => 1,
 198      "glGetStringi" => 1,
 199      "glGetSynciv" => 1,
 200      "glIsSync" => 1,
 201      "glMapBuffer" => 1,
 202      "glMapBufferARB" => 1,
 203      "glMapBufferRange" => 1,
 204      "glMapNamedBuffer" => 1,
 205      "glMapNamedBufferEXT" => 1,
 206      "glMapNamedBufferRange" => 1,
 207      "glMapNamedBufferRangeEXT" => 1,
 208      "glPathGlyphIndexRangeNV" => 1,
 209      "glUnmapBuffer" => 1,
 210      "glUnmapBufferARB" => 1,
 211      "glUnmapNamedBuffer" => 1,
 212      "glUnmapNamedBufferEXT" => 1,
 213      "glWaitSync" => 1,
 214      "wglCreateContext" => 1,
 215      "wglCreateContextAttribsARB" => 1,
 216      "wglCreatePbufferARB" => 1,
 217      "wglDeleteContext" => 1,
 218      "wglGetExtensionsStringARB" => 1,
 219      "wglGetExtensionsStringEXT" => 1,
 220      "wglGetPbufferDCARB" => 1,
 221      "wglGetProcAddress" => 1,
 222      "wglGetProcAddress" => 1,
 223      "wglMakeContextCurrentARB" => 1,
 224      "wglMakeCurrent" => 1,
 225      "wglQueryCurrentRendererStringWINE" => 1,
 226      "wglQueryRendererStringWINE" => 1,
 227     );
 228 my %pointer_array_count =
 229     (
 230      "glCompileShaderIncludeARB" => "count",
 231      "glCreateShaderProgramv" => "count",
 232      "glGetUniformIndices" => "uniformCount",
 233      "glMultiDrawElements" => "drawcount",
 234      "glMultiDrawElementsBaseVertex" => "drawcount",
 235      "glMultiDrawElementsEXT" => "primcount",
 236      "glMultiModeDrawElementsIBM" => "primcount",
 237      "glTransformFeedbackVaryings" => "count",
 238      "glTransformFeedbackVaryingsEXT" => "count",
 239      "glShaderSource" => "count",
 240      "glShaderSourceARB" => "count",
 241      "glBindBuffersRange" => "count",
 242      "glBindVertexBuffers" => "count",
 243      "glDrawCommandsNV" => "count",
 244      "glVertexArrayVertexBuffers" => "count",
 245      "glDrawCommandsStatesNV" => "count",
 246      "glListDrawCommandsStatesClientNV" => "count",
 247     );
 248 my %pointer_is_offset =
 249     (
 250      "glGetPointerv" => "params",
 251      "glGetPointervEXT" => "params",
 252      "glGetVertexAttribPointerv" => "pointer",
 253      "glGetVertexAttribPointervARB" => "pointer",
 254     );
 255
 256 #
 257 # Used to convert some types
 258 #
 259 sub ConvertType($)
 260 {
 261     my $arg = shift;
 262     my $ret = $arg->textContent();
 263     my @type = $arg->findnodes("./ptype");
 264
 265     if (@type)
 266     {
 267         my $type = $type[0]->textContent();
 268         $ret =~ s/$type/$remap_types{$type}/ if defined $remap_types{$type};
 269     }
 270     return $ret;
 271 }
 272
 273 sub get_func_trace($$$)
 274 {
 275     my ($name, $func, $param_names) = @_;
 276     my $trace_fmt = "";
 277     my $trace_arg = "";
 278     foreach my $arg (@{$func->[1]})
 279     {
 280         my $ptype = get_arg_type( $arg );
 281         my $pname = get_arg_name( $arg );
 282         my $param = $arg->textContent();
 283         if ($param =~ /\*/ || $param =~ /\[/)
 284         {
 285             $trace_fmt .= ", ";
 286             $trace_fmt .= "$pname " if $param_names;
 287             $trace_fmt .= "%p";
 288             $trace_arg .= ", $pname";
 289         }
 290         elsif (defined $arg_types{$ptype})
 291         {
 292             my $format = ${$arg_types{$ptype}}[1];
 293             $trace_fmt .= ", ";
 294             $trace_fmt .= "$pname " if $param_names;
 295             $trace_fmt .= ($format =~ /^%/ ? $format : "%s");
 296             $trace_arg .= ", " . (sprintf $format =~ /^%/ ? "%s" : $format, $pname);
 297         }
 298         else { printf "Unknown type %s in %s\n", $param, $name; }
 299     }
 300     $trace_fmt =~ s/^, //;
 301     $trace_fmt = "($trace_fmt)" unless $param_names;
 302     return "TRACE( \"$trace_fmt\\n\"$trace_arg );\n";
 303 }
 304
 305 sub get_func_args($$$$)
 306 {
 307     my ($func, $decl_args, $convert_args, $prefix) = @_;
 308     my $ret = "";
 309     foreach my $arg (@{$func->[1]})
 310     {
 311         my $ptype = get_arg_type( $arg );
 312         my $pname = get_arg_name( $arg );
 313         if ($decl_args)
 314         {
 315             $ret .= " " . ($convert_args ? ConvertType( $arg ) : $arg->textContent()) . ",";
 316         }
 317         elsif ($convert_args && defined $remap_types{$ptype})
 318         {
 319             $ret .= " ($remap_types{$ptype})$prefix$pname,";
 320         }
 321         else
 322         {
 323             $ret .= " $prefix$pname,";
 324         }
 325     }
 326     $ret =~ s/,$/ /;
 327     $ret ||= "void" if $decl_args;
 328     return $ret;
 329 }
 330
 331 sub get_func_ret($$)
 332 {
 333     my ($func, $convert_args) = @_;
 334     my $ret = $convert_args ? ConvertType( $func->[0] ) : $func->[0]->textContent();
 335     $ret =~ s/ $//;
 336     return $ret;
 337 }
 338
 339 sub generate_unix_thunk($$$)
 340 {
 341     my ($name, $func, $prefix) = @_;
 342     my $call_args = get_func_args( $func, 0, 1, "params->" );
 343     my $func_ret = get_func_ret( $func, 0 );
 344     my $ret = "";
 345
 346     $ret .= "NTSTATUS $prefix\_$name( void *args )\n";
 347     $ret .= "{\n";
 348     $ret .= "    struct $name\_params *params = args;\n";
 349     # special case for functions that take an HDC as first parameter
 350     if (@{$func->[1]} && get_arg_type( ${$func->[1]}[0] ) eq "HDC")
 351     {
 352         my $pname = get_arg_name( ${$func->[1]}[0] );
 353         $ret .= "    const struct opengl_funcs *funcs = get_dc_funcs( params->$pname );\n";
 354         $ret .= "    if (!funcs || !funcs->$prefix.p_$name) return STATUS_NOT_IMPLEMENTED;\n";
 355     }
 356     else
 357     {
 358         $ret .= "    const struct opengl_funcs *funcs = params->teb->glTable;\n";
 359     }
 360     $ret .= "    ";
 361     $ret .= "params->ret = " unless is_void_func( $func );
 362     $ret .= "($func_ret)" if defined $remap_types{$func_ret};
 363     $ret .= "funcs->$prefix.p_$name($call_args);\n";
 364     $ret .= "    return STATUS_SUCCESS;\n";
 365     $ret .= "}\n\n";
 366
 367     return $ret;
 368 }
 369
 370 sub generate_win_thunk($$)
 371 {
 372     my ($name, $func) = @_;
 373     my $decl_args = get_func_args( $func, 1, 0, "" );
 374     my $func_ret = get_func_ret( $func, 0 );
 375     my $params = "";
 376     my $ret = "";
 377
 378     $ret .= "$func_ret WINAPI $name($decl_args)\n";
 379     $ret .= "{\n";
 380     $ret .= "    struct $name\_params args";
 381     $params .= " .teb = NtCurrentTeb()";
 382     foreach my $arg (@{$func->[1]})
 383     {
 384         my $pname = get_arg_name( $arg );
 385         $params .= ", .$pname = $pname" unless $arg->textContent() =~ /\[/;
 386     }
 387     $ret .= " = {$params }";
 388     $ret .= ";\n";
 389     $ret .= "    NTSTATUS status;\n";
 390     foreach my $arg (@{$func->[1]})
 391     {
 392         my $pname = get_arg_name( $arg );
 393         $ret .= "    memcpy( args.$pname, $pname, sizeof(args.$pname) );\n" if $arg->textContent() =~ /\[/;
 394     }
 395     $ret .= "    " . get_func_trace( $name, $func, 1 ) if $gen_traces;
 396     $ret .= "    if ((status = UNIX_CALL( $name, &args ))) WARN( \"$name returned %#lx\\n\", status );\n";
 397     $ret .= "    return args.ret;\n" unless is_void_func($func);
 398     $ret .= "}\n";
 399
 400     return $ret;
 401 }
 402
 403 sub get_wow64_arg_type($)
 404 {
 405     my $arg = shift;
 406     my $ptype = get_arg_type( $arg );
 407     return "void" if $ptype =~ /^void$/;
 408     return "PTR32" if $arg->textContent() =~ /(PROC|sizeiptr|intptr|\*|\[)/;
 409     return $ptype unless defined $arg_types{$ptype};
 410     return "PTR32" if ${$arg_types{$ptype}}[0] =~ /(ptr|str)/;
 411     return "PTR32" if ${$arg_types{$ptype}}[1] =~ /%p/;
 412     return $ptype;
 413 }
 414
 415 sub generate_wow64_thunk($$$)
 416 {
 417     my ($name, $func, $prefix) = @_;
 418     my $call_args = get_func_args( $func, 0, 1, "params->" );
 419     my $func_ret = get_func_ret( $func, 0 );
 420     my $need_manual_thunk = 0;
 421     my $ret = "";
 422
 423     $ret .= "static NTSTATUS wow64_$prefix\_$name( void *args )\n";
 424     $ret .= "{\n";
 425     $ret .= "    struct\n    {\n";
 426     $ret .= "        PTR32 teb;\n";
 427     foreach my $arg (@{$func->[1]})
 428     {
 429         my $ptype = get_wow64_arg_type( $arg );
 430         my $pname = get_arg_name( $arg );
 431         $ret .= "        $ptype $pname;\n";
 432         $need_manual_thunk = 1 if $arg->textContent() =~ /(\*.*\*|\[|(sizei|int)ptr.*\*)/ &&
 433                                   !defined $pointer_array_count{$_} && !defined $pointer_is_offset{$_};
 434     }
 435     if (!is_void_func($func))
 436     {
 437         my $ptype = get_wow64_arg_type( $func->[0] );
 438         $ret .= "        $ptype ret;\n";
 439     }
 440     $ret .= "    } *params32 = args;\n";
 441     $ret .= "    struct $name\_params params =\n";
 442     $ret .= "    {\n";
 443     $ret .= "        .teb = get_teb64(params32->teb),\n";
 444     foreach my $arg (@{$func->[1]})
 445     {
 446         next if $arg->textContent() =~ /(\*.*\*|\[|(sizei|int)ptr.*\*)/;
 447         my $ptype = get_arg_type( $arg );
 448         my $pname = get_arg_name( $arg );
 449         if ($arg->textContent() =~ /(sizei|int)ptr/)
 450         {
 451             $ret .= "        .$pname = ($ptype)ULongToPtr(params32->$pname),\n";
 452         }
 453         elsif (get_wow64_arg_type( $arg ) =~ /PTR32/)
 454         {
 455             $ret .= "        .$pname = ULongToPtr(params32->$pname),\n";
 456         }
 457         else
 458         {
 459             $ret .= "        .$pname = params32->$pname,\n";
 460         }
 461     }
 462     $ret .= "    };\n";
 463
 464     if ($need_manual_thunk || get_wow64_arg_type( $func->[0] ) =~ /PTR32/)
 465     {
 466         $ret .= "    FIXME( \"params32 %p, params %p stub!\\n\", params32, &params );\n";
 467         $ret .= "    return STATUS_NOT_IMPLEMENTED;\n";
 468         $ret .= "}\n\n";
 469         return $ret;
 470     }
 471
 472     $ret .= "    NTSTATUS status;\n";
 473
 474     foreach my $arg (@{$func->[1]})
 475     {
 476         next unless $arg->textContent() =~ /\*.*\*/ || $arg->textContent() =~ /(sizei|int)ptr.*\*/;
 477         next unless defined $pointer_array_count{$_};
 478         my $pname = get_arg_name( $arg );
 479         $ret .= "    params.$pname = copy_wow64_ptr32s( (UINT_PTR)params32->$pname, params32->$pointer_array_count{$_} );\n";
 480     }
 481
 482     $ret .= "    status = $prefix\_$name( &params );\n";
 483     if (!is_void_func( $func ))
 484     {
 485         $ret .= "    params32->ret = ";
 486         $ret .= "(UINT_PTR)" if get_wow64_arg_type( $func->[0] ) =~ /PTR32/;
 487         $ret .= "params.ret;\n";
 488     }
 489
 490     foreach my $arg (@{$func->[1]})
 491     {
 492         next unless $arg->textContent() =~ /\*.*\*/ || $arg->textContent() =~ /(sizei|int)ptr.*\*/;
 493         next unless defined $pointer_array_count{$_};
 494         my $pname = get_arg_name( $arg );
 495         $ret .= "    free( (void *)params.$pname );\n";
 496     }
 497
 498     foreach my $arg (@{$func->[1]})
 499     {
 500         next unless defined $pointer_is_offset{$_};
 501         my $pname = get_arg_name( $arg );
 502         next unless $pname =~ $pointer_is_offset{$_};
 503         $ret .= "    params32->$pname = PtrToUlong( params.$pname );\n";
 504     }
 505
 506     $ret .= "    return status;\n";
 507     $ret .= "}\n\n";
 508
 509     return $ret;
 510 }
 511
 512 sub generate_null_func($$)
 513 {
 514     my ($name, $func) = @_;
 515     my $decl_args = get_func_args( $func, 1, 1, "" );
 516     my $func_ret = get_func_ret( $func, 1 );
 517     my $ret = "";
 518
 519     return "" if $name eq "glDebugEntry";
 520
 521     $ret .= "static $func_ret null_$name($decl_args)";
 522     $ret .= " {";
 523     if ($name eq "glGetError")
 524     {
 525         $ret .= " return GL_INVALID_OPERATION;";
 526     }
 527     elsif (!is_void_func( $func ))
 528     {
 529         $ret .= " return 0;";
 530     }
 531     $ret .= " }\n";
 532     return $ret;
 533 }
 534
 535 sub generate_spec_entry($$)
 536 {
 537     my ($name, $func) = @_;
 538     my $args=" ";
 539     foreach my $arg (@{$func->[1]})
 540     {
 541         my $ptype = get_arg_type( $arg );
 542         my $param = $arg->textContent();
 543         if ($param =~ /[[*]/) {
 544             $args .= "ptr ";
 545         } elsif (defined($arg_types{$ptype})) {
 546             $args .= "$@$arg_types{$ptype}[0] ";
 547         } else {
 548             die "No conversion for func $name type $param\n";
 549         }
 550     }
 551     $args = substr($args,1,-1);
 552     return "@ stdcall $_($args)";
 553 }
 554
 555 sub generate_func_params($$)
 556 {
 557     my ($name, $func) = @_;
 558     my $ret = "";
 559     $ret .= sprintf "struct %s_params\n{\n", $name;
 560     $ret .= "    TEB *teb;\n";
 561     foreach my $arg (@{$func->[1]})
 562     {
 563         $ret .= sprintf "    %s;\n", $arg->textContent();
 564     }
 565     $ret .= sprintf "    %sret;\n", $func->[0]->textContent() unless is_void_func($func);
 566     $ret .= "};\n\n";
 567     return $ret;
 568 }
 569
 570 sub is_void_func($)
 571 {
 572     my $func = shift;
 573     return 0 if @{$func->[0]->findnodes("./ptype")};
 574     return $func->[0]->textContent() eq "void ";
 575 }
 576
 577 sub get_arg_type($)
 578 {
 579     my $p = (shift)->cloneNode(1);
 580     my @name = $p->findnodes("./name");
 581     $p->removeChild(@name) if @name;
 582     my $ret = $p->textContent();
 583     $ret =~ s/^ +//;
 584     $ret =~ s/ +$//;
 585     return $ret;
 586 }
 587
 588 sub get_arg_name($)
 589 {
 590     my $p = shift;
 591     my @name = $p->findnodes("./name");
 592     return $name[0]->textContent();
 593 }
 594
 595 #
 596 # Extract and checks the number of arguments
 597 #
 598 if (@ARGV > 1) {
 599     my $name0=$0;
 600     $name0=~s%^.*/%%;
 601     die "Usage: $name0 [version]\n";
 602 }
 603 my $version = $ARGV[0] || "1.1";
 604 if ($version eq "1.0") {
 605     %norm_categories = %cat_1_0;
 606 } elsif ($version eq "1.1") {
 607     %norm_categories = %cat_1_1;
 608 } elsif ($version eq "1.2") {
 609     %norm_categories = %cat_1_2;
 610 } elsif ($version eq "1.3") {
 611     %norm_categories = %cat_1_3;
 612 } elsif ($version eq "1.4") {
 613     %norm_categories = %cat_1_4;
 614 } elsif ($version eq "1.5") {
 615     %norm_categories = %cat_1_5;
 616 } else {
 617     die "Incorrect OpenGL version.\n";
 618 }
 619
 620 #
 621 # Fetch the registry files
 622 #
 623 my $url="https://raw.githubusercontent.com/KhronosGroup/OpenGL-Registry";
 624 my $commit="03e1bfb87c4664d34dc7822fb591841eec747094";
 625
 626 -f "gl-$commit.xml" || system "wget", "-O", "gl-$commit.xml", "$url/$commit/xml/gl.xml" || die "cannot download gl.xml";
 627 -f "wgl-$commit.xml" || system "wget", "-O", "wgl-$commit.xml", "$url/$commit/xml/wgl.xml" || die "cannot download wgl.xml";
 628
 629
 630 #
 631 # Then, create the list of all OpenGL functions using the registry
 632 # files. This will create two hash-tables, one with all the function
 633 # whose category matches the one listed in '@norm_categories', the other
 634 # with all other functions.
 635 #
 636 # An element of the hash table is a reference to an array with these
 637 # elements :
 638 #
 639 #  - XML node of the function prototype
 640 #
 641 #  - reference to an array of XML nodes giving the list of arguments (an empty array
 642 #    for a 'void' function).
 643 #
 644 my %norm_functions;
 645 my %ext_functions;
 646 my %wgl_functions;
 647 my %gl_enums;
 648 my (%gl_types, @gl_types);  # also use an array to preserve declaration order
 649
 650 my %remapped_wgl_functions =
 651     (
 652      "ChoosePixelFormat" => "wglChoosePixelFormat",
 653      "DescribePixelFormat" => "wglDescribePixelFormat",
 654      "GetPixelFormat" => "wglGetPixelFormat",
 655      "GetEnhMetaFilePixelFormat" => 0,
 656      "SetPixelFormat" => "wglSetPixelFormat",
 657      "SwapBuffers" => "wglSwapBuffers",
 658      "wglUseFontBitmaps" => 0,
 659      "wglUseFontOutlines" => 0,
 660     );
 661
 662 my @extra_wgl_functions = ( "wglGetDefaultProcAddress" );
 663
 664 my %supported_wgl_extensions =
 665    (
 666     "WGL_ARB_create_context" => 1,
 667     "WGL_ARB_create_context_no_error" => 1,
 668     "WGL_ARB_create_context_profile" => 1,
 669     "WGL_ARB_extensions_string" => 1,
 670     "WGL_ARB_make_current_read" => 1,
 671     "WGL_ARB_multisample" => 1,
 672     "WGL_ARB_pbuffer" => 1,
 673     "WGL_ARB_pixel_format" => 1,
 674     "WGL_ARB_framebuffer_sRGB" => 1,
 675     "WGL_ARB_pixel_format_float" => 1,
 676     "WGL_ARB_render_texture" => 1,
 677     "WGL_ATI_pixel_format_float" => 1,
 678     "WGL_EXT_create_context_es2_profile" => 1,
 679     "WGL_EXT_extensions_string" => 1,
 680     "WGL_EXT_framebuffer_sRGB" => 1,
 681     "WGL_EXT_pixel_format_packed_float" => 1,
 682     "WGL_EXT_swap_control" => 1,
 683     "WGL_EXT_swap_control_tear" => 1,
 684     "WGL_NV_float_buffer" => 1,
 685     "WGL_NV_render_depth_texture" => 1,
 686     "WGL_NV_render_texture_rectangle" => 1,
 687     "WGL_NV_vertex_array_range" => 1,
 688     "WGL_WINE_pixel_format_passthrough" => 1,
 689     "WGL_WINE_query_renderer" => 1,
 690    );
 691
 692 my %supported_apis =
 693     (
 694      "gl" => 1,
 695     );
 696
 697 sub is_supported_api($)
 698 {
 699     my $api = shift;
 700     foreach my $i (split /\|/, $api)
 701     {
 702         return 1 if defined $supported_apis{$i};
 703     }
 704     return 0;
 705 }
 706
 707 # some functions need a hand-written wrapper
 708 sub needs_wrapper($$)
 709 {
 710     my ($name, $func) = @_;
 711
 712     return 1 if $name =~ /^glDebugMessageCallback|^glGetString|^glGetIntegerv|^wglGetProcAddress/;
 713
 714     # check if return value needs special handling
 715     (my $type = $func->[0]->textContent()) =~ s/ $//;
 716     return 1 if defined $remap_types{$type};
 717     # check if one of the arguments needs special handling
 718     foreach (@{$func->[1]})
 719     {
 720         $type = get_arg_type( $_ );
 721         return 1 if defined $remap_types{$type};
 722     }
 723     return 0;
 724 }
 725
 726 sub parse_file($)
 727 {
 728     my $file = shift;
 729     my $xml = XML::LibXML->load_xml( location => $file );
 730     my %functions;
 731     my %enums;
 732
 733     # save all functions
 734     foreach my $command ($xml->findnodes("/registry/commands/command"))
 735     {
 736         my $proto = @{$command->findnodes("./proto")}[0];
 737         my $name = @{$command->findnodes("./proto/name")}[0];
 738         $proto->removeChild( $name );
 739         my @params = $command->findnodes("./param");
 740         $functions{$name->textContent()} = [ $proto, \@params ];
 741     }
 742
 743     # save all enums
 744     foreach my $enum ($xml->findnodes("/registry/enums/enum"))
 745     {
 746         $enums{$enum->{name}} = $enum->{value};
 747     }
 748
 749     # save all types
 750     foreach my $type ($xml->findnodes("/registry/types/type"))
 751     {
 752         next if $type->{api};
 753         my $name = @{$type->findnodes("./name")}[0];
 754         next unless $name;
 755         $name = $name->textContent;
 756         push @gl_types, $name unless $gl_types{$name};
 757         $gl_types{$name} = $type;
 758     }
 759
 760     # generate norm functions
 761     foreach my $feature ($xml->findnodes("/registry/feature"))
 762     {
 763         if ($feature->{api} eq "wgl")
 764         {
 765             foreach my $cmd ($feature->findnodes("./require/command"))
 766             {
 767                 my $name = $cmd->{name};
 768                 if (defined $remapped_wgl_functions{$name})
 769                 {
 770                     next unless $remapped_wgl_functions{$name};
 771                     $name = $remapped_wgl_functions{$name};
 772                 }
 773                 $wgl_functions{$name} = $functions{$cmd->{name}};
 774             }
 775             foreach my $name (@extra_wgl_functions)
 776             {
 777                 $wgl_functions{$name} = $functions{$name} if defined $functions{$name};
 778             }
 779         }
 780         next unless defined $norm_categories{$feature->{name}};
 781         foreach my $cmd ($feature->findnodes("./require/command"))
 782         {
 783             $norm_functions{$cmd->{name}} = $functions{$cmd->{name}};
 784         }
 785         foreach my $enum ($feature->findnodes("./require/enum"))
 786         {
 787             $gl_enums{$enum->{name}} = $enums{$enum->{name}};
 788         }
 789     }
 790
 791     # generate extension functions from norm functions, if they are newer than the category
 792     foreach my $feature ($xml->findnodes("/registry/feature"))
 793     {
 794         next if defined $norm_categories{$feature->{name}};
 795         next unless is_supported_api( $feature->{api} );
 796         foreach my $cmd ($feature->findnodes("./require/command"))
 797         {
 798             my $name = $cmd->{name};
 799             next if $norm_functions{$name} || $ext_functions{$name};
 800             $ext_functions{$name} = [ $functions{$name}[0], $functions{$name}[1], [ $feature->{name} ] ];
 801         }
 802         foreach my $enum ($feature->findnodes("./require/enum"))
 803         {
 804             $gl_enums{$enum->{name}} = $enums{$enum->{name}};
 805         }
 806     }
 807
 808     # generate extension functions
 809     foreach my $ext ($xml->findnodes("/registry/extensions/extension"))
 810     {
 811         if ($ext->{supported} eq "wgl")
 812         {
 813             next unless defined $supported_wgl_extensions{$ext->{name}};
 814             foreach my $cmd ($ext->findnodes("./require/command"))
 815             {
 816                 my $name = $cmd->{name};
 817                 $ext_functions{$name} = [ $functions{$name}[0], $functions{$name}[1], [ $ext->{name} ] ];
 818             }
 819             foreach my $enum ($ext->findnodes("./require/enum"))
 820             {
 821                 $gl_enums{$enum->{name}} = $enums{$enum->{name}};
 822             }
 823             next;
 824         }
 825         next unless is_supported_api( $ext->{supported} );
 826         foreach my $req ($ext->findnodes("./require"))
 827         {
 828             next unless !$req->{api} || $req->{api} eq "gl";
 829             foreach my $cmd ($req->findnodes("./command"))
 830             {
 831                 my $name = $cmd->{name};
 832                 next if $norm_functions{$name};
 833                 if (!$ext_functions{$name})
 834                 {
 835                     $ext_functions{$name} = [ $functions{$name}[0], $functions{$name}[1], [ $ext->{name} ] ];
 836                 }
 837                 else
 838                 {
 839                     push @{$ext_functions{$name}->[2]}, $ext->{name};
 840                 }
 841             }
 842         }
 843         foreach my $enum ($ext->findnodes("./require/enum"))
 844         {
 845             $gl_enums{$enum->{name}} = $enums{$enum->{name}};
 846         }
 847     }
 848 }
 849
 850 parse_file( "gl-$commit.xml" );
 851 parse_file( "wgl-$commit.xml" );
 852 parse_file( "winegl.xml" );
 853
 854 #
 855 # Get the current wgl_driver.h version
 856 #
 857 my $wgl_version = 0;
 858 open HEADER, "<$wgl_driver_file" or die "cannot open $wgl_driver_file";
 859 while (<HEADER>)
 860 {
 861     next unless /^#define WINE_WGL_DRIVER_VERSION (\d+)/;
 862     $wgl_version = $1;
 863     last;
 864 }
 865 close HEADER;
 866
 867 #
 868 # Generate the wgl_driver.h file
 869 #
 870 open HEADER, ">$wgl_driver_file" or die "cannot create $wgl_driver_file";
 871 print HEADER "/* Automatically generated from http://www.opengl.org/registry files; DO NOT EDIT! */\n\n";
 872 print HEADER "#ifndef __WINE_WGL_DRIVER_H\n";
 873 print HEADER "#define __WINE_WGL_DRIVER_H\n\n";
 874 print HEADER "#ifndef WINE_GLAPI\n";
 875 print HEADER "#define WINE_GLAPI\n";
 876 print HEADER "#endif\n\n";
 877
 878 printf HEADER "#define WINE_WGL_DRIVER_VERSION %u\n\n", $wgl_version + 1;
 879
 880 print HEADER "struct wgl_context;\n";
 881 print HEADER "struct wgl_pbuffer;\n\n";
 882
 883 print HEADER "struct opengl_funcs\n{\n";
 884 print HEADER "    struct\n    {\n";
 885 foreach (sort keys %wgl_functions)
 886 {
 887     next if defined $manual_win_functions{$_};
 888     my $decl_args = get_func_args( $wgl_functions{$_}, 1, 1, "" );
 889     my $func_ret = get_func_ret( $wgl_functions{$_}, 1 );
 890     printf HEADER "        %-10s (WINE_GLAPI *p_$_)($decl_args);\n", $func_ret;
 891 }
 892 print HEADER "    } wgl;\n\n";
 893
 894 print HEADER "    struct\n    {\n";
 895 foreach (sort keys %norm_functions)
 896 {
 897     next if defined $manual_win_functions{$_};
 898     my $decl_args = get_func_args( $norm_functions{$_}, 1, 1, "" );
 899     my $func_ret = get_func_ret( $norm_functions{$_}, 1 );
 900     printf HEADER "        %-10s (WINE_GLAPI *p_$_)($decl_args);\n", $func_ret;
 901 }
 902 print HEADER "    } gl;\n\n";
 903
 904 print HEADER "    struct\n    {\n";
 905 foreach (sort keys %ext_functions)
 906 {
 907     next if defined $manual_win_functions{$_};
 908     my $decl_args = get_func_args( $ext_functions{$_}, 1, 1, "" );
 909     my $func_ret = get_func_ret( $ext_functions{$_}, 1 );
 910     printf HEADER "        %-10s (WINE_GLAPI *p_$_)($decl_args);\n", $func_ret;
 911 }
 912 print HEADER "    } ext;\n";
 913 print HEADER "};\n\n";
 914
 915 print HEADER "#define ALL_WGL_FUNCS";
 916 foreach (sort keys %norm_functions)
 917 {
 918     next if defined $manual_win_functions{$_};
 919     printf HEADER " \\\n    USE_GL_FUNC(\%s)", $_;
 920 }
 921 print HEADER "\n\n";
 922
 923 print HEADER "extern struct opengl_funcs *__wine_get_wgl_driver( HDC hdc, UINT version );\n\n";
 924 print HEADER "#endif /* __WINE_WGL_DRIVER_H */\n";
 925 close HEADER;
 926
 927 #
 928 # Generate the wgl.h file
 929 #
 930 open HEADER, ">$wgl_file" or die "cannot create $wgl_file";
 931 print HEADER "/* Automatically generated from http://www.opengl.org/registry files; DO NOT EDIT! */\n\n";
 932 print HEADER "#ifndef __WINE_WGL_H\n";
 933 print HEADER "#define __WINE_WGL_H\n\n";
 934
 935 print HEADER "#ifndef GLAPIENTRY\n";
 936 print HEADER "#define GLAPIENTRY __stdcall\n";
 937 print HEADER "#endif\n\n";
 938
 939 foreach (@gl_types)
 940 {
 941     my $type = $gl_types{$_}->textContent();
 942     foreach my $t (keys %khronos_types) { $type =~ s/\s(\Q$t\E)\s/ $khronos_types{$t} /; }
 943     printf HEADER $type . "\n";
 944 }
 945 print HEADER "\n";
 946
 947 my $maxlen = 1;
 948 foreach (keys %gl_enums) { $maxlen = length($_) if length($_) > $maxlen; }
 949 foreach (sort keys %gl_enums)
 950 {
 951     printf HEADER "#define %-*s %s\n", $maxlen, $_, $gl_enums{$_};
 952 }
 953 print HEADER "\n";
 954
 955 foreach (sort keys %norm_functions)
 956 {
 957     my $decl_args = get_func_args( $norm_functions{$_}, 1, 0, "" );
 958     my $func_ret = get_func_ret( $norm_functions{$_}, 0 );
 959     printf HEADER "%-10s GLAPIENTRY $_($decl_args);\n", $func_ret;
 960 }
 961
 962 print HEADER "\n#endif /* __WINE_WGL_H */\n";
 963 close HEADER;
 964
 965 #
 966 # Now, generate the output files. First, the spec file.
 967 #
 968 open(SPEC, ">$spec_file") or die "cannot create $spec_file";
 969
 970 foreach (sort keys %norm_functions)
 971 {
 972     printf SPEC "%s\n", generate_spec_entry( $_, $norm_functions{$_} );
 973 }
 974 foreach (sort keys %wgl_functions)
 975 {
 976     printf SPEC "%s\n", generate_spec_entry( $_, $wgl_functions{$_} );
 977 }
 978
 979 close(SPEC);
 980
 981 #
 982 # Generate the unixlib.h file
 983 #
 984 open OUT, ">unixlib.h" or die "cannot create unixlib.h";
 985 print OUT "/* Automatically generated from http://www.opengl.org/registry files; DO NOT EDIT! */\n\n";
 986 print OUT "#ifndef __WINE_OPENGL32_UNIXLIB_H\n";
 987 print OUT "#define __WINE_OPENGL32_UNIXLIB_H\n\n";
 988
 989 print OUT "#include <stdarg.h>\n";
 990 print OUT "#include <stddef.h>\n\n";
 991
 992 print OUT "#include \"ntstatus.h\"\n";
 993 print OUT "#define WIN32_NO_STATUS\n";
 994 print OUT "#include \"windef.h\"\n";
 995 print OUT "#include \"winbase.h\"\n";
 996 print OUT "#include \"winternl.h\"\n";
 997 print OUT "#include \"wingdi.h\"\n\n";
 998 print OUT "#include \"wine/wgl.h\"\n";
 999 print OUT "#include \"wine/unixlib.h\"\n\n";
1000
1001 foreach (sort keys %wgl_functions)
1002 {
1003     next if defined $manual_win_functions{$_};
1004     print OUT generate_func_params($_, $wgl_functions{$_});
1005 }
1006 foreach (sort keys %norm_functions)
1007 {
1008     next if defined $manual_win_functions{$_};
1009     print OUT generate_func_params($_, $norm_functions{$_});
1010 }
1011 foreach (sort keys %ext_functions)
1012 {
1013     next if defined $manual_win_functions{$_};
1014     print OUT generate_func_params($_, $ext_functions{$_});
1015 }
1016
1017 print OUT "enum unix_funcs\n";
1018 print OUT "{\n";
1019 print OUT "    unix_thread_attach,\n";
1020 print OUT "    unix_process_detach,\n";
1021 foreach (sort keys %wgl_functions)
1022 {
1023     next if defined $manual_win_functions{$_};
1024     printf OUT "    unix_%s,\n", $_;
1025 }
1026 foreach (sort keys %norm_functions)
1027 {
1028     next if defined $manual_win_functions{$_};
1029     printf OUT "    unix_%s,\n", $_;
1030 }
1031 foreach (sort keys %ext_functions)
1032 {
1033     next if defined $manual_win_functions{$_};
1034     printf OUT "    unix_%s,\n", $_;
1035 }
1036 print OUT "};\n\n";
1037
1038 print OUT "typedef void (WINAPI *gl_debug_cb)(GLenum, GLenum, GLuint, GLenum, GLsizei, const GLchar *, const void *);\n";
1039 print OUT "struct wine_gl_debug_message_params\n";
1040 print OUT "{\n";
1041 print OUT "    gl_debug_cb user_callback;\n";
1042 print OUT "    const void *user_data;\n";
1043 print OUT "\n";
1044 print OUT "    GLenum source;\n";
1045 print OUT "    GLenum type;\n";
1046 print OUT "    GLuint id;\n";
1047 print OUT "    GLenum severity;\n";
1048 print OUT "    GLsizei length;\n";
1049 print OUT "    const GLchar *message;\n";
1050 print OUT "};\n\n";
1051
1052 print OUT "#define UNIX_CALL( func, params ) WINE_UNIX_CALL( unix_ ## func, params )\n\n";
1053
1054 print OUT "#endif /* __WINE_OPENGL32_UNIXLIB_H */\n";
1055 close OUT;
1056
1057 #
1058 # Generate the thunks.c file
1059 #
1060 open OUT, ">thunks.c" or die "cannot create thunks.c";
1061 print OUT "/* Automatically generated from http://www.opengl.org/registry files; DO NOT EDIT! */\n\n";
1062
1063 print OUT "#include <stdarg.h>\n";
1064 print OUT "#include <stddef.h>\n\n";
1065
1066 print OUT "#include \"ntstatus.h\"\n";
1067 print OUT "#define WIN32_NO_STATUS\n";
1068 print OUT "#include \"windef.h\"\n";
1069 print OUT "#include \"winbase.h\"\n";
1070 print OUT "#include \"wingdi.h\"\n\n";
1071
1072 print OUT "#include \"unixlib.h\"\n";
1073 print OUT "#include \"private.h\"\n\n";
1074 print OUT "#include \"wine/debug.h\"\n\n";
1075 print OUT "WINE_DEFAULT_DEBUG_CHANNEL(opengl);\n";
1076
1077 foreach (sort keys %wgl_functions)
1078 {
1079     next if defined $manual_win_functions{$_};
1080     next if defined $manual_win_thunks{$_};
1081     print OUT "\n" . generate_win_thunk($_, $wgl_functions{$_});
1082 }
1083 foreach (sort keys %norm_functions)
1084 {
1085     next if defined $manual_win_functions{$_};
1086     next if defined $manual_win_thunks{$_};
1087     print OUT "\n" . generate_win_thunk($_, $norm_functions{$_});
1088 }
1089 foreach (sort keys %ext_functions)
1090 {
1091     next if defined $manual_win_functions{$_};
1092     next if defined $manual_win_thunks{$_};
1093     print OUT "\nstatic " . generate_win_thunk($_, $ext_functions{$_});
1094 }
1095 print OUT "\n";
1096
1097 foreach (sort keys %ext_functions)
1098 {
1099     next unless defined $manual_win_functions{$_} || $manual_win_thunks{$_};
1100     my $decl_args = get_func_args( $ext_functions{$_}, 1, 0, "" );
1101     my $func_ret = get_func_ret( $ext_functions{$_}, 0 );
1102     printf OUT "extern %s WINAPI %s(%s) DECLSPEC_HIDDEN;\n", $func_ret, $_, $decl_args;
1103 }
1104
1105 print OUT "const void *extension_procs[] =\n";
1106 print OUT "{\n";
1107 foreach (sort keys %ext_functions)
1108 {
1109     printf OUT "    %s,\n", $_;
1110 }
1111 print OUT "};\n";
1112
1113 close OUT;
1114
1115 #
1116 # Generate the unix_thunks.c file
1117 #
1118 open OUT, ">unix_thunks.c" or die "cannot create unix_thunks.c";
1119 print OUT "/* Automatically generated from http://www.opengl.org/registry files; DO NOT EDIT! */\n\n";
1120
1121 print OUT "#if 0\n";
1122 print OUT "#pragma makedep unix\n";
1123 print OUT "#endif\n\n";
1124
1125 print OUT "#include <stdarg.h>\n";
1126 print OUT "#include <stddef.h>\n\n";
1127
1128 print OUT "#include \"ntstatus.h\"\n";
1129 print OUT "#define WIN32_NO_STATUS\n";
1130 print OUT "#include \"windef.h\"\n";
1131 print OUT "#include \"winbase.h\"\n";
1132 print OUT "#include \"wingdi.h\"\n\n";
1133
1134 print OUT "#include \"unixlib.h\"\n";
1135 print OUT "#include \"unix_private.h\"\n\n";
1136 print OUT "#include \"wine/debug.h\"\n\n";
1137
1138 print OUT "#ifdef _WIN64\n";
1139 print OUT "WINE_DEFAULT_DEBUG_CHANNEL(opengl);\n";
1140 print OUT "#endif\n\n";
1141
1142 print OUT "extern NTSTATUS thread_attach( void *args ) DECLSPEC_HIDDEN;\n";
1143 print OUT "extern NTSTATUS process_detach( void *args ) DECLSPEC_HIDDEN;\n";
1144 foreach (sort keys %wgl_functions)
1145 {
1146     next if defined $manual_win_functions{$_};
1147     next unless needs_wrapper( $_, $wgl_functions{$_} );
1148     print OUT "extern NTSTATUS wgl_$_( void *args ) DECLSPEC_HIDDEN;\n";
1149 }
1150 foreach (sort keys %norm_functions)
1151 {
1152     next if defined $manual_win_functions{$_};
1153     next unless needs_wrapper( $_, $norm_functions{$_} );
1154     print OUT "extern NTSTATUS gl_$_( void *args ) DECLSPEC_HIDDEN;\n";
1155 }
1156 foreach (sort keys %ext_functions)
1157 {
1158     next if defined $manual_win_functions{$_};
1159     next unless needs_wrapper( $_, $ext_functions{$_} );
1160     print OUT "extern NTSTATUS ext_$_( void *args ) DECLSPEC_HIDDEN;\n";
1161 }
1162 print OUT "\n";
1163
1164 foreach (sort keys %wgl_functions)
1165 {
1166     next if defined $manual_win_functions{$_};
1167     next if needs_wrapper( $_, $wgl_functions{$_} );
1168     print OUT "static " unless defined $manual_wow64_thunks{$_};
1169     print OUT generate_unix_thunk($_, $wgl_functions{$_}, "wgl");
1170 }
1171 foreach (sort keys %norm_functions)
1172 {
1173     next if defined $manual_win_functions{$_};
1174     next if needs_wrapper( $_, $norm_functions{$_} );
1175     print OUT "static " unless defined $manual_wow64_thunks{$_};
1176     print OUT generate_unix_thunk($_, $norm_functions{$_}, "gl");
1177 }
1178 foreach (sort keys %ext_functions)
1179 {
1180     next if defined $manual_win_functions{$_};
1181     next if needs_wrapper( $_, $ext_functions{$_} );
1182     print OUT "static " unless defined $manual_wow64_thunks{$_};
1183     print OUT generate_unix_thunk($_, $ext_functions{$_}, "ext");
1184 }
1185
1186 print OUT "const unixlib_entry_t __wine_unix_call_funcs[] =\n";
1187 print OUT "{\n";
1188 print OUT "    &thread_attach,\n";
1189 print OUT "    &process_detach,\n";
1190 foreach (sort keys %wgl_functions)
1191 {
1192     next if defined $manual_win_functions{$_};
1193     printf OUT "    &wgl_%s,\n", $_;
1194 }
1195 foreach (sort keys %norm_functions)
1196 {
1197     next if defined $manual_win_functions{$_};
1198     printf OUT "    &gl_%s,\n", $_;
1199 }
1200 foreach (sort keys %ext_functions)
1201 {
1202     next if defined $manual_win_functions{$_};
1203     printf OUT "    &ext_%s,\n", $_;
1204 }
1205 print OUT "};\n";
1206 print OUT "\n";
1207
1208 print OUT "#ifdef _WIN64\n\n";
1209 print OUT "typedef ULONG PTR32;\n\n";
1210 print OUT "extern NTSTATUS wow64_thread_attach( void *args ) DECLSPEC_HIDDEN;\n";
1211 print OUT "extern NTSTATUS wow64_process_detach( void *args ) DECLSPEC_HIDDEN;\n\n";
1212
1213 foreach (sort keys %wgl_functions)
1214 {
1215     next if defined $manual_win_functions{$_};
1216     next if defined $manual_wow64_thunks{$_};
1217     print OUT generate_wow64_thunk($_, $wgl_functions{$_}, "wgl");
1218 }
1219 foreach (sort keys %norm_functions)
1220 {
1221     next if defined $manual_win_functions{$_};
1222     next if defined $manual_wow64_thunks{$_};
1223     print OUT generate_wow64_thunk($_, $norm_functions{$_}, "gl");
1224 }
1225 foreach (sort keys %ext_functions)
1226 {
1227     next if defined $manual_win_functions{$_};
1228     next if defined $manual_wow64_thunks{$_};
1229     print OUT generate_wow64_thunk($_, $ext_functions{$_}, "ext");
1230 }
1231
1232 foreach (sort keys %wgl_functions)
1233 {
1234     next if defined $manual_win_functions{$_};
1235     next unless defined $manual_wow64_thunks{$_};
1236     print OUT "extern NTSTATUS wow64_wgl_$_( void *args ) DECLSPEC_HIDDEN;\n";
1237 }
1238 foreach (sort keys %norm_functions)
1239 {
1240     next if defined $manual_win_functions{$_};
1241     next unless defined $manual_wow64_thunks{$_};
1242     print OUT "extern NTSTATUS wow64_gl_$_( void *args ) DECLSPEC_HIDDEN;\n";
1243 }
1244 foreach (sort keys %ext_functions)
1245 {
1246     next if defined $manual_win_functions{$_};
1247     next unless defined $manual_wow64_thunks{$_};
1248     print OUT "extern NTSTATUS wow64_ext_$_( void *args ) DECLSPEC_HIDDEN;\n";
1249 }
1250
1251 print OUT "\nconst unixlib_entry_t __wine_unix_call_wow64_funcs[] =\n";
1252 print OUT "{\n";
1253 print OUT "    wow64_thread_attach,\n";
1254 print OUT "    wow64_process_detach,\n";
1255 foreach (sort keys %wgl_functions)
1256 {
1257     next if defined $manual_win_functions{$_};
1258     printf OUT "    wow64_wgl_%s,\n", $_;
1259 }
1260 foreach (sort keys %norm_functions)
1261 {
1262     next if defined $manual_win_functions{$_};
1263     printf OUT "    wow64_gl_%s,\n", $_;
1264 }
1265 foreach (sort keys %ext_functions)
1266 {
1267     next if defined $manual_win_functions{$_};
1268     printf OUT "    wow64_ext_%s,\n", $_;
1269 }
1270 print OUT "};\n\n";
1271
1272 print OUT "#endif\n\n";
1273
1274 foreach (sort keys %wgl_functions)
1275 {
1276     next if defined $manual_win_functions{$_};
1277     print OUT generate_null_func($_, $wgl_functions{$_});
1278 }
1279 foreach (sort keys %norm_functions)
1280 {
1281     next if defined $manual_win_functions{$_};
1282     print OUT generate_null_func($_, $norm_functions{$_});
1283 }
1284 foreach (sort keys %ext_functions)
1285 {
1286     next if defined $manual_win_functions{$_};
1287     print OUT generate_null_func($_, $ext_functions{$_});
1288 }
1289 print OUT "\n";
1290
1291 print OUT "struct opengl_funcs null_opengl_funcs =\n";
1292 print OUT "{\n";
1293 print OUT "    {\n";
1294 foreach (sort keys %wgl_functions)
1295 {
1296     next if defined $manual_win_functions{$_};
1297     print OUT "        null_$_,\n";
1298 }
1299 print OUT "    },\n";
1300 print OUT "    {\n";
1301 foreach (sort keys %norm_functions)
1302 {
1303     next if defined $manual_win_functions{$_};
1304     print OUT "        null_$_,\n";
1305 }
1306 print OUT "    },\n";
1307 print OUT "    {\n";
1308 foreach (sort keys %ext_functions)
1309 {
1310     next if defined $manual_win_functions{$_};
1311     print OUT "        null_$_,\n";
1312 }
1313 print OUT "    },\n";
1314 print OUT "};\n";
1315
1316 # Then the table giving the string <-> function correspondence */
1317 my $count = keys %ext_functions;
1318 print OUT "\nconst int extension_registry_size = $count;\n";
1319 print OUT "const struct registry_entry extension_registry[$count] =\n";
1320 print OUT "{\n";
1321 foreach (sort keys %ext_functions)
1322 {
1323     my $func = $ext_functions{$_};
1324     printf OUT "    { \"%s\", \"%s\" },\n", $_, join(" ", sort @{$func->[2]});
1325 }
1326 print OUT "};\n";
1327
1328 close OUT;