1 /*
   2  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 // MAIN.CPP - Entry point for the Architecture Description Language Compiler
  26 #include "adlc.hpp"
  27 
  28 //------------------------------Prototypes-------------------------------------
  29 static void  usage(ArchDesc& AD);          // Print usage message and exit
  30 static char *strip_ext(char *fname);       // Strip off name extension
  31 static char *base_plus_suffix(const char* base, const char *suffix);// New concatenated string
  32 static char *prefix_plus_base_plus_suffix(const char* prefix, const char* base, const char *suffix);// New concatenated string
  33 static int get_legal_text(FileBuff &fbuf, char **legal_text); // Get pointer to legal text
  34 
  35 ArchDesc* globalAD = NULL;      // global reference to Architecture Description object
  36 
  37 const char* get_basename(const char* filename) {
  38   const char *basename = filename;
  39   const char *cp;
  40   for (cp = basename; *cp; cp++) {
  41     if (*cp == '/') {
  42       basename = cp+1;
  43     }
  44   }
  45   return basename;
  46 }
  47 
  48 //------------------------------main-------------------------------------------
  49 int main(int argc, char *argv[])
  50 {
  51   ArchDesc      AD;             // Architecture Description object
  52   globalAD = &AD;
  53 
  54   // ResourceMark  mark;
  55   ADLParser    *ADL_Parse;      // ADL Parser object to parse AD file
  56 
  57   // Check for proper arguments
  58   if( argc == 1 ) usage(AD);    // No arguments?  Then print usage
  59 
  60   // Read command line arguments and file names
  61   for( int i = 1; i < argc; i++ ) { // For all arguments
  62     register char *s = argv[i]; // Get option/filename
  63 
  64     if( *s++ == '-' ) {         // It's a flag? (not a filename)
  65       if( !*s ) {               // Stand-alone `-' means stdin
  66         //********** INSERT CODE HERE **********
  67       } else while (*s != '\0') { // While have flags on option
  68         switch (*s++) {         // Handle flag
  69         case 'd':               // Debug flag
  70           AD._dfa_debug += 1;   // Set Debug Flag
  71           break;
  72         case 'g':               // Debug ad location flag
  73           AD._adlocation_debug += 1;       // Set Debug ad location Flag
  74           break;
  75         case 'o':               // No Output Flag
  76           AD._no_output ^= 1;   // Toggle no_output flag
  77           break;
  78         case 'q':               // Quiet Mode Flag
  79           AD._quiet_mode ^= 1;  // Toggle quiet_mode flag
  80           break;
  81         case 'w':               // Disable Warnings Flag
  82           AD._disable_warnings ^= 1; // Toggle disable_warnings flag
  83           break;
  84         case 'T':               // Option to make DFA as many subroutine calls.
  85           AD._dfa_small += 1;   // Set Mode Flag
  86           break;
  87         case 'c': {             // Set C++ Output file name
  88           AD._CPP_file._name = s;
  89           const char *base = strip_ext(strdup(s));
  90           AD._CPP_CLONE_file._name    = base_plus_suffix(base,"_clone.cpp");
  91           AD._CPP_EXPAND_file._name   = base_plus_suffix(base,"_expand.cpp");
  92           AD._CPP_FORMAT_file._name   = base_plus_suffix(base,"_format.cpp");
  93           AD._CPP_GEN_file._name      = base_plus_suffix(base,"_gen.cpp");
  94           AD._CPP_MISC_file._name     = base_plus_suffix(base,"_misc.cpp");
  95           AD._CPP_PEEPHOLE_file._name = base_plus_suffix(base,"_peephole.cpp");
  96           AD._CPP_PIPELINE_file._name = base_plus_suffix(base,"_pipeline.cpp");
  97           s += strlen(s);
  98           break;
  99         }
 100         case 'h':               // Set C++ Output file name
 101           AD._HPP_file._name = s; s += strlen(s);
 102           break;
 103         case 'v':               // Set C++ Output file name
 104           AD._VM_file._name = s; s += strlen(s);
 105           break;
 106         case 'a':               // Set C++ Output file name
 107           AD._DFA_file._name = s;
 108           AD._bug_file._name = s;
 109           s += strlen(s);
 110           break;
 111         case '#':               // Special internal debug flag
 112           AD._adl_debug++;      // Increment internal debug level
 113           break;
 114         case 's':               // Output which instructions are cisc-spillable
 115           AD._cisc_spill_debug = true;
 116           break;
 117         case 'D':               // Flag Definition
 118           {
 119             char* flag = s;
 120             s += strlen(s);
 121             char* def = strchr(flag, '=');
 122             if (def == NULL)  def = (char*)"1";
 123             else              *def++ = '\0';
 124             AD.set_preproc_def(flag, def);
 125           }
 126           break;
 127         case 'U':               // Flag Un-Definition
 128           {
 129             char* flag = s;
 130             s += strlen(s);
 131             AD.set_preproc_def(flag, NULL);
 132           }
 133           break;
 134         default:                // Unknown option
 135           usage(AD);            // So print usage and exit
 136         }                       // End of switch on options...
 137       }                         // End of while have options...
 138 
 139     } else {                    // Not an option; must be a filename
 140       AD._ADL_file._name = argv[i]; // Set the input filename
 141 
 142       // // Files for storage, based on input file name
 143       const char *base = strip_ext(strdup(argv[i]));
 144       char       *temp = base_plus_suffix("dfa_",base);
 145       AD._DFA_file._name = base_plus_suffix(temp,".cpp");
 146       delete temp;
 147       temp = base_plus_suffix("ad_",base);
 148       AD._CPP_file._name          = base_plus_suffix(temp,".cpp");
 149       AD._CPP_CLONE_file._name    = base_plus_suffix(temp,"_clone.cpp");
 150       AD._CPP_EXPAND_file._name   = base_plus_suffix(temp,"_expand.cpp");
 151       AD._CPP_FORMAT_file._name   = base_plus_suffix(temp,"_format.cpp");
 152       AD._CPP_GEN_file._name      = base_plus_suffix(temp,"_gen.cpp");
 153       AD._CPP_MISC_file._name     = base_plus_suffix(temp,"_misc.cpp");
 154       AD._CPP_PEEPHOLE_file._name = base_plus_suffix(temp,"_peephole.cpp");
 155       AD._CPP_PIPELINE_file._name = base_plus_suffix(temp,"_pipeline.cpp");
 156       AD._HPP_file._name = base_plus_suffix(temp,".hpp");
 157       delete temp;
 158       temp = base_plus_suffix("adGlobals_",base);
 159       AD._VM_file._name = base_plus_suffix(temp,".hpp");
 160       delete temp;
 161       temp = base_plus_suffix("bugs_",base);
 162       AD._bug_file._name = base_plus_suffix(temp,".out");
 163       delete temp;
 164     }                           // End of files vs options...
 165   }                             // End of while have command line arguments
 166 
 167   // Open files used to store the matcher and its components
 168   if (AD.open_files() == 0) return 1; // Open all input/output files
 169 
 170   // Build the File Buffer, Parse the input, & Generate Code
 171   FileBuff  ADL_Buf(&AD._ADL_file, AD); // Create a file buffer for input file
 172 
 173   // Get pointer to legal text at the beginning of AD file.
 174   // It will be used in generated ad files.
 175   char* legal_text;
 176   int legal_sz = get_legal_text(ADL_Buf, &legal_text);
 177 
 178   ADL_Parse = new ADLParser(ADL_Buf, AD); // Create a parser to parse the buffer
 179   ADL_Parse->parse();           // Parse buffer & build description lists
 180 
 181   if( AD._dfa_debug >= 1 ) {    // For higher debug settings, print dump
 182     AD.dump();
 183   }
 184 
 185   delete ADL_Parse;             // Delete parser
 186 
 187   // Verify that the results of the parse are consistent
 188   AD.verify();
 189 
 190   // Prepare to generate the result files:
 191   AD.generateMatchLists();
 192   AD.identify_unique_operands();
 193   AD.identify_cisc_spill_instructions();
 194   AD.identify_short_branches();
 195   // Make sure every file starts with a copyright:
 196   AD.addSunCopyright(legal_text, legal_sz, AD._HPP_file._fp);           // .hpp
 197   AD.addSunCopyright(legal_text, legal_sz, AD._CPP_file._fp);           // .cpp
 198   AD.addSunCopyright(legal_text, legal_sz, AD._CPP_CLONE_file._fp);     // .cpp
 199   AD.addSunCopyright(legal_text, legal_sz, AD._CPP_EXPAND_file._fp);    // .cpp
 200   AD.addSunCopyright(legal_text, legal_sz, AD._CPP_FORMAT_file._fp);    // .cpp
 201   AD.addSunCopyright(legal_text, legal_sz, AD._CPP_GEN_file._fp);       // .cpp
 202   AD.addSunCopyright(legal_text, legal_sz, AD._CPP_MISC_file._fp);      // .cpp
 203   AD.addSunCopyright(legal_text, legal_sz, AD._CPP_PEEPHOLE_file._fp);  // .cpp
 204   AD.addSunCopyright(legal_text, legal_sz, AD._CPP_PIPELINE_file._fp);  // .cpp
 205   AD.addSunCopyright(legal_text, legal_sz, AD._VM_file._fp);            // .hpp
 206   AD.addSunCopyright(legal_text, legal_sz, AD._DFA_file._fp);           // .cpp
 207   // Add include guards for all .hpp files
 208   AD.addIncludeGuardStart(AD._HPP_file, "GENERATED_ADFILES_AD_HPP");        // .hpp
 209   AD.addIncludeGuardStart(AD._VM_file, "GENERATED_ADFILES_ADGLOBALS_HPP");  // .hpp
 210   // Add includes
 211   AD.addInclude(AD._CPP_file, "precompiled.hpp");
 212   AD.addInclude(AD._CPP_file, "adfiles", get_basename(AD._VM_file._name));
 213   AD.addInclude(AD._CPP_file, "adfiles", get_basename(AD._HPP_file._name));
 214   AD.addInclude(AD._CPP_file, "memory/allocation.inline.hpp");
 215   AD.addInclude(AD._CPP_file, "asm/macroAssembler.inline.hpp");
 216   AD.addInclude(AD._CPP_file, "code/compiledIC.hpp");
 217   AD.addInclude(AD._CPP_file, "code/vmreg.hpp");
 218   AD.addInclude(AD._CPP_file, "gc_interface/collectedHeap.inline.hpp");
 219   AD.addInclude(AD._CPP_file, "oops/compiledICHolder.hpp");
 220   AD.addInclude(AD._CPP_file, "oops/markOop.hpp");
 221   AD.addInclude(AD._CPP_file, "oops/method.hpp");
 222   AD.addInclude(AD._CPP_file, "oops/oop.inline.hpp");
 223   AD.addInclude(AD._CPP_file, "oops/oop.inline2.hpp");
 224   AD.addInclude(AD._CPP_file, "opto/cfgnode.hpp");
 225   AD.addInclude(AD._CPP_file, "opto/locknode.hpp");
 226   AD.addInclude(AD._CPP_file, "opto/opcodes.hpp");
 227   AD.addInclude(AD._CPP_file, "opto/regalloc.hpp");
 228   AD.addInclude(AD._CPP_file, "opto/regmask.hpp");
 229   AD.addInclude(AD._CPP_file, "opto/runtime.hpp");
 230   AD.addInclude(AD._CPP_file, "runtime/biasedLocking.hpp");
 231   AD.addInclude(AD._CPP_file, "runtime/sharedRuntime.hpp");
 232   AD.addInclude(AD._CPP_file, "runtime/stubRoutines.hpp");
 233   AD.addInclude(AD._CPP_file, "utilities/growableArray.hpp");
 234 #ifdef TARGET_ARCH_x86
 235   AD.addInclude(AD._CPP_file, "nativeInst_x86.hpp");
 236   AD.addInclude(AD._CPP_file, "vmreg_x86.inline.hpp");
 237 #endif
 238 #ifdef TARGET_ARCH_aarch64
 239   AD.addInclude(AD._CPP_file, "assembler_aarch64.inline.hpp");
 240   AD.addInclude(AD._CPP_file, "nativeInst_aarch64.hpp");
 241   AD.addInclude(AD._CPP_file, "vmreg_aarch64.inline.hpp");
 242 #endif
 243 #ifdef TARGET_ARCH_sparc
 244   AD.addInclude(AD._CPP_file, "nativeInst_sparc.hpp");
 245   AD.addInclude(AD._CPP_file, "vmreg_sparc.inline.hpp");
 246 #endif
 247 #ifdef TARGET_ARCH_arm
 248   AD.addInclude(AD._CPP_file, "nativeInst_arm.hpp");
 249   AD.addInclude(AD._CPP_file, "vmreg_arm.inline.hpp");
 250 #endif
 251 #ifdef TARGET_ARCH_ppc
 252   AD.addInclude(AD._CPP_file, "assembler_ppc.inline.hpp");
 253   AD.addInclude(AD._CPP_file, "nativeInst_ppc.hpp");
 254   AD.addInclude(AD._CPP_file, "vmreg_ppc.inline.hpp");
 255 #endif
 256   AD.addInclude(AD._HPP_file, "memory/allocation.hpp");
 257   AD.addInclude(AD._HPP_file, "opto/machnode.hpp");
 258   AD.addInclude(AD._HPP_file, "opto/node.hpp");
 259   AD.addInclude(AD._HPP_file, "opto/regalloc.hpp");
 260   AD.addInclude(AD._HPP_file, "opto/subnode.hpp");
 261   AD.addInclude(AD._HPP_file, "opto/vectornode.hpp");
 262   AD.addInclude(AD._CPP_CLONE_file, "precompiled.hpp");
 263   AD.addInclude(AD._CPP_CLONE_file, "adfiles", get_basename(AD._HPP_file._name));
 264   AD.addInclude(AD._CPP_EXPAND_file, "precompiled.hpp");
 265   AD.addInclude(AD._CPP_EXPAND_file, "adfiles", get_basename(AD._HPP_file._name));
 266   AD.addInclude(AD._CPP_FORMAT_file, "precompiled.hpp");
 267   AD.addInclude(AD._CPP_FORMAT_file, "adfiles", get_basename(AD._HPP_file._name));
 268   AD.addInclude(AD._CPP_GEN_file, "precompiled.hpp");
 269   AD.addInclude(AD._CPP_GEN_file, "adfiles", get_basename(AD._HPP_file._name));
 270   AD.addInclude(AD._CPP_GEN_file, "opto/cfgnode.hpp");
 271   AD.addInclude(AD._CPP_GEN_file, "opto/locknode.hpp");
 272   AD.addInclude(AD._CPP_MISC_file, "precompiled.hpp");
 273   AD.addInclude(AD._CPP_MISC_file, "adfiles", get_basename(AD._HPP_file._name));
 274   AD.addInclude(AD._CPP_PEEPHOLE_file, "precompiled.hpp");
 275   AD.addInclude(AD._CPP_PEEPHOLE_file, "adfiles", get_basename(AD._HPP_file._name));
 276   AD.addInclude(AD._CPP_PIPELINE_file, "precompiled.hpp");
 277   AD.addInclude(AD._CPP_PIPELINE_file, "adfiles", get_basename(AD._HPP_file._name));
 278   AD.addInclude(AD._DFA_file, "precompiled.hpp");
 279   AD.addInclude(AD._DFA_file, "adfiles", get_basename(AD._HPP_file._name));
 280   AD.addInclude(AD._DFA_file, "opto/cfgnode.hpp");  // Use PROB_MAX in predicate.
 281   AD.addInclude(AD._DFA_file, "opto/matcher.hpp");
 282   AD.addInclude(AD._DFA_file, "opto/opcodes.hpp");
 283   // Make sure each .cpp file starts with include lines:
 284   // files declaring and defining generators for Mach* Objects (hpp,cpp)
 285   // Generate the result files:
 286   // enumerations, class definitions, object generators, and the DFA
 287   // file containing enumeration of machine operands & instructions (hpp)
 288   AD.addPreHeaderBlocks(AD._HPP_file._fp);        // .hpp
 289   AD.buildMachOperEnum(AD._HPP_file._fp);         // .hpp
 290   AD.buildMachOpcodesEnum(AD._HPP_file._fp);      // .hpp
 291   AD.buildMachRegisterNumbers(AD._VM_file._fp);   // VM file
 292   AD.buildMachRegisterEncodes(AD._HPP_file._fp);  // .hpp file
 293   AD.declareRegSizes(AD._HPP_file._fp);           // .hpp
 294   AD.build_pipeline_enums(AD._HPP_file._fp);      // .hpp
 295   // output definition of class "State"
 296   AD.defineStateClass(AD._HPP_file._fp);          // .hpp
 297   // file declaring the Mach* classes derived from MachOper and MachNode
 298   AD.declareClasses(AD._HPP_file._fp);
 299   // declare and define maps: in the .hpp and .cpp files respectively
 300   AD.addSourceBlocks(AD._CPP_file._fp);           // .cpp
 301   AD.addHeaderBlocks(AD._HPP_file._fp);           // .hpp
 302   AD.buildReduceMaps(AD._HPP_file._fp, AD._CPP_file._fp);
 303   AD.buildMustCloneMap(AD._HPP_file._fp, AD._CPP_file._fp);
 304   // build CISC_spilling oracle and MachNode::cisc_spill() methods
 305   AD.build_cisc_spill_instructions(AD._HPP_file._fp, AD._CPP_file._fp);
 306   // define methods for machine dependent State, MachOper, and MachNode classes
 307   AD.defineClasses(AD._CPP_file._fp);
 308   AD.buildMachOperGenerator(AD._CPP_GEN_file._fp);// .cpp
 309   AD.buildMachNodeGenerator(AD._CPP_GEN_file._fp);// .cpp
 310   // define methods for machine dependent instruction matching
 311   AD.buildInstructMatchCheck(AD._CPP_file._fp);  // .cpp
 312   // define methods for machine dependent frame management
 313   AD.buildFrameMethods(AD._CPP_file._fp);         // .cpp
 314   AD.generate_needs_clone_jvms(AD._CPP_file._fp);
 315 
 316   // do this last:
 317   AD.addPreprocessorChecks(AD._CPP_file._fp);     // .cpp
 318   AD.addPreprocessorChecks(AD._CPP_CLONE_file._fp);     // .cpp
 319   AD.addPreprocessorChecks(AD._CPP_EXPAND_file._fp);    // .cpp
 320   AD.addPreprocessorChecks(AD._CPP_FORMAT_file._fp);    // .cpp
 321   AD.addPreprocessorChecks(AD._CPP_GEN_file._fp);       // .cpp
 322   AD.addPreprocessorChecks(AD._CPP_MISC_file._fp);      // .cpp
 323   AD.addPreprocessorChecks(AD._CPP_PEEPHOLE_file._fp);  // .cpp
 324   AD.addPreprocessorChecks(AD._CPP_PIPELINE_file._fp);  // .cpp
 325 
 326   // define the finite automata that selects lowest cost production
 327   AD.buildDFA(AD._DFA_file._fp);
 328   // Add include guards for all .hpp files
 329   AD.addIncludeGuardEnd(AD._HPP_file, "GENERATED_ADFILES_AD_HPP");        // .hpp
 330   AD.addIncludeGuardEnd(AD._VM_file, "GENERATED_ADFILES_ADGLOBALS_HPP");  // .hpp
 331 
 332   AD.close_files(0);               // Close all input/output files
 333 
 334   // Final printout and statistics
 335   // cout << program;
 336 
 337   if( AD._dfa_debug & 2 ) {    // For higher debug settings, print timing info
 338     //    Timer t_stop;
 339     //    Timer t_total = t_stop - t_start; // Total running time
 340     //    cerr << "\n---Architecture Description Totals---\n";
 341     //    cerr << ", Total lines: " << TotalLines;
 342     //    float l = TotalLines;
 343     //    cerr << "\nTotal Compilation Time: " << t_total << "\n";
 344     //    float ft = (float)t_total;
 345     //    if( ft > 0.0 ) fprintf(stderr,"Lines/sec: %#5.2f\n", l/ft);
 346   }
 347   return (AD._syntax_errs + AD._semantic_errs + AD._internal_errs); // Bye Bye!!
 348 }
 349 
 350 //------------------------------usage------------------------------------------
 351 static void usage(ArchDesc& AD)
 352 {
 353   printf("Architecture Description Language Compiler\n\n");
 354   printf("Usage: adlc [-doqwTs] [-#]* [-D<FLAG>[=<DEF>]] [-U<FLAG>] [-c<CPP_FILE_NAME>] [-h<HPP_FILE_NAME>] [-a<DFA_FILE_NAME>] [-v<GLOBALS_FILE_NAME>] <ADL_FILE_NAME>\n");
 355   printf(" d  produce DFA debugging info\n");
 356   printf(" o  no output produced, syntax and semantic checking only\n");
 357   printf(" q  quiet mode, supresses all non-essential messages\n");
 358   printf(" w  suppress warning messages\n");
 359   printf(" T  make DFA as many subroutine calls\n");
 360   printf(" s  output which instructions are cisc-spillable\n");
 361   printf(" D  define preprocessor symbol\n");
 362   printf(" U  undefine preprocessor symbol\n");
 363   printf(" c  specify CPP file name (default: %s)\n", AD._CPP_file._name);
 364   printf(" h  specify HPP file name (default: %s)\n", AD._HPP_file._name);
 365   printf(" a  specify DFA output file name\n");
 366   printf(" v  specify adGlobals output file name\n");
 367   printf(" #  increment ADL debug level\n");
 368   printf("\n");
 369 }
 370 
 371 //------------------------------open_file------------------------------------
 372 int ArchDesc::open_file(bool required, ADLFILE & ADF, const char *action)
 373 {
 374   if (required &&
 375       (ADF._fp = fopen(ADF._name, action)) == NULL) {
 376     printf("ERROR: Cannot open file for %s: %s\n", action, ADF._name);
 377     close_files(1);
 378     return 0;
 379   }
 380   return 1;
 381 }
 382 
 383 //------------------------------open_files-------------------------------------
 384 int ArchDesc::open_files(void)
 385 {
 386   if (_ADL_file._name == NULL)
 387   { printf("ERROR: No ADL input file specified\n"); return 0; }
 388 
 389   if (!open_file(true       , _ADL_file, "r"))          { return 0; }
 390   if (!open_file(!_no_output, _DFA_file, "w"))          { return 0; }
 391   if (!open_file(!_no_output, _HPP_file, "w"))          { return 0; }
 392   if (!open_file(!_no_output, _CPP_file, "w"))          { return 0; }
 393   if (!open_file(!_no_output, _CPP_CLONE_file, "w"))    { return 0; }
 394   if (!open_file(!_no_output, _CPP_EXPAND_file, "w"))   { return 0; }
 395   if (!open_file(!_no_output, _CPP_FORMAT_file, "w"))   { return 0; }
 396   if (!open_file(!_no_output, _CPP_GEN_file, "w"))      { return 0; }
 397   if (!open_file(!_no_output, _CPP_MISC_file, "w"))     { return 0; }
 398   if (!open_file(!_no_output, _CPP_PEEPHOLE_file, "w")) { return 0; }
 399   if (!open_file(!_no_output, _CPP_PIPELINE_file, "w")) { return 0; }
 400   if (!open_file(!_no_output, _VM_file , "w"))          { return 0; }
 401   if (!open_file(_dfa_debug != 0, _bug_file, "w"))    { return 0; }
 402 
 403   return 1;
 404 }
 405 
 406 //------------------------------close_file------------------------------------
 407 void ArchDesc::close_file(int delete_out, ADLFILE& ADF)
 408 {
 409   if (ADF._fp) {
 410     fclose(ADF._fp);
 411     if (delete_out) remove(ADF._name);
 412   }
 413 }
 414 
 415 //------------------------------close_files------------------------------------
 416 void ArchDesc::close_files(int delete_out)
 417 {
 418   if (_ADL_file._fp) fclose(_ADL_file._fp);
 419 
 420   close_file(delete_out, _CPP_file);
 421   close_file(delete_out, _CPP_CLONE_file);
 422   close_file(delete_out, _CPP_EXPAND_file);
 423   close_file(delete_out, _CPP_FORMAT_file);
 424   close_file(delete_out, _CPP_GEN_file);
 425   close_file(delete_out, _CPP_MISC_file);
 426   close_file(delete_out, _CPP_PEEPHOLE_file);
 427   close_file(delete_out, _CPP_PIPELINE_file);
 428   close_file(delete_out, _HPP_file);
 429   close_file(delete_out, _DFA_file);
 430   close_file(delete_out, _bug_file);
 431 
 432   if (!_quiet_mode) {
 433     printf("\n");
 434     if (_no_output || delete_out) {
 435       if (_ADL_file._name) printf("%s: ", _ADL_file._name);
 436       printf("No output produced");
 437     }
 438     else {
 439       if (_ADL_file._name) printf("%s --> ", _ADL_file._name);
 440       printf("%s, %s, %s, %s, %s, %s, %s, %s, %s, %s",
 441              _CPP_file._name,
 442              _CPP_CLONE_file._name,
 443              _CPP_EXPAND_file._name,
 444              _CPP_FORMAT_file._name,
 445              _CPP_GEN_file._name,
 446              _CPP_MISC_file._name,
 447              _CPP_PEEPHOLE_file._name,
 448              _CPP_PIPELINE_file._name,
 449              _HPP_file._name,
 450              _DFA_file._name);
 451     }
 452     printf("\n");
 453   }
 454 }
 455 
 456 //------------------------------strip_ext--------------------------------------
 457 static char *strip_ext(char *fname)
 458 {
 459   char *ep;
 460 
 461   if (fname) {
 462     ep = fname + strlen(fname) - 1; // start at last character and look for '.'
 463     while (ep >= fname && *ep != '.') --ep;
 464     if (*ep == '.')     *ep = '\0'; // truncate string at '.'
 465   }
 466   return fname;
 467 }
 468 
 469 //------------------------------base_plus_suffix-------------------------------
 470 // New concatenated string
 471 static char *base_plus_suffix(const char* base, const char *suffix)
 472 {
 473   int len = (int)strlen(base) + (int)strlen(suffix) + 1;
 474 
 475   char* fname = new char[len];
 476   sprintf(fname,"%s%s",base,suffix);
 477   return fname;
 478 }
 479 
 480 //------------------------------get_legal_text---------------------------------
 481 // Get pointer to legal text at the beginning of AD file.
 482 // This code assumes that a legal text starts at the beginning of .ad files,
 483 // is commented by "//" at each line and ends with empty line.
 484 //
 485 int get_legal_text(FileBuff &fbuf, char **legal_text)
 486 {
 487   char* legal_start = fbuf.get_line();
 488   assert(legal_start[0] == '/' && legal_start[1] == '/', "Incorrect header of AD file");
 489   char* legal_end = fbuf.get_line();
 490   assert(strncmp(legal_end, "// Copyright", 12) == 0, "Incorrect header of AD file");
 491   while(legal_end[0] == '/' && legal_end[1] == '/') {
 492     legal_end = fbuf.get_line();
 493   }
 494   *legal_text = legal_start;
 495   return (int) (legal_end - legal_start);
 496 }
 497 
 498 // VS2005 has its own definition, identical to this one.
 499 #if !defined(_WIN32) || defined(_WIN64) || _MSC_VER < 1400
 500 void *operator new( size_t size, int, const char *, int ) throw() {
 501   return ::operator new( size );
 502 }
 503 #endif