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