source4/script/genstruct.pl

   1 #!/usr/bin/perl -w
   2 # a simple system for generating C parse info
   3 # this can be used to write generic C structer load/save routines
   4 # Copyright 2002 Andrew Tridgell <genstruct@tridgell.net>
   5 # released under the GNU General Public License v2 or later
   6
   7 use strict;
   8
   9 my(%enum_done) = ();
  10 my(%struct_done) = ();
  11
  12 ###################################################
  13 # general handler
  14 sub handle_general($$$$$$$$)
  15 {
  16         my($name) = shift;
  17         my($ptr_count) = shift;
  18         my($size) = shift;
  19         my($element) = shift;
  20         my($flags) = shift;
  21         my($dump_fn) = shift;
  22         my($parse_fn) = shift;
  23         my($tflags) = shift;
  24         my($array_len) = 0;
  25         my($dynamic_len) = "NULL";
  26
  27         # handle arrays, currently treat multidimensional arrays as 1 dimensional
  28         while ($element =~ /(.*)\[(.*?)\]$/) {
  29                 $element = $1;
  30                 if ($array_len == 0) {
  31                         $array_len = $2;
  32                 } else {
  33                         $array_len = "$2 * $array_len";
  34                 }
  35         }
  36
  37         if ($flags =~ /_LEN\((\w*?)\)/) {
  38                 $dynamic_len = "\"$1\"";
  39         }
  40
  41         if ($flags =~ /_NULLTERM/) {
  42                 $tflags = "FLAG_NULLTERM";
  43         }
  44
  45         print OFILE "{\"$element\", $ptr_count, $size, offsetof(struct $name, $element), $array_len, $dynamic_len, $tflags, $dump_fn, $parse_fn},\n";
  46 }
  47
  48
  49 ####################################################
  50 # parse one element
  51 sub parse_one($$$$)
  52 {
  53         my($name) = shift;
  54         my($type) = shift;
  55         my($element) = shift;
  56         my($flags) = shift;
  57         my($ptr_count) = 0;
  58         my($size) = "sizeof($type)";
  59         my($tflags) = "0";
  60
  61         # enums get the FLAG_ALWAYS flag
  62         if ($type =~ /^enum /) {
  63                 $tflags = "FLAG_ALWAYS";
  64         }
  65
  66
  67         # make the pointer part of the base type
  68         while ($element =~ /^\*(.*)/) {
  69                 $ptr_count++;
  70                 $element = $1;
  71         }
  72
  73         # convert spaces to _
  74         $type =~ s/ /_/g;
  75
  76         my($dump_fn) = "gen_dump_$type";
  77         my($parse_fn) = "gen_parse_$type";
  78
  79         handle_general($name, $ptr_count, $size, $element, $flags, $dump_fn, $parse_fn, $tflags);
  80 }
  81
  82 ####################################################
  83 # parse one element
  84 sub parse_element($$$)
  85 {
  86         my($name) = shift;
  87         my($element) = shift;
  88         my($flags) = shift;
  89         my($type);
  90         my($data);
  91
  92         # pull the base type
  93         if ($element =~ /^struct (\S*) (.*)/) {
  94                 $type = "struct $1";
  95                 $data = $2;
  96         } elsif ($element =~ /^enum (\S*) (.*)/) {
  97                 $type = "enum $1";
  98                 $data = $2;
  99         } elsif ($element =~ /^unsigned (\S*) (.*)/) {
 100                 $type = "unsigned $1";
 101                 $data = $2;
 102         } elsif ($element =~ /^(\S*) (.*)/) {
 103                 $type = $1;
 104                 $data = $2;
 105         } else {
 106                 die "Can't parse element '$element'";
 107         }
 108
 109         # handle comma separated lists
 110         while ($data =~ /(\S*),[\s]?(.*)/) {
 111                 parse_one($name, $type, $1, $flags);
 112                 $data = $2;
 113         }
 114         parse_one($name, $type, $data, $flags);
 115 }
 116
 117
 118 my($first_struct) = 1;
 119
 120 ####################################################
 121 # parse the elements of one structure
 122 sub parse_elements($$)
 123 {
 124         my($name) = shift;
 125         my($elements) = shift;
 126
 127         if ($first_struct) {
 128                 $first_struct = 0;
 129                 print "Parsing structs: $name";
 130         } else {
 131                 print ", $name";
 132         }
 133
 134         print OFILE "int gen_dump_struct_$name(struct parse_string *, const char *, unsigned);\n";
 135         print OFILE "int gen_parse_struct_$name(char *, const char *);\n";
 136
 137         print OFILE "static const struct parse_struct pinfo_" . $name . "[] = {\n";
 138
 139         while ($elements =~ /^.*?([a-z].*?);\s*?(\S*?)\s*?\$(.*)/msi) {
 140                 my($element) = $1;
 141                 my($flags) = $2;
 142                 $elements = $3;
 143                 parse_element($name, $element, $flags);
 144         }
 145
 146         print OFILE "{NULL, 0, 0, 0, 0, NULL, 0, NULL, NULL}};\n";
 147
 148         print OFILE "
 149 int gen_dump_struct_$name(struct parse_string *p, const char *ptr, unsigned indent) {
 150         return gen_dump_struct(pinfo_$name, p, ptr, indent);
 151 }
 152 int gen_parse_struct_$name(char *ptr, const char *str) {
 153         return gen_parse_struct(pinfo_$name, ptr, str);
 154 }
 155
 156 ";
 157 }
 158
 159 my($first_enum) = 1;
 160
 161 ####################################################
 162 # parse out the enum declarations
 163 sub parse_enum_elements($$)
 164 {
 165         my($name) = shift;
 166         my($elements) = shift;
 167
 168         if ($first_enum) {
 169                 $first_enum = 0;
 170                 print "Parsing enums: $name";
 171         } else {
 172                 print ", $name";
 173         }
 174
 175         print OFILE "static const struct enum_struct einfo_" . $name . "[] = {\n";
 176
 177         my(@enums) = split(/,/s, $elements);
 178         for (my($i)=0; $i <= $#{@enums}; $i++) {
 179                 my($enum) = $enums[$i];
 180                 if ($enum =~ /\s*(\w*)/) {
 181                         my($e) = $1;
 182                         print OFILE "{\"$e\", $e},\n";
 183                 }
 184         }
 185
 186         print OFILE "{NULL, 0}};\n";
 187
 188         print OFILE "
 189 int gen_dump_enum_$name(struct parse_string *p, const char *ptr, unsigned indent) {
 190         return gen_dump_enum(einfo_$name, p, ptr, indent);
 191 }
 192
 193 int gen_parse_enum_$name(char *ptr, const char *str) {
 194         return gen_parse_enum(einfo_$name, ptr, str);
 195 }
 196
 197 ";
 198 }
 199
 200 ####################################################
 201 # parse out the enum declarations
 202 sub parse_enums($)
 203 {
 204         my($data) = shift;
 205
 206         while ($data =~ /^GENSTRUCT\s+enum\s+(\w*?)\s*{(.*?)}\s*;(.*)/ms) {
 207                 my($name) = $1;
 208                 my($elements) = $2;
 209                 $data = $3;
 210
 211                 if (!defined($enum_done{$name})) {
 212                         $enum_done{$name} = 1;
 213                         parse_enum_elements($name, $elements);
 214                 }
 215         }
 216
 217         if (! $first_enum) {
 218                 print "\n";
 219         }
 220 }
 221
 222 ####################################################
 223 # parse all the structures
 224 sub parse_structs($)
 225 {
 226         my($data) = shift;
 227
 228         # parse into structures
 229         while ($data =~ /^GENSTRUCT\s+struct\s+(\w+?)\s*{\s*(.*?)\s*}\s*;(.*)/ms) {
 230                 my($name) = $1;
 231                 my($elements) = $2;
 232                 $data = $3;
 233                 if (!defined($struct_done{$name})) {
 234                         $struct_done{$name} = 1;
 235                         parse_elements($name, $elements);
 236                 }
 237         }
 238
 239         if (! $first_struct) {
 240                 print "\n";
 241         } else {
 242                 print "No GENSTRUCT structures found?\n";
 243         }
 244 }
 245
 246
 247 ####################################################
 248 # parse a header file, generating a dumper structure
 249 sub parse_data($)
 250 {
 251         my($data) = shift;
 252
 253         # collapse spaces
 254         $data =~ s/[\t ]+/ /sg;
 255         $data =~ s/\s*\n\s+/\n/sg;
 256         # strip debug lines
 257         $data =~ s/^\#.*?\n//smg;
 258
 259         parse_enums($data);
 260         parse_structs($data);
 261 }
 262
 263
 264 #########################################
 265 # display help text
 266 sub ShowHelp()
 267 {
 268     print "
 269 generator for C structure dumpers
 270 Copyright Andrew Tridgell <genstruct\@tridgell.net>
 271
 272 Sample usage:
 273    genstruct -o output.h gcc -E -O2 -g test.h
 274
 275 Options:
 276     --help                this help page
 277     -o OUTPUT             place output in OUTPUT
 278 ";
 279     exit(0);
 280 }
 281
 282 ########################################
 283 # main program
 284 if ($ARGV[0] ne "-o" || $#ARGV < 2) {
 285         ShowHelp();
 286 }
 287
 288 shift;
 289 my($opt_ofile)=shift;
 290
 291 print "creating $opt_ofile\n";
 292
 293 open(OFILE, ">$opt_ofile") || die "can't open $opt_ofile";
 294
 295 print OFILE "/* This is an automatically generated file - DO NOT EDIT! */\n\n";
 296
 297 parse_data(`@ARGV -DGENSTRUCT=GENSTRUCT`);
 298 exit(0);