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