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