widl: Zero initialize parameters in the generated server code.
[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 use strict;
23
24 my %formats =
25 (
26     "int"           => "%d",
27     "short int"     => "%d",
28     "char"          => "%c",
29     "unsigned char" => "%02x",
30     "unsigned short"=> "%04x",
31     "unsigned int"  => "%08x",
32     "void*"         => "%p",
33     "time_t"        => "%ld",
34     "size_t"        => "%d",
35     "obj_handle_t"  => "%p",
36     "atom_t"        => "%04x",
37     "user_handle_t" => "%p",
38     "process_id_t"  => "%04x",
39     "thread_id_t"   => "%04x",
40     "abs_time_t"    => "&dump_abs_time",
41     "rectangle_t"   => "&dump_rectangle",
42     "char_info_t"   => "&dump_char_info",
43 );
44
45 my @requests = ();
46 my %replies = ();
47
48 my @trace_lines = ();
49
50
51
52 ### Generate a dumping function
53
54 sub DO_DUMP_FUNC($$@)
55 {
56     my $name = shift;
57     my $req = shift;
58     push @trace_lines, "static void dump_${name}_$req( const struct ${name}_$req *req )\n{\n";
59     while ($#_ >= 0)
60     {
61         my $type = shift;
62         my $var = shift;
63         if (defined($formats{$type}))
64         {
65             if ($formats{$type} =~ /^&(.*)/)
66             {
67                 my $func = $1;
68                 push @trace_lines, "    fprintf( stderr, \" $var=\" );\n";
69                 push @trace_lines, "    $func( &req->$var );\n";
70                 push @trace_lines, "    fprintf( stderr, \",\" );\n" if ($#_ > 0);
71             }
72             else
73             {
74                 push @trace_lines, "    fprintf( stderr, \" $var=$formats{$type}";
75                 push @trace_lines, "," if ($#_ > 0);
76                 push @trace_lines, "\", ";
77                 # In the case of time_t we need to cast the parameter to
78                 # long to match the associated "%ld" printf modifier.
79                 push @trace_lines, "(long)" if( $type eq "time_t" );
80                 push @trace_lines, "req->$var );\n";
81             }
82         }
83         else  # must be some varargs format
84         {
85             my $func = $type;
86             push @trace_lines, "    fprintf( stderr, \" $var=\" );\n";
87             push @trace_lines, "    $func;\n";
88             push @trace_lines, "    fputc( ',', stderr );\n" if ($#_ > 0);
89         }
90     }
91     push @trace_lines, "}\n\n";
92 }
93
94 ### Parse the request definitions
95
96 sub PARSE_REQUESTS()
97 {
98     # states: 0 = header 1 = declarations 2 = inside @REQ 3 = inside @REPLY
99     my $state = 0;
100     my $name = "";
101     my @in_struct = ();
102     my @out_struct = ();
103
104     open(PROTOCOL,"server/protocol.def") or die "Can't open server/protocol.def";
105
106     while (<PROTOCOL>)
107     {
108         my ($type, $var);
109         # strip comments
110         s!/\*.*\*/!!g;
111         # strip white space at end of line
112         s/\s+$//;
113
114         if (/^\@HEADER/)
115         {
116             die "Misplaced \@HEADER" unless $state == 0;
117             $state++;
118             next;
119         }
120
121         # ignore everything while in state 0
122         next if $state == 0;
123
124         if (/^\@REQ\(\s*(\w+)\s*\)/)
125         {
126             $name = $1;
127             die "Misplaced \@REQ" unless $state == 1;
128             # start a new request
129             @in_struct = ();
130             @out_struct = ();
131             print SERVER_PROT "struct ${name}_request\n{\n";
132             print SERVER_PROT "    struct request_header __header;\n";
133             $state++;
134             next;
135         }
136
137         if (/^\@REPLY/)
138         {
139             die "Misplaced \@REPLY" unless $state == 2;
140             print SERVER_PROT "};\n";
141             print SERVER_PROT "struct ${name}_reply\n{\n";
142             print SERVER_PROT "    struct reply_header __header;\n";
143             $state++;
144             next;
145         }
146
147         if (/^\@END/)
148         {
149             die "Misplaced \@END" unless ($state == 2 || $state == 3);
150             print SERVER_PROT "};\n";
151
152             if ($state == 2)  # build dummy reply struct
153             {
154                 print SERVER_PROT "struct ${name}_reply\n{\n";
155                 print SERVER_PROT "    struct reply_header __header;\n";
156                 print SERVER_PROT "};\n";
157             }
158
159             # got a complete request
160             push @requests, $name;
161             DO_DUMP_FUNC( $name, "request", @in_struct);
162             if ($#out_struct >= 0)
163             {
164                 $replies{$name} = 1;
165                 DO_DUMP_FUNC( $name, "reply", @out_struct);
166             }
167             $state = 1;
168             next;
169         }
170
171         if ($state != 1)
172         {
173             # skip empty lines (but keep them in output file)
174             if (/^$/)
175             {
176                 print SERVER_PROT "\n";
177                 next;
178             }
179
180             if (/^\s*VARARG\((\w+),(\w+),(\w+)\)/)
181             {
182                 $var = $1;
183                 $type = "dump_varargs_" . $2 . "( min(cur_size,req->" . $3 . ") )";
184                 s!(VARARG\(.*\)\s*;)!/* $1 */!;
185             }
186             elsif (/^\s*VARARG\((\w+),(\w+)\)/)
187             {
188                 $var = $1;
189                 $type = "dump_varargs_" . $2 . "( cur_size )";
190                 s!(VARARG\(.*\)\s*;)!/* $1 */!;
191             }
192             elsif (/^\s*(\w+\**(\s+\w+\**)*)\s+(\w+);/)
193             {
194                 $type = $1;
195                 $var = $3;
196                 die "Unrecognized type $type" unless defined($formats{$type});
197             }
198             else
199             {
200                 die "Unrecognized syntax $_";
201             }
202             if ($state == 2) { push @in_struct, $type, $var; }
203             if ($state == 3) { push @out_struct, $type, $var; }
204         }
205
206         # Pass it through into the output file
207         print SERVER_PROT $_ . "\n";
208     }
209     close PROTOCOL;
210 }
211
212 ### Retrieve the server protocol version from the existing server_protocol.h file
213
214 sub GET_PROTOCOL_VERSION()
215 {
216     my $protocol = 0;
217     open SERVER_PROT, "include/wine/server_protocol.h" or return 0;
218     while (<SERVER_PROT>)
219     {
220         if (/^\#define SERVER_PROTOCOL_VERSION (\d+)/) { $protocol = $1; last; }
221     }
222     close SERVER_PROT;
223     return $protocol;
224 }
225
226 ### Retrieve the list of status and errors used in the server
227
228 sub GET_ERROR_NAMES()
229 {
230     my %errors = ();
231     foreach my $f (glob "server/*.c")
232     {
233         open FILE, $f or die "Can't open $f";
234         while (<FILE>)
235         {
236             if (/set_error\s*\(\s*STATUS_(\w+)\s*\)/)
237             {
238                 $errors{$1} = "STATUS_$1";
239             }
240             elsif (/set_win32_error\s*\(\s*(\w+)\s*\)/)
241             {
242                 $errors{$1} = "0xc0010000 | $1";
243             }
244         }
245         close FILE;
246     }
247     return %errors;
248 }
249
250 ### Replace the contents of a file between ### make_requests ### marks
251
252 sub REPLACE_IN_FILE($@)
253 {
254     my $name = shift;
255     my @data = @_;
256     my @lines = ();
257     open(FILE,$name) or die "Can't open $name";
258     while (<FILE>)
259     {
260         push @lines, $_;
261         last if /\#\#\# make_requests begin \#\#\#/;
262     }
263     push @lines, "\n", @data;
264     while (<FILE>)
265     {
266         if (/\#\#\# make_requests end \#\#\#/) { push @lines, "\n", $_; last; }
267     }
268     push @lines, <FILE>;
269     open(FILE,">$name") or die "Can't modify $name";
270     print FILE @lines;
271     close(FILE);
272 }
273
274 ### Main
275
276 # Get the server protocol version
277 my $protocol = GET_PROTOCOL_VERSION();
278
279 my %errors = GET_ERROR_NAMES();
280
281 ### Create server_protocol.h and print header
282
283 open SERVER_PROT, ">include/wine/server_protocol.h" or die "Cannot create include/wine/server_protocol.h";
284 print SERVER_PROT "/*\n * Wine server protocol definitions\n *\n";
285 print SERVER_PROT " * This file is automatically generated; DO NO EDIT!\n";
286 print SERVER_PROT " * Edit server/protocol.def instead and re-run tools/make_requests\n";
287 print SERVER_PROT " */\n\n";
288 print SERVER_PROT "#ifndef __WINE_WINE_SERVER_PROTOCOL_H\n";
289 print SERVER_PROT "#define __WINE_WINE_SERVER_PROTOCOL_H\n";
290
291 ### Parse requests to find request/reply structure definitions
292
293 PARSE_REQUESTS();
294
295 ### Build the request list and structures
296
297 print SERVER_PROT "\n\nenum request\n{\n";
298 foreach my $req (@requests) { print SERVER_PROT "    REQ_$req,\n"; }
299 print SERVER_PROT "    REQ_NB_REQUESTS\n};\n\n";
300
301 print SERVER_PROT "union generic_request\n{\n";
302 print SERVER_PROT "    struct request_max_size max_size;\n";
303 print SERVER_PROT "    struct request_header request_header;\n";
304 foreach my $req (@requests) { print SERVER_PROT "    struct ${req}_request ${req}_request;\n"; }
305 print SERVER_PROT "};\n";
306
307 print SERVER_PROT "union generic_reply\n{\n";
308 print SERVER_PROT "    struct request_max_size max_size;\n";
309 print SERVER_PROT "    struct reply_header reply_header;\n";
310 foreach my $req (@requests) { print SERVER_PROT "    struct ${req}_reply ${req}_reply;\n"; }
311 print SERVER_PROT "};\n\n";
312
313 printf SERVER_PROT "#define SERVER_PROTOCOL_VERSION %d\n\n", $protocol + 1;
314 print SERVER_PROT "#endif /* __WINE_WINE_SERVER_PROTOCOL_H */\n";
315 close SERVER_PROT;
316
317 ### Output the dumping function tables
318
319 push @trace_lines, "static const dump_func req_dumpers[REQ_NB_REQUESTS] = {\n";
320 foreach my $req (@requests)
321 {
322     push @trace_lines, "    (dump_func)dump_${req}_request,\n";
323 }
324 push @trace_lines, "};\n\n";
325
326 push @trace_lines, "static const dump_func reply_dumpers[REQ_NB_REQUESTS] = {\n";
327 foreach my $req (@requests)
328 {
329     push @trace_lines, "    (dump_func)", $replies{$req} ? "dump_${req}_reply,\n" : "0,\n";
330 }
331 push @trace_lines, "};\n\n";
332
333 push @trace_lines, "static const char * const req_names[REQ_NB_REQUESTS] = {\n";
334 foreach my $req (@requests)
335 {
336     push @trace_lines, "    \"$req\",\n";
337 }
338 push @trace_lines, "};\n\n";
339
340 push @trace_lines, "static const struct\n{\n";
341 push @trace_lines, "    const char  *name;\n";
342 push @trace_lines, "    unsigned int value;\n";
343 push @trace_lines, "} status_names[] =\n{\n";
344
345 foreach my $err (sort keys %errors)
346 {
347     push @trace_lines, sprintf("    { %-30s %s },\n", "\"$err\",", $errors{$err});
348 }
349 push @trace_lines, "    { NULL, 0 }\n";
350 push @trace_lines, "};\n";
351
352 REPLACE_IN_FILE( "server/trace.c", @trace_lines );
353
354 ### Output the request handlers list
355
356 my @request_lines = ();
357
358 foreach my $req (@requests) { push @request_lines, "DECL_HANDLER($req);\n"; }
359 push @request_lines, "\n#ifdef WANT_REQUEST_HANDLERS\n\n";
360 push @request_lines, "typedef void (*req_handler)( const void *req, void *reply );\n";
361 push @request_lines, "static const req_handler req_handlers[REQ_NB_REQUESTS] =\n{\n";
362 foreach my $req (@requests)
363 {
364     push @request_lines, "    (req_handler)req_$req,\n";
365 }
366 push @request_lines, "};\n#endif  /* WANT_REQUEST_HANDLERS */\n";
367
368 REPLACE_IN_FILE( "server/request.h", @request_lines );