infobase/examples/legacy/template.pl

   1 #!/usr/bin/perl
   2
   3 ###############################################################################
   4 #                                                                             #
   5 #  Name   : template                                                          #
   6 #  Author : Chris Koeritz                                                     #
   7 #  Rights : Copyright (C) 1996-$now by Author                                 #
   8 #                                                                             #
   9 #  Purpose:                                                                   #
  10 #                                                                             #
  11 #    Attempts to pre-instantiate C++ templates to work-around C++ compilers   #
  12 #  that don't support templates (a rare breed, these days).                   #
  13 #                                                                             #
  14 ###############################################################################
  15 #  This program is free software; you can redistribute it and/or modify it    #
  16 #  under the terms of the GNU General Public License as published by the Free #
  17 #  Software Foundation; either version 2 of the License or (at your option)   #
  18 #  any later version.  See: "http://www.gruntose.com/Info/GNU/GPL.html" for a #
  19 #  version of the License.  Please send any updates to "fred@gruntose.com".   #
  20 ###############################################################################
  21
  22 # this was a majestic abortive attempt to create a template instantiator for
  23 # compilers that do not possess templates, but which do support some subset
  24 # of C++.  This was necessary at the time, due to our firmware compiler's
  25 # limitations.  This processor never totally worked, although it did produce
  26 # some interesting compilable code.  Might be useful as a demo or maybe just
  27 # as a warning to avoid brain-damaged C++ compilers.
  28
  29 # to do:
  30 #   maintain statistics about placement in file for error resolution.
  31
  32 # limitations so far:
  33 #
  34 # the word "template" must be the first word on the line.
  35 #
  36 # the type to instantiate must be one word (like charstar, not char *).
  37 #
  38 # templates must follow the form templateName<templateType> without
  39 #   any spaces between the angle brackets.
  40
  41 # flag to enable debugging print outs.
  42 $DEBUG_TEMPLATIZER = 1;
  43 #$DEBUG_TEMPLATIZER = 0;
  44
  45 # array to store instance types to convert to
  46 @instance_type_buffer = ();
  47 # flag for checking read from file option
  48 $f_option = 0;
  49 $d_option = 0;
  50
  51 if ($#ARGV < 1) {
  52   die("
  53     The template instantiater supports an optional directory path as the first
  54     parameter (preceded by a -d with no spaces in between the d and the
  55     directory name) in which to store the generated templates, and then
  56     requires the instantiation type as the next argument (or a file
  57     specification preceded by -f), and a list of files as the last
  58     arguments.
  59     The files will be scanned for templates and those templates will be
  60     instantiated in the type(s) specified.
  61     Examples:
  62        perl template.pl char istring.h torpedo.h
  63        perl template.pl -f instance.txt matrix.h
  64        perl template.pl -d. -f instance.txt function.h data_src.h
  65        perl template.pl -dfirm_src\library\basis -f instance.txt amorph.h\n");
  66 }
  67
  68 # Check directory option
  69 if (grep(/^\s*-d/, @ARGV)) {
  70    $d_option = 1;
  71    $d_dir = @ARGV[0];
  72 #   print $d_dir, "\n";
  73    shift;
  74 }
  75
  76
  77 # Check to see if user used a file to specify instantiation types
  78 if (grep(/^\s*-f/, @ARGV)) {
  79    $f_option = 1;
  80    shift;
  81    $types_file = @ARGV[0];
  82
  83 # Open instantiation type file to read from
  84    open(TYPES_FILE, "<$types_file")
  85      || die("couldn't open file $types_file for reading");
  86
  87 # Read in all the different types to instantiate
  88 # Create instance_type list
  89    @tp = <TYPES_FILE>;
  90    while (@tp) {
  91       local($line) = @tp;
  92       chop $line;
  93       push(@instance_type_buffer, $line);
  94       shift @tp;
  95    }
  96    shift @ARGV;
  97    &instantiate_templates(@ARGV);
  98    exit;
  99 }
 100
 101 &instantiate_templates(@ARGV);
 102 exit;
 103
 104 #
 105 # driver of the instantiation process.
 106 #
 107 sub instantiate_templates {
 108   if (!$f_option) {
 109   # grab the user's desired instance type.
 110   $instance_type = @_[0];
 111   push(@instance_type_buffer, $instance_type);
 112   print "Instantiation type is \"$instance_type\".\n";
 113   # jump over the instance type to look at the filenames.
 114   shift;
 115   }
 116
 117   local($i) = 0;
 118   foreach $filename (@_) {
 119     open(INPUT_FILE, "<$filename")
 120       || die("couldn't open file $filename for reading");
 121     # create an output name for the instance.
 122     $out_filename = &make_output_name($filename);
 123     if ($DEBUG_TEMPLATIZER) {
 124 #      print "out file is ", $out_filename, "\n";
 125     }
 126     local($index) = $i + 1;
 127     print "Instantiating file[$index] as $out_filename.\n";
 128     # now try opening our output file.
 129     open(OUTPUT_FILE, ">$out_filename")
 130       || die("couldn't open file $filename for writing");
 131     # grab the current file into an array.
 132
 133     @file_array = <INPUT_FILE>;
 134     @start_template = @file_array;
 135     @stop_template = @file_array;
 136     # process the file's contents as a manipulable array.
 137     while (@file_array) {
 138       local($line) = shift @file_array;
 139       if (grep(/^\s*template/, $line)) {
 140         @start_template = @file_array;
 141
 142         # iterate through all the instance types for each template
 143         foreach $instance_type (@instance_type_buffer) {
 144            @file_array = @start_template;
 145            &snag_place_holder($line);
 146            &snag_object_name;
 147            &absorb_until_matched_block;
 148            &replace_place_holder;
 149            &dump_the_buffer;
 150            print OUTPUT_FILE "\n";
 151         }
 152       } elsif (grep(/\w+<\w+>/, $line)) {
 153         local(@pieces) = split(/\s/, $line);
 154         foreach $piece (@pieces) {
 155           local($prefix) = "";
 156           # special case for separating function name from templated first
 157           # parameter to it.
 158           if (grep(/\(\w+</, $piece)) {
 159             local(@chop_paren) = split(/\(/, $piece, 2);
 160             $prefix = $chop_paren[0].'(';
 161             $piece = $chop_paren[1];
 162           }
 163           if (grep(/\w+<\w+>/, $piece)) { $piece = &special_mangle($piece); }
 164           print OUTPUT_FILE "$prefix$piece ";
 165         }
 166         print OUTPUT_FILE "\n";
 167       } else {
 168           print OUTPUT_FILE $line;
 169       }
 170     }
 171     $i++;
 172   }
 173 }
 174
 175 #
 176 # generates an output name from the filename to be translated.
 177 #
 178 sub make_output_name {
 179   local($out_filename) = @_[0];
 180   local($d_dir_temp) = $d_dir;
 181 #  print "OUTFILE NAME: ",$out_filename,"\n";
 182   # break down the filename at the slashes.
 183   local(@split_filename) = split(/[\\\/]/, $out_filename);
 184   # take the basename of the list of names.
 185   $out_filename = $split_filename[$#split_filename];
 186   local($hold_filename) = $out_filename;
 187   if (grep(!/\.cpp$/i, $out_filename) && grep(!/\.h$/i, $out_filename)
 188       && grep(!/\.c$/i, $out_filename) && grep(!/\.h$/i, $out_filename) ) {
 189     die("filename @_[0] not recognized as a C++ code file.");
 190   }
 191   # makes an instance of the file in a directory named after the instance type
 192   # that is located under the current directory.
 193
 194   $d_dir_temp = join('/',$d_dir, $hold_filename);
 195   if ($d_option) {
 196      $d_dir_temp =~ s/-d//i;
 197      @split_filename = split(/[\\\/]/, $d_dir_temp);
 198 #     exit;
 199   }
 200
 201 # try to create dir using the deepest dir given in filename input
 202
 203     local($y) = 0;
 204     foreach (@split_filename) { $y++; }
 205
 206     local($x) = 0;
 207     local($ret) = 0;
 208     local($dirs) = 0;
 209
 210     if ($y >= 2) {
 211       foreach (@split_filename) {
 212        if ((($x > 0) && ($x < $y-1)) || (($d_option) && ($x < $y-1))) {
 213          if (!$dirs) { $dirs = @split_filename[$x]; }
 214          else { $dirs = $dirs."/".@split_filename[$x]; }
 215 #         print "Creating... ",$dirs,"\n";
 216          $ret = mkdir($dirs, 0777);
 217          if (!ret) { die("a directory named $instance_dir could not be made."); }
 218        }
 219        $x++;
 220       }
 221       $out_filename = $dirs."/".$hold_filename;
 222     }
 223     else { $out_filename = "template/".$hold_filename;
 224          local($instance_dir) = "template";
 225          $ret = mkdir($instance_dir, 0777);
 226          if (!ret) { die("a directory named $instance_dir could not be made."); }
 227     }
 228 #   print $out_filename, "\n";
 229
 230 #  local($instance_dir) = @split_filename[$x-2];
 231 #  creates the directory.
 232 #  local($ret) = mkdir($instance_dir, 0777);
 233 #  if (!ret) { die("a directory named $instance_dir could not be made."); }
 234
 235   $out_filename;  # return the new name.
 236 }
 237
 238 #
 239 # grabs the name of the placeholder type that will be replaced by
 240 # the template instantiation type.
 241 #
 242 sub snag_place_holder {
 243   $place_holder = @_[0];
 244   chop $place_holder;
 245
 246   local(@pieces) = split(/>\s*/, $place_holder, 2);
 247
 248   # send back the parts not involved in the template statement.
 249   if (length($pieces[1])) {
 250      unshift(@file_array, $pieces[1]."\n");
 251   }
 252   $place_holder = $pieces[0];
 253   $place_holder =~ s/\s*template\s+<class\s+(\w+)$/\1/;
 254   if ($DEBUG_TEMPLATIZER) {
 255 #    print "Replacing place holder \"$place_holder\" with \"$instance_type\".\n";
 256   }
 257 }
 258
 259 #
 260 # grabs the name of the object itself that will become an instantiated
 261 # object in the type specified.  the global variable "object_name" is
 262 # set by the subfunctions used here.
 263 #
 264 sub snag_object_name {
 265   local($next_line) = shift(@file_array);
 266   chop $next_line;
 267   &match_class_declaration($next_line)
 268     || &match_class_member_definition($next_line)
 269       || &match_function_definition($next_line);
 270 }
 271
 272 #
 273 # creates a mangled form of the name that includes the instantiation
 274 # type.  the global variable "mangled_name" is set by this function.
 275 #
 276 sub mangle_name {
 277   local($to_grind) = @_[0];
 278   local($mangled_name) = "template__".$to_grind."__".$instance_type;
 279   if ($DEBUG_TEMPLATIZER) {
 280 #    print "Replacing name \"$to_grind\" with \"$mangled_name\".\n";
 281   }
 282   $mangled_name;
 283 }
 284
 285 #
 286 # processes "#include" preprocessor directives to make sure if the filename
 287 # is in there to include a C++ file (for the template code), then it gets
 288 # converted to the new file name.
 289 #
 290
 291 # this is a pretty bogus thing; it should not be used.
 292
 293 sub convert_inclusion {
 294   local($line) = @_[0];
 295   chop $line;
 296   local($temp) = $line;
 297   # extract out the name parts of the include declaration.
 298   $temp =~ s/\s*#include\s*([<"])([\w.]+)([>"])/\1 \2 \3/;
 299   local(@broken_up) = split(/ /, $temp);
 300   # strip off the punctuation from the name.
 301   local($incl_prefix) = @broken_up[1];
 302   $incl_prefix =~ s/["<](.*)[">]/\1/;
 303   $incl_prefix =~ s/\s//g;
 304   # return if it's not a code file being included.
 305   if (!grep(/.cpp/i, $incl_prefix)) { print OUTPUT_FILE $line, "\n"; return; }
 306   # strip to just the name without the ending.
 307   $incl_prefix =~ s/\.cpp$//i;
 308   # now get the name of the file we're processing.
 309   local($file_prefix) = $filename;
 310   # return if it's not a header file being examined.
 311   if (!grep(/.h/i, $file_prefix)) { print OUTPUT_FILE $line, "\n"; return; }
 312   # strip off the extension.
 313   $file_prefix =~ s/\.h$//i;
 314   # return if the names aren't equivalent--this means the include doesn't
 315   # refer to our new templated form of the code file.
 316   if ($incl_prefix ne $file_prefix) { print OUTPUT_FILE $line, "\n"; return FALSE; }
 317   # dump out a message about the removal.
 318   $line =~ s/^\s*//;
 319   print OUTPUT_FILE "/* removed unneeded template inclusion: $line */\n";
 320 }
 321
 322 #
 323 # extracts lines from the file until the curly brackets are matched up
 324 # at level 0.
 325 #
 326 sub absorb_until_matched_block {
 327   $bracket_level = 0;
 328   $end_absorb = 0;
 329   @template_buffer = ();
 330   $hit_one=0;
 331   while (@file_array) {
 332     local($line) = shift @file_array;
 333     &look_for_curlies($line);
 334     if (($hit_one && ($bracket_level == 0)) || $end_absorb) { return; }
 335   }
 336 }
 337
 338 #
 339 # examines the parameters passed in for curly brackets and changes the
 340 # counter if they are found.
 341 #
 342 sub look_for_curlies {
 343 #  $hit_one = 0;  # records whether a bracket was found or not.
 344   local($line) = @_[0];
 345   @word = ();
 346   foreach $char (split(//, $line)) {
 347     if ($char eq '{') {
 348       $hit_one = 1;
 349       $bracket_level++;
 350     } elsif ($char eq '}') {
 351       $hit_one = 1;
 352       $bracket_level--;
 353     } elsif (($char eq ';') && ($hit_one==0)) {
 354       $end_absorb = 1;
 355     }
 356
 357
 358     if ($DEBUG_TEMPLATIZER) {
 359 #      print "~$char~ ";
 360     }
 361     push(@word, $char);
 362     if (grep(!/\w/, $char)) {
 363       # don't split yet if it's a possible template char.
 364       if (grep(!/[<>]/, $char)) {
 365         local($real_word) = join("", @word);
 366         if ($DEBUG_TEMPLATIZER) {
 367 #          print "adding a word $real_word\n";
 368         }
 369         push(@template_buffer, "$real_word");
 370         @word = ();
 371       }
 372     }
 373   }
 374 }
 375
 376 #
 377 # this goes through the buffer and replaces all occurrences of the name to
 378 # replace with the instance name.
 379 #
 380 sub replace_place_holder {
 381   @new_template_buffer = @template_buffer;
 382   @template_buffer = ();
 383
 384   foreach $i (0 .. $#new_template_buffer) {
 385     $word = $new_template_buffer[$i];
 386 #    if ($DEBUG_TEMPLATIZER) {
 387 #      print "<$i $word> ";
 388 #      $old = $word;
 389 #    }
 390
 391     # replace a templated combination with the mangled version.
 392     $word =~ s/^${object_name}<${instance_type}>/${mangled_name}/;
 393
 394 #    if ($DEBUG_TEMPLATIZER) {
 395 #      if ($old ne $word) {print "1 ... changed to $word.\n"; $old = $word; }
 396 #    }
 397
 398     if (grep(/^\w+<\w+>/, $word)) {
 399       # replace some other template with our stuff if we can.
 400       $word = &special_mangle($word);
 401     }
 402
 403 #    if ($DEBUG_TEMPLATIZER) {
 404 #      if ($old ne $word) {print "2 ... changed to $word.\n"; $old = $word; }
 405 #    }
 406
 407     # replace the object's name with its mangled form.
 408     $word =~ s/^${object_name}/${mangled_name}/;
 409
 410 #    if ($DEBUG_TEMPLATIZER) {
 411 #      if ($old ne $word) {print "3... changed to $word.\n"; $old = $word; }
 412 #    }
 413
 414     # replace the place holder with the instantiation type.
 415     $word =~ s/^${place_holder}/${instance_type}/;
 416
 417 #    if ($DEBUG_TEMPLATIZER) {
 418 #      if ($old ne $word) {print "4... changed to $word.\n"; $old = $word; }
 419 #    }
 420
 421     push(@template_buffer, $word);
 422   }
 423 }
 424
 425 #
 426 # processes a general template usage, in the form X<Y>, where either
 427 # X or Y are not ones that we think we need to replace.  it is assumed
 428 # that it's safe to use the mangled form of the template.
 429 #
 430 sub special_mangle {
 431   local($word) = @_[0];
 432   # split the template form into pieces.
 433   local(@pieces) = split(/[<>]/, $word, 2);
 434
 435   $pieces[1] =~ s/${place_holder}/${instance_type}/;
 436   $pieces[1] =~ s/>//;
 437   # hold onto the real instance type.
 438   local($hold_instance) = $instance_type;
 439   $instance_type = $pieces[1];
 440   # mangle the name in the template usage line.
 441   local($hold_mangled) = &mangle_name($pieces[0]);
 442   # restore the original instance type.
 443   $instance_type = $hold_instance;
 444   # returns the new mangled form.
 445   $hold_mangled;
 446 }
 447
 448 #
 449 # prints out the buffer we've accumulated to the output file.
 450 #
 451 sub dump_the_buffer {
 452   print OUTPUT_FILE @template_buffer;
 453 }
 454
 455 #
 456 # processes a class declaration and sets the object name for future use.
 457 #
 458 sub match_class_declaration {
 459   local($next_line) = @_[0];
 460 # too strict!
 461 #  if (grep(!/class\s.*\w+$/, $next_line)
 462 #      && grep(!/class\s.*\w+\s*\{/, $next_line)
 463 #      && grep(!/struct\s.*\w+$/, $next_line)
 464 #      && grep(!/struct\s.*\w+\s*\{/, $next_line)) {
 465 #    return 0;
 466 #  }
 467
 468   if (grep(!/class\s+\w+/, $next_line) && grep(!/struct\s+\w+/, $next_line) ) {
 469     return 0;
 470   }
 471
 472   if ($DEBUG_TEMPLATIZER) {
 473 #    print "matched class decl in $next_line\n";
 474   }
 475
 476   if (grep(/class\s+\w+.*:/, $next_line)
 477       || grep(/struct\s+\w+.*:/, $next_line)) {
 478     # parses an inheriting class decl.
 479     if ($DEBUG_TEMPLATIZER) {
 480 #      print "in inheritance case on $next_line\n";
 481     }
 482     local(@pieces) = split(/:/, $next_line, 2);
 483     # push the rest of the line back into the input array.
 484     if ($DEBUG_TEMPLATIZER) {
 485 #      print "going to unshift $pieces[1]...\n";
 486     }
 487     unshift(@file_array, ": ".$pieces[1]." ");
 488     $next_line = $pieces[0];
 489   } elsif (grep(/class\s.*\w+\s*\{/, $next_line)
 490       || grep(/struct\s.*\w+\s*\{/, $next_line)) {
 491     # parses a non-inheriting declaration with bracket on same line.
 492     if ($DEBUG_TEMPLATIZER) {
 493 #      print "in special case on $next_line\n";
 494     }
 495     # special case for continued stuff on same line.
 496     local(@pieces) = split(/{/, $next_line, 2);
 497     # push the rest of the line back into the input array.
 498     unshift(@file_array, " { ".$pieces[1]." ");
 499     $next_line = $pieces[0];
 500   }
 501   if ($DEBUG_TEMPLATIZER) {
 502 #    print "matched class declaration... $next_line\n";
 503   }
 504   local(@pieces) = split(/\s/, $next_line);
 505   $object_name = $pieces[$#pieces];
 506   $mangled_name = &mangle_name($object_name);
 507   foreach $posn (0 .. $#pieces - 1) { print OUTPUT_FILE "$pieces[$posn] "; }
 508   print OUTPUT_FILE "$mangled_name\n";
 509   1;
 510 }
 511
 512 #
 513 # processes the implementation of a class member and sets the object
 514 # name for future use.
 515 #
 516 sub match_class_member_definition {
 517   local($next_line) = @_[0];
 518   local($junk);
 519   if (grep(!/\w+<\w+>::/, $next_line)) {
 520     return 0;
 521   }
 522   if ($DEBUG_TEMPLATIZER) {
 523 #    print "matched class member definition... $next_line\n";
 524   }
 525   local(@pieces) = split(/>::/, $next_line, 2);
 526   # checks for spaces in the first part of the split.  if there is one,
 527   # it means we don't have a simple object thing.
 528   if (grep(/\s/, $pieces[0])) {
 529     if ($DEBUG_TEMPLATIZER) {
 530 #      print "matched a space in the first part of supposed object name... $pieces[0]\n";
 531     }
 532     if (grep(/^\w+<\w+>/, $pieces[0])) {
 533       if ($DEBUG_TEMPLATIZER) {
 534 #        print "matched a template usage in first part of name...";
 535       }
 536       # replace some other template with our stuff if we can.
 537       $pieces[0] = &special_mangle($pieces[0]);
 538     }
 539     if ($DEBUG_TEMPLATIZER) {
 540 #      print "now our first bit is: $pieces[0]\n";
 541     }
 542     local(@new_pieces) = split(/ /, $pieces[0]);
 543     $pieces[0] = $new_pieces[$#new_pieces];
 544     foreach $posn (0 .. $#new_pieces - 1) {
 545       $new_pieces[$posn] =~ s/${place_holder}/${instance_type}/g;
 546       print OUTPUT_FILE "$new_pieces[$posn] ";
 547     }
 548   }
 549   unshift(@file_array, "::\n".$pieces[1]."\n");
 550   $object_name = $pieces[0];
 551   $object_name =~ s/(\W*)(\w+)<(\w+)/\2/;
 552   if (length($1)) { print OUTPUT_FILE "$1"; }
 553   if ($3 ne $place_holder) {
 554     die("The placeholder does not match on this line: $next_line");
 555   }
 556   $mangled_name = &mangle_name($object_name);
 557   print OUTPUT_FILE "$mangled_name\n";
 558   1;  # return success.
 559 }
 560
 561 #
 562 # processes a function template by making sure it fits the format and
 563 # then setting up the variables for the replacement.  since function templates
 564 # are so simple, the object name is not changed; only the place_holder is
 565 # changed to the instance type.
 566 #
 567 sub match_function_definition {
 568   local($next_line) = @_[0];
 569
 570   if (grep(!/^\s*\w+\s+.*/, $next_line) ) {
 571     if ($DEBUG_TEMPLATIZER) {
 572       print "failed on funcdef for ", $next_line, "!\n";
 573     }
 574     return 0;
 575   }
 576
 577 # old broken code:...
 578 #  if (grep(!/^\s*\w+\s+.*\(.*\)\s*/, $next_line) ) {
 579 #print "failed on funcdef for ", $next_line, "!\n";
 580 #    return 0;
 581 #  }
 582
 583 #  if ($DEBUG_TEMPLATIZER) {
 584 #    print "matched function definition on $next_line\n";
 585 #  }
 586
 587 #  if ($DEBUG_TEMPLATIZER) {
 588 #   print "stuffing back into the file array $next_line.\n";
 589 #  }
 590   # put the line back because it's nearly right for being instantiated.
 591   unshift(@file_array, "inline ".$next_line."\n");
 592   # come up with a very rare name that will not be matched in the text.
 593   $object_name = "hogga_wogga_nunky_budget_weeny_teeny_kahini_beany";
 594   $mangled_name = &mangle_name($object_name);
 595   1;  # return a success.
 596 }