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