tools/make_requests

   1 #! /usr/bin/perl -w
   2 #
   3 # Build the server/trace.c and include/server/request.h files
   4 # from the contents of include/server.h.
   5 #
   6 # Copyright (C) 1998 Alexandre Julliard
   7 #
   8
   9 %formats =
  10 (
  11     "int"          => "%d",
  12     "char"         => "%c",
  13     "char[0]"      => "\\\"%.*s\\\"",
  14     "unsigned int" => "%08x",
  15     "void*"        => "%p",
  16     "time_t"       => "%ld"
  17 );
  18
  19 my @requests = ();
  20 my %replies = ();
  21
  22 open(SERVER,"include/server.h") or die "Can't open include/server.h";
  23 open(TRACE,">server/trace.c") or die "Can't create server/trace.c";
  24 open(REQUESTS,">include/server/request.h") or die "Can't create include/server/request.h";
  25
  26 ### Generate the header
  27
  28 print TRACE <<EOF;
  29 /* File generated automatically by $0; DO NOT EDIT!! */
  30
  31 #include <stdio.h>
  32 #include <sys/types.h>
  33 #include <sys/uio.h>
  34 #include "server.h"
  35 #include "server/thread.h"
  36 EOF
  37
  38 ### Parse server.h to find request/reply structure definitions
  39
  40 while (<SERVER>)
  41 {
  42     if (/^struct +(\w+)_request/) { &DO_REQUEST($1); }
  43     if (/^struct +(\w+)_reply/)   { &DO_REPLY($1); }
  44 }
  45
  46 ### Output the dumping function tables
  47
  48 print TRACE<<EOF;
  49
  50 struct dumper
  51 {
  52     int (*dump_req)( void *data, int len );
  53     void (*dump_reply)( void *data );
  54 };
  55
  56 static const struct dumper dumpers[REQ_NB_REQUESTS] =
  57 {
  58 EOF
  59
  60 foreach $req (@requests)
  61 {
  62     $request = $req . "_request";
  63     $reply = $replies{$req} ? "dump_${req}_reply" : "0";
  64     print TRACE "    { (int(*)(void *,int))dump_$request,\n";
  65     print TRACE "      (void(*)())$reply },\n";
  66 }
  67
  68 print TRACE <<EOF;
  69 };
  70
  71 static const char * const req_names[REQ_NB_REQUESTS] =
  72 {
  73 EOF
  74 foreach $req (@requests)
  75 {
  76     print TRACE "    \"$req\",\n";
  77 }
  78
  79 ### Output the tracing functions
  80
  81 print TRACE <<EOF;
  82 };
  83
  84 void trace_request( enum request req, void *data, int len, int fd )
  85 {
  86     int size;
  87     current->last_req = req;
  88     printf( "%08x: %s(", (unsigned int)current, req_names[req] );
  89     size = dumpers[req].dump_req( data, len );
  90     if ((len -= size) > 0)
  91     {
  92         unsigned char *ptr = (unsigned char *)data + size;
  93         while (len--) printf( ", %02x", *ptr++ );
  94     }
  95     if (fd != -1) printf( " ) fd=%d\\n", fd );
  96     else printf( " )\\n" );
  97 }
  98
  99 void trace_timeout(void)
 100 {
 101     printf( "%08x: *timeout*\\n", (unsigned int)current );
 102 }
 103
 104 void trace_kill( int exit_code )
 105 {
 106     printf( "%08x: *killed* exit_code=%d\\n",
 107             (unsigned int)current, exit_code );
 108 }
 109
 110 void trace_reply( struct thread *thread, int type, int pass_fd,
 111                   struct iovec *vec, int veclen )
 112 {
 113     if (!thread) return;
 114     printf( "%08x: %s() = %d",
 115             (unsigned int)thread, req_names[thread->last_req], type );
 116     if (veclen)
 117     {
 118         printf( " {" );
 119         if (dumpers[thread->last_req].dump_reply)
 120         {
 121             dumpers[thread->last_req].dump_reply( vec->iov_base );
 122             vec++;
 123             veclen--;
 124         }
 125         for (; veclen; veclen--, vec++)
 126         {
 127             unsigned char *ptr = vec->iov_base;
 128             int len = vec->iov_len;
 129             while (len--) printf( ", %02x", *ptr++ );
 130         }
 131         printf( " }" );
 132     }
 133     if (pass_fd != -1) printf( " fd=%d\\n", pass_fd );
 134     else printf( "\\n" );
 135 }
 136 EOF
 137
 138 ### Output the requests list
 139
 140 print REQUESTS <<EOF;
 141 /* File generated automatically by $0; DO NOT EDIT!! */
 142
 143 #ifndef __WINE_SERVER_REQUEST_H
 144 #define __WINE_SERVER_REQUEST_H
 145
 146 enum request
 147 {
 148 EOF
 149
 150 foreach $req (@requests)
 151 {
 152     print REQUESTS "    REQ_\U$req,\n";
 153 }
 154
 155 print REQUESTS <<EOF;
 156     REQ_NB_REQUESTS
 157 };
 158
 159 #ifdef WANT_REQUEST_HANDLERS
 160
 161 #define DECL_HANDLER(name) \\
 162     static void req_##name( struct name##_request *req, void *data, int len, int fd )
 163
 164 EOF
 165
 166 foreach $req (@requests) { print REQUESTS "DECL_HANDLER($req);\n"; }
 167
 168 print REQUESTS <<EOF;
 169
 170 static const struct handler {
 171     void       (*handler)();
 172     unsigned int min_size;
 173 } req_handlers[REQ_NB_REQUESTS] = {
 174 EOF
 175
 176 foreach $req (@requests)
 177 {
 178     print REQUESTS "    { (void(*)())req_$req, sizeof(struct ${req}_request) },\n";
 179 }
 180
 181 print REQUESTS <<EOF;
 182 };
 183 #endif  /* WANT_REQUEST_HANDLERS */
 184
 185 #endif  /* __WINE_SERVER_REQUEST_H */
 186 EOF
 187
 188 ### Handle a request structure definition
 189
 190 sub DO_REQUEST
 191 {
 192     my $name = shift;
 193     my @struct = ();
 194     while (<SERVER>)
 195     {
 196         last if /^};$/;
 197         next if /^{$/;
 198         s!/\*.*\*/!!g;
 199         next if /^\s*$/;
 200         / *(\w+\**( +\w+\**)*) +(\w+)(\[0\])?;/ or die "Unrecognized syntax $_";
 201         my $type = $1 . ($4 || "");
 202         my $var = $3;
 203         die "Unrecognized type $type" unless defined($formats{$type});
 204         push @struct, $type, $var;
 205     }
 206     push @requests, $name;
 207     &DO_DUMP_FUNC( $name . "_request",@struct);
 208 }
 209
 210 ### Handle a reply structure definition
 211
 212 sub DO_REPLY
 213 {
 214     my $name = shift;
 215     my @struct = ();
 216     while (<SERVER>)
 217     {
 218         last if /^};$/;
 219         next if /^{$/;
 220         s!/\*.*\*/!!g;
 221         next if /^\s*$/;
 222         / *(\w+\**( +\w+\**)*) +(\w+);/ or die "Unrecognized syntax $_";
 223         my $type = $1;
 224         my $var = $3;
 225         die "Unrecognized type $type" unless defined($formats{$type});
 226         push @struct, $type, $var;
 227     }
 228     $replies{$name} = 1;
 229     &DO_DUMP_FUNC( $name . "_reply" ,@struct);
 230 }
 231
 232 ### Generate a dumping function
 233
 234 sub DO_DUMP_FUNC
 235 {
 236     my $vararg = 0;
 237     my $name = shift;
 238     print TRACE "\nstatic int dump_$name( struct $name *req, int len )\n{\n";
 239     while ($#_ >= 0)
 240     {
 241         my $type = shift;
 242         my $var = shift;
 243         print TRACE "    printf( \" $var=$formats{$type}";
 244         print TRACE "," if ($#_ > 0);
 245         print TRACE "\", ";
 246         if ($type =~ s/\[0\]$//g)  # vararg type?
 247         {
 248             $vararg = 1;
 249             print TRACE "len - (int)sizeof(*req), ($type *)(req+1) );\n";
 250         }
 251         else
 252         {
 253             print TRACE "req->$var );\n";
 254         }
 255     }
 256     print TRACE "    return ", $vararg ? "len" : "(int)sizeof(*req)", ";\n}\n";
 257 }