Add version info to dll/dsound.
[wine] / tools / make_requests
1 #! /usr/bin/perl -w
2 #
3 # Build the server/trace.c and server/request.h files
4 # from the contents of include/wine/server.h.
5 #
6 # Copyright (C) 1998 Alexandre Julliard
7 #
8 # This library is free software; you can redistribute it and/or
9 # modify it under the terms of the GNU Lesser General Public
10 # License as published by the Free Software Foundation; either
11 # version 2.1 of the License, or (at your option) any later version.
12 #
13 # This library is distributed in the hope that it will be useful,
14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 # Lesser General Public License for more details.
17 #
18 # You should have received a copy of the GNU Lesser General Public
19 # License along with this library; if not, write to the Free Software
20 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21 #
22
23 %formats =
24 (
25     "int"           => "%d",
26     "short int"     => "%d",
27     "char"          => "%c",
28     "unsigned char" => "%02x",
29     "unsigned short"=> "%04x",
30     "unsigned int"  => "%08x",
31     "void*"         => "%p",
32     "time_t"        => "%ld",
33     "size_t"        => "%d",
34     "obj_handle_t"  => "%p",
35     "atom_t"        => "%04x",
36     "user_handle_t" => "%p",
37     "process_id_t"  => "%08x",
38     "thread_id_t"   => "%08x",
39     "rectangle_t"   => "&dump_rectangle",
40     "char_info_t"   => "&dump_char_info",
41 );
42
43 my @requests = ();
44 my %replies = ();
45
46 my @trace_lines = ();
47
48 # Get the server protocol version
49 my $protocol = &GET_PROTOCOL_VERSION;
50
51 ### Create server_protocol.h and print header
52
53 open SERVER_PROT, ">include/wine/server_protocol.h" or die "Cannot create include/wine/server_protocol.h";
54 print SERVER_PROT "/*\n * Wine server protocol definitions\n *\n";
55 print SERVER_PROT " * This file is automatically generated; DO NO EDIT!\n";
56 print SERVER_PROT " * Edit server/protocol.def instead and re-run tools/make_requests\n";
57 print SERVER_PROT " */\n\n";
58 print SERVER_PROT "#ifndef __WINE_WINE_SERVER_PROTOCOL_H\n";
59 print SERVER_PROT "#define __WINE_WINE_SERVER_PROTOCOL_H\n";
60
61 ### Parse requests to find request/reply structure definitions
62
63 &PARSE_REQUESTS;
64
65 ### Build the request list and structures
66
67 print SERVER_PROT "\n\nenum request\n{\n";
68 foreach $req (@requests) { print SERVER_PROT "    REQ_$req,\n"; }
69 print SERVER_PROT "    REQ_NB_REQUESTS\n};\n\n";
70
71 print SERVER_PROT "union generic_request\n{\n";
72 print SERVER_PROT "    struct request_max_size max_size;\n";
73 print SERVER_PROT "    struct request_header request_header;\n";
74 foreach $req (@requests) { print SERVER_PROT "    struct ${req}_request ${req}_request;\n"; }
75 print SERVER_PROT "};\n";
76
77 print SERVER_PROT "union generic_reply\n{\n";
78 print SERVER_PROT "    struct request_max_size max_size;\n";
79 print SERVER_PROT "    struct reply_header reply_header;\n";
80 foreach $req (@requests) { print SERVER_PROT "    struct ${req}_reply ${req}_reply;\n"; }
81 print SERVER_PROT "};\n\n";
82
83 printf SERVER_PROT "#define SERVER_PROTOCOL_VERSION %d\n\n", $protocol + 1;
84 print SERVER_PROT "#endif /* __WINE_WINE_SERVER_PROTOCOL_H */\n";
85 close SERVER_PROT;
86
87 ### Output the dumping function tables
88
89 push @trace_lines, "static const dump_func req_dumpers[REQ_NB_REQUESTS] = {\n";
90 foreach $req (@requests)
91 {
92     push @trace_lines, "    (dump_func)dump_${req}_request,\n";
93 }
94 push @trace_lines, "};\n\n";
95
96 push @trace_lines, "static const dump_func reply_dumpers[REQ_NB_REQUESTS] = {\n";
97 foreach $req (@requests)
98 {
99     push @trace_lines, "    (dump_func)", $replies{$req} ? "dump_${req}_reply,\n" : "0,\n";
100 }
101 push @trace_lines, "};\n\n";
102
103 push @trace_lines, "static const char * const req_names[REQ_NB_REQUESTS] = {\n";
104 foreach $req (@requests)
105 {
106     push @trace_lines, "    \"$req\",\n";
107 }
108 push @trace_lines, "};\n";
109
110 REPLACE_IN_FILE( "server/trace.c", @trace_lines );
111
112 ### Output the request handlers list
113
114 my @request_lines = ();
115
116 foreach $req (@requests) { push @request_lines, "DECL_HANDLER($req);\n"; }
117 push @request_lines, "\n#ifdef WANT_REQUEST_HANDLERS\n\n";
118 push @request_lines, "typedef void (*req_handler)( const void *req, void *reply );\n";
119 push @request_lines, "static const req_handler req_handlers[REQ_NB_REQUESTS] =\n{\n";
120 foreach $req (@requests)
121 {
122     push @request_lines, "    (req_handler)req_$req,\n";
123 }
124 push @request_lines, "};\n#endif  /* WANT_REQUEST_HANDLERS */\n";
125
126 REPLACE_IN_FILE( "server/request.h", @request_lines );
127
128 ### Parse the request definitions
129
130 sub PARSE_REQUESTS
131 {
132     # states: 0 = header 1 = declarations 2 = inside @REQ 3 = inside @REPLY
133     my $state = 0;
134     my $name = "";
135     my @in_struct = ();
136     my @out_struct = ();
137
138     open(PROTOCOL,"server/protocol.def") or die "Can't open server/protocol.def";
139
140     while (<PROTOCOL>)
141     {
142         my ($type, $var);
143         # strip comments
144         s!/\*.*\*/!!g;
145         # strip white space at end of line
146         s/\s+$//;
147
148         if (/^\@HEADER/)
149         {
150             die "Misplaced \@HEADER" unless $state == 0;
151             $state++;
152             next;
153         }
154
155         # ignore everything while in state 0
156         next if $state == 0;
157
158         if (/^\@REQ\(\s*(\w+)\s*\)/)
159         {
160             $name = $1;
161             die "Misplaced \@REQ" unless $state == 1;
162             # start a new request
163             @in_struct = ();
164             @out_struct = ();
165             print SERVER_PROT "struct ${name}_request\n{\n";
166             print SERVER_PROT "    struct request_header __header;\n";
167             $state++;
168             next;
169         }
170
171         if (/^\@REPLY/)
172         {
173             die "Misplaced \@REPLY" unless $state == 2;
174             print SERVER_PROT "};\n";
175             print SERVER_PROT "struct ${name}_reply\n{\n";
176             print SERVER_PROT "    struct reply_header __header;\n";
177             $state++;
178             next;
179         }
180
181         if (/^\@END/)
182         {
183             die "Misplaced \@END" unless ($state == 2 || $state == 3);
184             print SERVER_PROT "};\n";
185
186             if ($state == 2)  # build dummy reply struct
187             {
188                 print SERVER_PROT "struct ${name}_reply\n{\n";
189                 print SERVER_PROT "    struct reply_header __header;\n";
190                 print SERVER_PROT "};\n";
191             }
192
193             # got a complete request
194             push @requests, $name;
195             &DO_DUMP_FUNC( $name, "request", @in_struct);
196             if ($#out_struct >= 0)
197             {
198                 $replies{$name} = 1;
199                 &DO_DUMP_FUNC( $name, "reply", @out_struct);
200             }
201             $state = 1;
202             next;
203         }
204
205         if ($state != 1)
206         {
207             # skip empty lines (but keep them in output file)
208             if (/^$/)
209             {
210                 print SERVER_PROT "\n";
211                 next;
212             }
213
214             if (/^\s*VARARG\((\w+),(\w+),(\w+)\)/)
215             {
216                 $var = $1;
217                 $type = "dump_varargs_" . $2 . "( min(cur_size,req->" . $3 . ") )";
218                 s!(VARARG\(.*\)\s*;)!/* $1 */!;
219             }
220             elsif (/^\s*VARARG\((\w+),(\w+)\)/)
221             {
222                 $var = $1;
223                 $type = "dump_varargs_" . $2 . "( cur_size )";
224                 s!(VARARG\(.*\)\s*;)!/* $1 */!;
225             }
226             elsif (/^\s*(\w+\**(\s+\w+\**)*)\s+(\w+);/)
227             {
228                 $type = $1;
229                 $var = $3;
230                 die "Unrecognized type $type" unless defined($formats{$type});
231             }
232             else
233             {
234                 die "Unrecognized syntax $_";
235             }
236             if ($state == 2) { push @in_struct, $type, $var; }
237             if ($state == 3) { push @out_struct, $type, $var; }
238         }
239
240         # Pass it through into the output file
241         print SERVER_PROT $_ . "\n";
242     }
243     close PROTOCOL;
244 }
245
246 ### Generate a dumping function
247
248 sub DO_DUMP_FUNC
249 {
250     my $name = shift;
251     my $req = shift;
252     push @trace_lines, "static void dump_${name}_$req( const struct ${name}_$req *req )\n{\n";
253     while ($#_ >= 0)
254     {
255         my $type = shift;
256         my $var = shift;
257         if (defined($formats{$type}))
258         {
259             if ($formats{$type} =~ /^&(.*)/)
260             {
261                 my $func = $1;
262                 push @trace_lines, "    fprintf( stderr, \" $var=\" );\n";
263                 push @trace_lines, "    $func( &req->$var );\n";
264                 push @trace_lines, "    fprintf( stderr, \",\" );\n" if ($#_ > 0);
265             }
266             else
267             {
268                 push @trace_lines, "    fprintf( stderr, \" $var=$formats{$type}";
269                 push @trace_lines, "," if ($#_ > 0);
270                 push @trace_lines, "\", ";
271                 push @trace_lines, "req->$var );\n";
272             }
273         }
274         else  # must be some varargs format
275         {
276             my $func = $type;
277             push @trace_lines, "    fprintf( stderr, \" $var=\" );\n";
278             push @trace_lines, "    $func;\n";
279             push @trace_lines, "    fputc( ',', stderr );\n" if ($#_ > 0);
280         }
281     }
282     push @trace_lines, "}\n\n";
283 }
284
285 ### Retrieve the server protocol version from the existing server_protocol.h file
286
287 sub GET_PROTOCOL_VERSION
288 {
289     my $protocol = 0;
290     open SERVER_PROT, "include/wine/server_protocol.h" or return 0;
291     while (<SERVER_PROT>)
292     {
293         if (/^\#define SERVER_PROTOCOL_VERSION (\d+)/) { $protocol = $1; last; }
294     }
295     close SERVER_PROT;
296     return $protocol;
297 }
298
299 ### Replace the contents of a file between ### make_requests ### marks
300
301 sub REPLACE_IN_FILE
302 {
303     my $name = shift;
304     my @data = @_;
305     my @lines = ();
306     open(FILE,$name) or die "Can't open $name";
307     while (<FILE>)
308     {
309         push @lines, $_;
310         last if /\#\#\# make_requests begin \#\#\#/;
311     }
312     push @lines, "\n", @data;
313     while (<FILE>)
314     {
315         if (/\#\#\# make_requests end \#\#\#/) { push @lines, "\n", $_; last; }
316     }
317     push @lines, <FILE>;
318     open(FILE,">$name") or die "Can't modify $name";
319     print FILE @lines;
320     close(FILE);
321 }