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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 #
22 use strict;
23
24 my %formats =
25 ( # size align format
26 "int" => [ 4, 4, "%d" ],
27 "short int" => [ 2, 2, "%d" ],
28 "char" => [ 1, 1, "%c" ],
29 "unsigned char" => [ 1, 1, "%02x" ],
30 "unsigned short"=> [ 2, 2, "%04x" ],
31 "unsigned int" => [ 4, 4, "%08x" ],
32 "data_size_t" => [ 4, 4, "%u" ],
33 "obj_handle_t" => [ 4, 4, "%04x" ],
34 "atom_t" => [ 4, 4, "%04x" ],
35 "user_handle_t" => [ 4, 4, "%08x" ],
36 "process_id_t" => [ 4, 4, "%04x" ],
37 "thread_id_t" => [ 4, 4, "%04x" ],
38 "client_ptr_t" => [ 8, 8, "&dump_uint64" ],
39 "mod_handle_t" => [ 8, 8, "&dump_uint64" ],
40 "lparam_t" => [ 8, 8, "&dump_uint64" ],
41 "apc_param_t" => [ 8, 8, "&dump_uint64" ],
42 "file_pos_t" => [ 8, 8, "&dump_uint64" ],
43 "mem_size_t" => [ 8, 8, "&dump_uint64" ],
44 "affinity_t" => [ 8, 8, "&dump_uint64" ],
45 "timeout_t" => [ 8, 8, "&dump_timeout" ],
46 "rectangle_t" => [ 16, 4, "&dump_rectangle" ],
47 "char_info_t" => [ 4, 2, "&dump_char_info" ],
48 "apc_call_t" => [ 40, 8, "&dump_apc_call" ],
49 "apc_result_t" => [ 40, 8, "&dump_apc_result" ],
50 "async_data_t" => [ 40, 8, "&dump_async_data" ],
51 "luid_t" => [ 8, 4, "&dump_luid" ],
52 "ioctl_code_t" => [ 4, 4, "&dump_ioctl_code" ],
53 );
54
55 my @requests = ();
56 my %replies = ();
57 my @asserts = ();
58
59 my @trace_lines = ();
60
61 my $max_req_size = 64;
62
63 my $warnings = scalar(@ARGV) && $ARGV[0] eq "-w";
64
65 ### Generate a dumping function
66
67 sub DO_DUMP_FUNC($$@)
68 {
69 my $name = shift;
70 my $req = shift;
71 push @trace_lines, "static void dump_${name}_$req( const struct ${name}_$req *req )\n{\n";
72 while ($#_ >= 0)
73 {
74 my $type = shift;
75 my $var = shift;
76 next if $var =~ /^__pad/;
77 if (defined($formats{$type}))
78 {
79 my $fmt = ${$formats{$type}}[2];
80 if ($fmt =~ /^&(.*)/)
81 {
82 my $func = $1;
83 push @trace_lines, " fprintf( stderr, \" $var=\" );\n";
84 push @trace_lines, " $func( &req->$var );\n";
85 push @trace_lines, " fprintf( stderr, \",\" );\n" if ($#_ > 0);
86 }
87 elsif ($fmt =~ /^(%.*)\s+\((.*)\)/)
88 {
89 my ($format, $cast) = ($1, $2);
90 push @trace_lines, " fprintf( stderr, \" $var=$format";
91 push @trace_lines, "," if ($#_ > 0);
92 push @trace_lines, "\", ($cast)req->$var );\n";
93 }
94 else
95 {
96 push @trace_lines, " fprintf( stderr, \" $var=$fmt";
97 push @trace_lines, "," if ($#_ > 0);
98 push @trace_lines, "\", req->$var );\n";
99 }
100 }
101 else # must be some varargs format
102 {
103 my $func = $type;
104 push @trace_lines, " fprintf( stderr, \" $var=\" );\n";
105 push @trace_lines, " $func;\n";
106 push @trace_lines, " fputc( ',', stderr );\n" if ($#_ > 0);
107 }
108 }
109 push @trace_lines, "}\n\n";
110 }
111
112 ### Parse the request definitions
113
114 sub PARSE_REQUESTS()
115 {
116 # states: 0 = header 1 = declarations 2 = inside @REQ 3 = inside @REPLY
117 my $state = 0;
118 my $offset = 0;
119 my $name = "";
120 my @in_struct = ();
121 my @out_struct = ();
122
123 open(PROTOCOL,"server/protocol.def") or die "Can't open server/protocol.def";
124
125 while (<PROTOCOL>)
126 {
127 my ($type, $var);
128 # strip comments
129 s!/\*.*\*/!!g;
130 # strip white space at end of line
131 s/\s+$//;
132
133 if (/^\@HEADER/)
134 {
135 die "Misplaced \@HEADER" unless $state == 0;
136 $state++;
137 next;
138 }
139
140 # ignore everything while in state 0
141 next if $state == 0;
142
143 if (/^\@REQ\(\s*(\w+)\s*\)/)
144 {
145 $name = $1;
146 die "Misplaced \@REQ" unless $state == 1;
147 # start a new request
148 @in_struct = ();
149 @out_struct = ();
150 $offset = 12;
151 print SERVER_PROT "struct ${name}_request\n{\n";
152 print SERVER_PROT " struct request_header __header;\n";
153 $state++;
154 next;
155 }
156
157 if (/^\@REPLY/)
158 {
159 die "Misplaced \@REPLY" unless $state == 2;
160 print SERVER_PROT "};\n";
161 print SERVER_PROT "struct ${name}_reply\n{\n";
162 print SERVER_PROT " struct reply_header __header;\n";
163 die "request $name too large ($offset)" if ($offset > $max_req_size);
164 $offset = 8;
165 $state++;
166 next;
167 }
168
169 if (/^\@END/)
170 {
171 die "Misplaced \@END" unless ($state == 2 || $state == 3);
172
173 if ($offset & 7) # all requests should be 8-byte aligned
174 {
175 my $count = 8 - ($offset & 7);
176 print SERVER_PROT " char __pad_$offset\[$count\];\n";
177 $offset += $count;
178 }
179 print SERVER_PROT "};\n";
180 if ($state == 2) # build dummy reply struct
181 {
182 die "request $name too large ($offset)" if ($offset > $max_req_size);
183 push @asserts, "C_ASSERT( sizeof(struct ${name}_request) == $offset );\n";
184 print SERVER_PROT "struct ${name}_reply\n{\n";
185 print SERVER_PROT " struct reply_header __header;\n";
186 print SERVER_PROT "};\n";
187 }
188 else
189 {
190 die "reply $name too large ($offset)" if ($offset > $max_req_size);
191 push @asserts, "C_ASSERT( sizeof(struct ${name}_reply) == $offset );\n";
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 my @fmt = @{$formats{$type}};
232 if ($offset & ($fmt[1] - 1))
233 {
234 my $count = $fmt[1] - ($offset & ($fmt[1] - 1));
235 print "protocol.def:$.: warning: $name $offset $type $var needs padding\n" if $warnings;
236 print SERVER_PROT " char __pad_$offset\[$count\];\n";
237 $offset += $count;
238 }
239 if ($state == 2)
240 {
241 push @asserts, "C_ASSERT( FIELD_OFFSET(struct ${name}_request, $var) == $offset );\n";
242 }
243 else
244 {
245 push @asserts, "C_ASSERT( FIELD_OFFSET(struct ${name}_reply, $var) == $offset );\n";
246 }
247 $offset += $fmt[0];
248 }
249 else
250 {
251 die "Unrecognized syntax $_";
252 }
253 if ($state == 2) { push @in_struct, $type, $var; }
254 if ($state == 3) { push @out_struct, $type, $var; }
255 }
256
257 # Pass it through into the output file
258 print SERVER_PROT $_ . "\n";
259 }
260 close PROTOCOL;
261 }
262
263 ### Retrieve the server protocol version from the existing server_protocol.h file
264
265 sub GET_PROTOCOL_VERSION()
266 {
267 my $protocol = 0;
268 open SERVER_PROT, "include/wine/server_protocol.h" or return 0;
269 while (<SERVER_PROT>)
270 {
271 if (/^\#define SERVER_PROTOCOL_VERSION (\d+)/) { $protocol = $1; last; }
272 }
273 close SERVER_PROT;
274 return $protocol;
275 }
276
277 ### Retrieve the list of status and errors used in the server
278
279 sub GET_ERROR_NAMES()
280 {
281 my %errors = ();
282 foreach my $f (glob "server/*.c")
283 {
284 next if $f eq "server/trace.c";
285 open FILE, $f or die "Can't open $f";
286 while (<FILE>)
287 {
288 if (/STATUS_(\w+)/)
289 {
290 $errors{$1} = "STATUS_$1" unless $1 eq "SUCCESS";
291 }
292 elsif (/set_win32_error\s*\(\s*(\w+)\s*\)/)
293 {
294 $errors{$1} = "0xc0010000 | $1";
295 }
296 }
297 close FILE;
298 }
299 return %errors;
300 }
301
302 # update a file if changed
303 sub update_file($)
304 {
305 my $file = shift;
306 my $ret = !(-f $file) || system "cmp $file $file.new >/dev/null";
307 if (!$ret)
308 {
309 unlink "$file.new";
310 }
311 else
312 {
313 rename "$file.new", "$file";
314 print "$file updated\n";
315 }
316 return $ret;
317 }
318
319 # replace some lines in a file between two markers
320 sub replace_in_file($$$@)
321 {
322 my $file = shift;
323 my $start = shift;
324 my $end = shift;
325
326 open NEW_FILE, ">$file.new" or die "cannot create $file.new";
327
328 if (defined($start))
329 {
330 open OLD_FILE, "$file" or die "cannot open $file";
331 while (<OLD_FILE>)
332 {
333 print NEW_FILE $_;
334 last if /$start/;
335 }
336 }
337
338 print NEW_FILE "\n", @_, "\n";
339
340 if (defined($end))
341 {
342 my $skip=1;
343 while (<OLD_FILE>)
344 {
345 $skip = 0 if /$end/;
346 print NEW_FILE $_ unless $skip;
347 }
348 }
349
350 close OLD_FILE if defined($start);
351 close NEW_FILE;
352 return update_file($file);
353 }
354
355 ### Main
356
357 # Get the server protocol version
358 my $protocol = GET_PROTOCOL_VERSION();
359
360 my %errors = GET_ERROR_NAMES();
361
362 ### Create server_protocol.h and print header
363
364 open SERVER_PROT, ">include/wine/server_protocol.h.new" or die "Cannot create include/wine/server_protocol.h.new";
365 print SERVER_PROT "/*\n * Wine server protocol definitions\n *\n";
366 print SERVER_PROT " * This file is automatically generated; DO NO EDIT!\n";
367 print SERVER_PROT " * Edit server/protocol.def instead and re-run tools/make_requests\n";
368 print SERVER_PROT " */\n\n";
369 print SERVER_PROT "#ifndef __WINE_WINE_SERVER_PROTOCOL_H\n";
370 print SERVER_PROT "#define __WINE_WINE_SERVER_PROTOCOL_H\n";
371
372 ### Parse requests to find request/reply structure definitions
373
374 PARSE_REQUESTS();
375
376 ### Build the request list and structures
377
378 print SERVER_PROT "\n\nenum request\n{\n";
379 foreach my $req (@requests) { print SERVER_PROT " REQ_$req,\n"; }
380 print SERVER_PROT " REQ_NB_REQUESTS\n};\n\n";
381
382 print SERVER_PROT "union generic_request\n{\n";
383 print SERVER_PROT " struct request_max_size max_size;\n";
384 print SERVER_PROT " struct request_header request_header;\n";
385 foreach my $req (@requests) { print SERVER_PROT " struct ${req}_request ${req}_request;\n"; }
386 print SERVER_PROT "};\n";
387
388 print SERVER_PROT "union generic_reply\n{\n";
389 print SERVER_PROT " struct request_max_size max_size;\n";
390 print SERVER_PROT " struct reply_header reply_header;\n";
391 foreach my $req (@requests) { print SERVER_PROT " struct ${req}_reply ${req}_reply;\n"; }
392 print SERVER_PROT "};\n\n";
393
394 printf SERVER_PROT "#define SERVER_PROTOCOL_VERSION %d\n\n", $protocol + 1;
395 print SERVER_PROT "#endif /* __WINE_WINE_SERVER_PROTOCOL_H */\n";
396 close SERVER_PROT;
397 update_file( "include/wine/server_protocol.h" );
398
399 ### Output the dumping function tables
400
401 push @trace_lines, "static const dump_func req_dumpers[REQ_NB_REQUESTS] = {\n";
402 foreach my $req (@requests)
403 {
404 push @trace_lines, " (dump_func)dump_${req}_request,\n";
405 }
406 push @trace_lines, "};\n\n";
407
408 push @trace_lines, "static const dump_func reply_dumpers[REQ_NB_REQUESTS] = {\n";
409 foreach my $req (@requests)
410 {
411 push @trace_lines, " ", $replies{$req} ? "(dump_func)dump_${req}_reply,\n" : "NULL,\n";
412 }
413 push @trace_lines, "};\n\n";
414
415 push @trace_lines, "static const char * const req_names[REQ_NB_REQUESTS] = {\n";
416 foreach my $req (@requests)
417 {
418 push @trace_lines, " \"$req\",\n";
419 }
420 push @trace_lines, "};\n\n";
421
422 push @trace_lines, "static const struct\n{\n";
423 push @trace_lines, " const char *name;\n";
424 push @trace_lines, " unsigned int value;\n";
425 push @trace_lines, "} status_names[] =\n{\n";
426
427 foreach my $err (sort keys %errors)
428 {
429 push @trace_lines, sprintf(" { %-30s %s },\n", "\"$err\",", $errors{$err});
430 }
431 push @trace_lines, " { NULL, 0 }\n";
432 push @trace_lines, "};\n";
433
434 replace_in_file( "server/trace.c",
435 "### make_requests begin ###",
436 "### make_requests end ###",
437 @trace_lines );
438
439 ### Output the request handlers list
440
441 my @request_lines = ();
442
443 foreach my $req (@requests) { push @request_lines, "DECL_HANDLER($req);\n"; }
444 push @request_lines, "\n#ifdef WANT_REQUEST_HANDLERS\n\n";
445 push @request_lines, "typedef void (*req_handler)( const void *req, void *reply );\n";
446 push @request_lines, "static const req_handler req_handlers[REQ_NB_REQUESTS] =\n{\n";
447 foreach my $req (@requests)
448 {
449 push @request_lines, " (req_handler)req_$req,\n";
450 }
451 push @request_lines, "};\n\n";
452
453 foreach my $type (sort keys %formats)
454 {
455 my $size = ${$formats{$type}}[0];
456 push @request_lines, "C_ASSERT( sizeof($type) == $size );\n";
457 }
458 push @request_lines, @asserts;
459 push @request_lines, "\n#endif /* WANT_REQUEST_HANDLERS */\n";
460
461 replace_in_file( "server/request.h",
462 "### make_requests begin ###",
463 "### make_requests end ###",
464 @request_lines );
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.