lasker-2.2.3/src/parsers/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 =~ /^const (\S*) (.*)/) {
 103                 $type = $1;
 104                 $data = $2;
 105         } elsif ($element =~ /^(\S*) (.*)/) {
 106                 $type = $1;
 107                 $data = $2;
 108         } else {
 109                 die "Can't parse element '$element'";
 110         }
 111
 112         # handle comma separated lists
 113         while ($data =~ /(\S*),[\s]?(.*)/) {
 114                 parse_one($name, $type, $1, $flags);
 115                 $data = $2;
 116         }
 117         parse_one($name, $type, $data, $flags);
 118 }
 119
 120
 121 my($first_struct) = 1;
 122
 123 ####################################################
 124 # parse the elements of one structure
 125 sub parse_elements($$)
 126 {
 127         my($name) = shift;
 128         my($elements) = shift;
 129
 130         if ($first_struct) {
 131                 $first_struct = 0;
 132                 print "Parsing structs: $name";
 133         } else {
 134                 print ", $name";
 135         }
 136
 137         print OFILE "int gen_dump_struct_$name(struct parse_string *, const char *, unsigned);\n";
 138         print OFILE "int gen_parse_struct_$name(char *, const char *);\n";
 139
 140         print OFILE "static const struct parse_struct pinfo_" . $name . "[] = {\n";
 141
 142         while ($elements =~ /^.*?([a-z].*?);\s*?(\S*?)\s*?$(.*)/msi) {
 143                 my($element) = $1;
 144                 my($flags) = $2;
 145                 $elements = $3;
 146                 parse_element($name, $element, $flags);
 147         }
 148
 149         print OFILE "{NULL, 0, 0, 0, 0, NULL, 0, NULL, NULL}};\n";
 150
 151         print OFILE "
 152 int gen_dump_struct_$name(struct parse_string *p, const char *ptr, unsigned indent) {
 153         return gen_dump_struct(pinfo_$name, p, ptr, indent);
 154 }
 155 int gen_parse_struct_$name(char *ptr, const char *str) {
 156         return gen_parse_struct(pinfo_$name, ptr, str);
 157 }
 158
 159 ";
 160 }
 161
 162 my($first_enum) = 1;
 163
 164 ####################################################
 165 # parse out the enum declarations
 166 sub parse_enum_elements($$)
 167 {
 168         my($name) = shift;
 169         my($elements) = shift;
 170
 171         if ($first_enum) {
 172                 $first_enum = 0;
 173                 print "Parsing enums: $name";
 174         } else {
 175                 print ", $name";
 176         }
 177
 178         print OFILE "static const struct enum_struct einfo_" . $name . "[] = {\n";
 179
 180         my(@enums) = split(/,/s, $elements);
 181         for (my($i)=0; $i <= $#enums; $i++) {
 182                 my($enum) = $enums[$i];
 183                 if ($enum =~ /\s*(\w*)/) {
 184                         my($e) = $1;
 185                         print OFILE "{\"$e\", $e},\n";
 186                 }
 187         }
 188
 189         print OFILE "{NULL, 0}};\n";
 190
 191         print OFILE "
 192 int gen_dump_enum_$name(struct parse_string *p, const char *ptr, unsigned indent) {
 193         return gen_dump_enum(einfo_$name, p, ptr, indent);
 194 }
 195
 196 int gen_parse_enum_$name(char *ptr, const char *str) {
 197         return gen_parse_enum(einfo_$name, ptr, str);
 198 }
 199
 200 ";
 201 }
 202
 203 ####################################################
 204 # parse out the enum declarations
 205 sub parse_enums($)
 206 {
 207         my($data) = shift;
 208
 209         while ($data =~ /^GENSTRUCT\s+enum\s+(\w*?)\s*{(.*?)}\s*;(.*)/ms) {
 210                 my($name) = $1;
 211                 my($elements) = $2;
 212                 $data = $3;
 213
 214                 if (!defined($enum_done{$name})) {
 215                         $enum_done{$name} = 1;
 216                         parse_enum_elements($name, $elements);
 217                 }
 218         }
 219
 220         if (! $first_enum) {
 221                 print "\n";
 222         }
 223 }
 224
 225 ####################################################
 226 # parse all the structures
 227 sub parse_structs($)
 228 {
 229         my($data) = shift;
 230
 231         # parse into structures
 232         while ($data =~ /^GENSTRUCT\s+struct\s+(\w+?)\s*{\s*(.*?)\s*}\s*;(.*)/ms) {
 233                 my($name) = $1;
 234                 my($elements) = $2;
 235                 $data = $3;
 236                 if (!defined($struct_done{$name})) {
 237                         $struct_done{$name} = 1;
 238                         parse_elements($name, $elements);
 239                 }
 240         }
 241
 242         if (! $first_struct) {
 243                 print "\n";
 244         } else {
 245                 print "No GENSTRUCT structures found?\n";
 246         }
 247 }
 248
 249
 250 ####################################################
 251 # parse a header file, generating a dumper structure
 252 sub parse_data($)
 253 {
 254         my($data) = shift;
 255
 256         # collapse spaces
 257         $data =~ s/[\t ]+/ /sg;
 258         $data =~ s/\s*\n\s+/\n/sg;
 259         # strip debug lines
 260         $data =~ s/^\#.*?\n//smg;
 261
 262         parse_enums($data);
 263         parse_structs($data);
 264 }
 265
 266
 267 #########################################
 268 # display help text
 269 sub ShowHelp()
 270 {
 271     print "
 272 generator for C structure dumpers
 273 Copyright Andrew Tridgell <genstruct\@tridgell.net>
 274
 275 Sample usage:
 276    genstruct -o output.h gcc -E -O2 -g test.h
 277
 278 Options:
 279     --help                this help page
 280     -o OUTPUT             place output in OUTPUT
 281 ";
 282     exit(0);
 283 }
 284
 285 ########################################
 286 # main program
 287 if ($ARGV[0] ne "-o" || $#ARGV < 2) {
 288         ShowHelp();
 289 }
 290
 291 shift;
 292 my($opt_ofile)=shift;
 293
 294 open(OFILE, ">$opt_ofile") || die "can't open $opt_ofile";
 295
 296 print OFILE "/* This is an automatically generated file - DO NOT EDIT! */\n\n";
 297
 298 parse_data(`@ARGV -DGENSTRUCT=GENSTRUCT`);
 299 exit(0);