src/libs/ec/file_generator.pl

   1 #!/usr/bin/perl
   2 #
   3
   4 ## This file is part of the aMule Project
   5 ##
   6 ## Copyright (c) 2004-2008 Angel Vidal ( kry@amule.org )
   7 ## Copyright (c) 2003-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   8 ##
   9 ## This program is free software; you can redistribute it and/or
  10 ## modify it under the terms of the GNU General Public License
  11 ## as published by the Free Software Foundation; either
  12 ## version 2 of the License, or (at your option) any later version.
  13 ##
  14 ## This program is distributed in the hope that it will be useful,
  15 ## but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 ## GNU General Public License for more details.
  18 ##
  19 ## You should have received a copy of the GNU General Public License
  20 ## along with this program; if not, write to the Free Software
  21 ## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  22
  23 # Gimme a break, it's my second perl app... (Kry)
  24
  25 use File::Copy;
  26 use warnings;
  27 use strict;
  28 use POSIX;
  29
  30 my $exit_with_help;
  31
  32 if ($#ARGV < 1) {
  33         print "You must specify at least the folder and one abstract file.\n";
  34         $exit_with_help = "true";
  35 }
  36
  37 if ($exit_with_help) {
  38         die "Usage: file_generator file.abstract [file2.abstract ...]\n";
  39 }
  40
  41
  42 my $folder = $ARGV[0] . "/";
  43
  44 my $numArgs = $#ARGV;
  45 print "Parsing $numArgs files\n";
  46
  47 foreach my $argnum (1 .. $#ARGV) {
  48         generate_files($folder, $ARGV[$argnum]);
  49 }
  50
  51
  52 sub generate_files {
  53
  54         my $folder = $_[0];
  55         my $input_file = $_[1];
  56
  57         open(INFO, $folder . $input_file) or die "Cannot open input file " . $input_file . " for reading: $!";          # Open the file
  58
  59         my $line="no";
  60         while ($line !~ /^\[Section Definition\]$/) {
  61                 $line = <INFO>;
  62                 if (!($line)) {
  63                         die $input_file . " seems not to have a Section Definition\n";
  64                 }
  65                 chop $line;
  66         }
  67
  68         #We're at the start of the Section Definition.
  69         # Read the Definition Section.
  70
  71         my $filename = "";
  72
  73         my $nameline = <INFO>;
  74         if ($nameline =~ /^FileName\s+(.+)$/) {
  75                 $filename = $1;
  76         } else {
  77                 die "Section Definition must start with FileName item.";
  78         }
  79
  80         my $filecontent = "";
  81
  82         my $contentline = <INFO>;
  83         if ($contentline =~ /^FileContent\s+(.+)$/) {
  84                 $filecontent = $1;
  85         } else {
  86                 die "Section Definition must have a FileContent after the FileName item.";
  87         }
  88
  89         #Skip the rest of the section, allow for extensions later.
  90
  91         $line = "";
  92         while ($line && ($line !~ /^\[\/Section\]$/)) {
  93                 $line = <INFO>;
  94         }
  95
  96
  97         print "FileName: " . $filename . "\n";
  98         print "FileContent: " . $filecontent . "\n";
  99
 100         #Open language output files
 101         open(CPPFILE," > " . $folder . "cpp/$filename" . ".h");
 102         #Open language output files
 103         open(JAVAFILE," > " . $folder . "java/$filename" . ".java");
 104
 105         open(CDASHFILE, ">${folder}/c#/${filename}.cs");
 106
 107         # Print license on top.
 108         write_license_header($folder, *CPPFILE, "// ", "", $filecontent);
 109         write_license_header($folder, *CDASHFILE, "// ", "", $filecontent);
 110         write_license_header($folder, *JAVAFILE, "// ", "", $filecontent);
 111         #Example for a language that needs start/end:
 112         #write_license_header($folder, *CFILE, "/* ", " */", $filecontent);
 113
 114         #Add top guards for each language
 115         write_cpp_top_guard(*CPPFILE, $filename);
 116         write_cdash_top_guard(*CDASHFILE);
 117         # JAVA doesn't need guards, but needs file type declaration
 118         print JAVAFILE "public interface " . $filename . " {\n\n";
 119         ##Add other language guards
 120
 121
 122         read_content(*INFO, *CPPFILE, *JAVAFILE, *CDASHFILE);
 123
 124
 125         #Add bottom guards for each language
 126         write_cpp_bottom_guard(*CPPFILE, $filename);
 127         write_cdash_bottom_guard(*CDASHFILE);
 128         # JAVA doesn't need guards, but we have to close the interface
 129         print JAVAFILE "}\n";
 130         ##Add other language guards
 131
 132
 133         # Close language files
 134         close(CPPFILE);
 135         close(JAVAFILE);
 136
 137         print "All info parsed\n";
 138
 139         close(INFO);
 140
 141 }
 142
 143 ################ Generic Subroutines #####################
 144
 145 sub read_content {
 146         local (*INFO) = $_[0];
 147         local (*CPPFILE) = $_[1];
 148         local (*JAVAFILE) = $_[2];
 149         local (*CDASHFILE) = $_[3];
 150
 151         my $stop = "";
 152
 153         while (!($stop)) {
 154                 my $line="no";
 155
 156                 #Skip till Content
 157                 while (!(eof(INFO)) && $line !~ /^\[Section Content\]$/) {
 158                         $line = <INFO>;
 159                         chop $line;
 160                 }
 161
 162                 if ($line =~ /^\[Section Content\]$/) {
 163                         print "Reading content section...\n";
 164                         read_content_section(*INFO, *CPPFILE, *JAVAFILE, *CDASHFILE);
 165                         print CPPFILE "\n";
 166                         print JAVAFILE "\n";
 167                 } else {
 168                         print "No more content sections\n";
 169                         $stop = "yes";
 170                 }
 171         }
 172 }
 173
 174 sub read_content_section {
 175
 176         local (*INFO) = $_[0];
 177         local (*CPPOUTPUT) = $_[1];
 178         local (*JAVAOUTPUT) = $_[2];
 179         local (*CDASHFILE) = $_[3];
 180
 181         my $line = <INFO>;
 182         my $datatype = "";
 183         if ($line =~ /^Type\s+(.+)$/) {
 184                 $datatype = $1;
 185                 print "\tDatatype: " . $datatype . "\n";
 186         } else {
 187                 die "Content section has a non-typed data stream\n";
 188         }
 189
 190         if ($datatype eq "Define") {
 191                 read_define_content(*INFO, *CPPOUTPUT, *JAVAOUTPUT, *CDASHFILE);
 192         } elsif ($datatype eq "Enum") {
 193                 read_enum_content(*INFO, *CPPOUTPUT, *JAVAOUTPUT, *CDASHFILE);
 194         } elsif ($datatype eq "TypeDef") {
 195                 read_typedef_content(*INFO, *CPPOUTPUT, *JAVAOUTPUT, *CDASHFILE);
 196         } else {
 197                 die "Unknown type on content section\n";
 198         }
 199
 200 }
 201
 202 sub read_define_content {
 203         local (*INFO) = $_[0];
 204         local (*CPPOUTPUT) = $_[1];
 205         local (*JAVAOUTPUT) = $_[2];
 206         local (*CDASHFILE) = $_[3];
 207
 208         my $line = <INFO>;
 209         while (!(eof) && ($line !~ /^\[\/Section\]$/)) {
 210                 if ($line !~ /^(#.*|\s*)$/) {
 211                         if ($line =~ /^(.+)\s+(.+)$/) {
 212                                 write_cpp_define_line(*CPPOUTPUT, $1, $2);
 213                                 write_java_define_line(*JAVAOUTPUT, $1, $2);
 214                                 write_cdash_define_line(*CDASHFILE, $1, $2);
 215                         } else {
 216                                 die "Malformed content section define line\n";
 217                         }
 218                 }
 219                 $line = <INFO>;
 220         }
 221 }
 222
 223 sub read_typedef_content {
 224
 225         local (*INFO) = $_[0];
 226         local (*CPPOUTPUT) = $_[1];
 227         local (*JAVAOUTPUT) = $_[2];
 228
 229         my $line = <INFO>;
 230         while (!(eof) && ($line !~ /^\[\/Section\]$/)) {
 231                 if ($line !~ /^(#.*|\s*)$/) {
 232                         if ($line =~ /^(.+)\s+(.+)$/) {
 233                                 write_cpp_typedef_line(*CPPOUTPUT, $1, $2);
 234                                 # Java doesn't support typedefs, ignore it.
 235                                 #write_java_typedef_line(*JAVAOUTPUT, $1, $2);
 236                                 # c# doesn't support typedefs either (AFAIK)
 237                         } else {
 238                                 die "Malformed content section typedef line\n";
 239                         }
 240                 }
 241                 $line = <INFO>;
 242         }
 243 }
 244
 245 sub read_enum_content {
 246
 247         local (*INFO) = $_[0];
 248         local (*CPPOUTPUT) = $_[1];
 249         local (*JAVAOUTPUT) = $_[2];
 250         local (*CDASHFILE) = $_[3];
 251
 252         my $line = <INFO>;
 253         my $dataname = "";
 254         if ($line =~ /^Name\s+(.+)$/) {
 255                 $dataname = $1;
 256                 print "\tDataname: " . $dataname . "\n";
 257         } else {
 258                 die "Content section has a non-named data stream\n";
 259         }
 260
 261         $line = <INFO>;
 262         my $datatype = "";
 263         if ($line =~ /^DataType\s+(.+)$/) {
 264                 $datatype = $1;
 265                 print "\tDataType: " . $datatype . "\n";
 266         } else {
 267                 die "Content section has a enum stream with no data type\n";
 268         }
 269
 270         my $first = "yes";
 271         $line = <INFO>;
 272         while (!(eof) && ($line !~ /^\[\/Section\]$/)) {
 273                 if ($line !~ /^(#.*|\s*)$/) {
 274                         if ($line =~ /^(.+)\s+(.+)$/) {
 275                                 my $firstoperand = $1;
 276                                 my $secondoperand = $2;
 277
 278                                 if ($first) {
 279                                         write_cpp_enum_start(*CPPOUTPUT, $dataname);
 280                                         write_cdash_enum_start(*CDASHFILE, $dataname);
 281                                 }
 282
 283                                 write_cpp_enum_line(*CPPOUTPUT, $firstoperand, $secondoperand, $first);
 284                                 write_java_define_line(*JAVAOUTPUT, $firstoperand, $secondoperand, $datatype);
 285                                 write_cdash_enum_line(*CDASHFILE, $firstoperand, $secondoperand, $first);
 286
 287                                 if ($first) {
 288                                         $first = "";
 289                                 }
 290                         } else {
 291                                 die "Malformed content section enum line\n";
 292                         }
 293                 }
 294                 $line = <INFO>;
 295         }
 296
 297         write_cpp_enum_end(*CPPOUTPUT);
 298         write_cdash_enum_end(*CDASHFILE);
 299
 300 }
 301
 302 # Takes a file handle, and the comment start/end character for that language
 303 sub write_license_header {
 304
 305         my $folder = $_[0];
 306         local (*OUTPUT) = $_[1];
 307
 308         open(LICENSE, $folder . "abstracts/License.abstract") or die "Cannot open license file";
 309
 310         my $line = <LICENSE>;
 311         while (!(eof)) {
 312                 printf OUTPUT $_[2] . $line . $_[3];
 313                 $line = <LICENSE>;
 314         }
 315
 316         print OUTPUT "\n";
 317
 318         print OUTPUT $_[2] . "Purpose:" . $_[3] . "\n" . $_[2] . $_[4] . $_[3] . "\n\n";
 319
 320         close(LICENSE);
 321 }
 322
 323 ################ C# Specific Subroutines #####################
 324
 325 sub write_cdash_top_guard {
 326         local (*OUTPUT) = $_[0];
 327         print OUTPUT "namespace amule.net\n{\n";
 328 }
 329
 330 sub write_cdash_bottom_guard {
 331         local (*OUTPUT) = $_[0];
 332         print OUTPUT "}\n";
 333 }
 334
 335 sub write_cdash_enum_start {
 336
 337         local (*OUTPUT) = $_[0];
 338
 339         print OUTPUT "public enum " . $_[1] . " {\n";
 340 }
 341
 342 sub write_cdash_enum_end {
 343
 344         local (*OUTPUT) = $_[0];
 345
 346         print OUTPUT "\n};\n"
 347 }
 348
 349
 350 sub write_cdash_enum_line {
 351         local (*OUTPUT) = $_[0];
 352
 353         if ($_[3] !~ "yes") {
 354                 print OUTPUT ",\n"
 355         }
 356
 357         # looks like c# can't handle such values as enums
 358         if ( not (POSIX::strtod($_[2]) & 0x8000000) ) {
 359                 print OUTPUT "\t" . $_[1] . " = " . $_[2];
 360         }
 361 }
 362
 363 sub write_cdash_define_line {
 364         local (*OUTPUT) = $_[0];
 365
 366         die "ERROR: c# have no 'define' directive $_[1] $_[2]"
 367 }
 368
 369 ################ CPP Specific Subroutines #####################
 370
 371 sub write_cpp_top_guard {
 372
 373         local (*OUTPUT) = $_[0];
 374
 375         my $guardname = uc($_[1]);
 376
 377         print OUTPUT "#ifndef __" . $guardname . "_H__\n";
 378         print OUTPUT "#define __" . $guardname . "_H__\n\n";
 379 }
 380
 381 sub write_cpp_bottom_guard {
 382
 383         local (*OUTPUT) = $_[0];
 384
 385         my $guardname = uc($_[1]);
 386
 387         print OUTPUT "#endif // __" . $guardname . "_H__\n";
 388
 389 }
 390
 391 sub write_cpp_enum_start {
 392
 393         local (*OUTPUT) = $_[0];
 394
 395         print OUTPUT "enum " . $_[1] . " {\n";
 396 }
 397
 398 sub write_cpp_enum_end {
 399
 400         local (*OUTPUT) = $_[0];
 401
 402         print OUTPUT "\n};\n"
 403 }
 404
 405
 406 sub write_cpp_enum_line {
 407
 408         local (*OUTPUT) = $_[0];
 409
 410         if ($_[3] !~ "yes") {
 411                 print OUTPUT ",\n"
 412         }
 413
 414         print OUTPUT "\t" . $_[1] . " = " . $_[2];
 415 }
 416
 417 sub write_cpp_define_line {
 418
 419         local (*OUTPUT) = $_[0];
 420
 421         print OUTPUT "#define " . $_[1] . " " . $_[2] . "\n";
 422
 423 }
 424
 425 sub write_cpp_typedef_line {
 426
 427         local (*OUTPUT) = $_[0];
 428
 429         my $translated_type;
 430
 431         my $preamble = "";
 432
 433         my $datatype = $_[2];
 434
 435         if ($datatype) {
 436                 if ($datatype =~ /^u?int(8|16|32|64)$/) {
 437                         $translated_type = $datatype . "_t";
 438                 } elsif ($datatype eq "string") {
 439                         $translated_type = "std::string"
 440                 } else {
 441                         $preamble = "// ";
 442                         $translated_type = $datatype;
 443                 }
 444         } else {
 445                 die "No data type on abstract";
 446         }
 447
 448         print OUTPUT $preamble . "typedef " . $translated_type . " " . $_[1] . ";\n";
 449
 450 }
 451
 452 ################ JAVA Specific Subroutines #####################
 453
 454
 455 sub write_java_define_line {
 456
 457         local (*OUTPUT) = $_[0];
 458
 459         my $datatype = "int";
 460         my $first = $_[1];
 461         my $second = $_[2];
 462
 463         if ($_[3]) {
 464                 if ($_[3] =~ /int8/) { $datatype = "byte"; }
 465                 elsif ($_[3] =~ /(uint8|int16)/) { $datatype = "short"; }
 466                 elsif ($_[3] =~  /(uint16|int32)/) { $datatype = "int"; }
 467                 elsif ($_[3] =~ /(uint32|int64)/) { $datatype = "long"; }
 468                 else { die "Unknown data type on abstract: " . $_[3]; }
 469         } else {
 470                 if ($second =~ /^\".*\"$/) {
 471                         $datatype = "String";
 472                 }
 473         }
 474
 475         print OUTPUT "public final static " . $datatype . " " . $first . " = " . $second . ";\n";
 476 }
 477
 478 sub write_java_typedef_line {
 479
 480         die "Typedef not supported on java";
 481
 482 }