ragel/main.cpp

   1 /*
   2  *  Copyright 2001-2007 Adrian Thurston <thurston@cs.queensu.ca>
   3  */
   4
   5 /*  This file is part of Ragel.
   6  *
   7  *  Ragel is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  Ragel is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with Ragel; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <stdio.h>
  25 #include <iostream>
  26 #include <fstream>
  27 #include <unistd.h>
  28 #include <sstream>
  29 #include <unistd.h>
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #include <fcntl.h>
  33 #include <errno.h>
  34
  35 #ifndef WIN32
  36 #include <sys/wait.h>
  37 #else
  38 #include <windows.h>
  39 #include <psapi.h>
  40 #endif
  41
  42 /* Parsing. */
  43 #include "ragel.h"
  44 #include "rlscan.h"
  45
  46 /* Parameters and output. */
  47 #include "pcheck.h"
  48 #include "vector.h"
  49 #include "version.h"
  50 #include "common.h"
  51
  52 using std::istream;
  53 using std::ostream;
  54 using std::ifstream;
  55 using std::ofstream;
  56 using std::cin;
  57 using std::cout;
  58 using std::cerr;
  59 using std::endl;
  60 using std::ios;
  61 using std::streamsize;
  62
  63 /* Controls minimization. */
  64 MinimizeLevel minimizeLevel = MinimizePartition2;
  65 MinimizeOpt minimizeOpt = MinimizeMostOps;
  66
  67 /* Graphviz dot file generation. */
  68 char *machineSpec = 0, *machineName = 0;
  69 bool machineSpecFound = false;
  70 bool wantDupsRemoved = true;
  71
  72 bool printStatistics = false;
  73 bool frontendOnly = false;
  74 bool generateDot = false;
  75
  76 ArgsVector frontendArgs;
  77 ArgsVector backendArgs;
  78 ArgsVector includePaths;
  79
  80 /* Print a summary of the options. */
  81 void usage()
  82 {
  83         cout <<
  84 "usage: ragel [options] file\n"
  85 "general:\n"
  86 "   -h, -H, -?, --help   Print this usage and exit\n"
  87 "   -v, --version        Print version information and exit\n"
  88 "   -o <file>            Write output to <file>\n"
  89 "   -s                   Print some statistics on stderr\n"
  90 "   -d                   Do not remove duplicates from action lists\n"
  91 "fsm minimization:\n"
  92 "   -n                   Do not perform minimization\n"
  93 "   -m                   Minimize at the end of the compilation\n"
  94 "   -l                   Minimize after most operations (default)\n"
  95 "   -e                   Minimize after every operation\n"
  96 "visualization:\n"
  97 "   -x                   Run the frontend only: emit XML intermediate format\n"
  98 "   -V                   Generate a dot file for Graphviz\n"
  99 "   -p                   Display printable characters on labels\n"
 100 "   -S <spec>            FSM specification to output (for rlgen-dot)\n"
 101 "   -M <machine>         Machine definition/instantiation to output (for rlgen-dot)\n"
 102 "host language:\n"
 103 "   -C                   The host language is C, C++, Obj-C or Obj-C++ (default)\n"
 104 "   -D                   The host language is D\n"
 105 "   -J                   The host language is Java\n"
 106 "   -R                   The host language is Ruby\n"
 107 "   -A                   The host language is C#\n"
 108 "line direcives: (C/D/C# only)\n"
 109 "   -L                   Inhibit writing of #line directives\n"
 110 "code style: (C/Ruby/C# only)\n"
 111 "   -T0                  Table driven FSM (default)\n"
 112 "   -T1                  Faster table driven FSM\n"
 113 "   -F0                  Flat table driven FSM\n"
 114 "   -F1                  Faster flat table-driven FSM\n"
 115 "code style: (C/C# only)\n"
 116 "   -G0                  Goto-driven FSM\n"
 117 "   -G1                  Faster goto-driven FSM\n"
 118 "code style: (C only)\n"
 119 "   -G2                  Really fast goto-driven FSM\n"
 120 "   -P<N>                N-Way Split really fast goto-driven FSM\n"
 121         ;
 122 }
 123
 124 /* Print version information. */
 125 void version()
 126 {
 127         cout << "Ragel State Machine Compiler version " VERSION << " " PUBDATE << endl <<
 128                         "Copyright (c) 2001-2007 by Adrian Thurston" << endl;
 129 }
 130
 131 /* Total error count. */
 132 int gblErrorCount = 0;
 133
 134 /* Print the opening to a warning in the input, then return the error ostream. */
 135 ostream &warning( const InputLoc &loc )
 136 {
 137         assert( loc.fileName != 0 );
 138         cerr << loc.fileName << ":" << loc.line << ":" <<
 139                         loc.col << ": warning: ";
 140         return cerr;
 141 }
 142
 143 /* Print the opening to a program error, then return the error stream. */
 144 ostream &error()
 145 {
 146         gblErrorCount += 1;
 147         cerr << PROGNAME ": ";
 148         return cerr;
 149 }
 150
 151 ostream &error( const InputLoc &loc )
 152 {
 153         gblErrorCount += 1;
 154         assert( loc.fileName != 0 );
 155         cerr << loc.fileName << ":" << loc.line << ": ";
 156         return cerr;
 157 }
 158
 159 void escapeLineDirectivePath( std::ostream &out, char *path )
 160 {
 161         for ( char *pc = path; *pc != 0; pc++ ) {
 162                 if ( *pc == '\\' )
 163                         out << "\\\\";
 164                 else
 165                         out << *pc;
 166         }
 167 }
 168
 169 void processArgs( int argc, char **argv, char *&inputFileName, char *&outputFileName )
 170 {
 171         ParamCheck pc("xo:dnmleabjkS:M:I:CDJRAvHh?-:sT:F:G:P:LpV", argc, argv);
 172
 173         while ( pc.check() ) {
 174                 switch ( pc.state ) {
 175                 case ParamCheck::match:
 176                         switch ( pc.parameter ) {
 177                         case 'V':
 178                                 generateDot = true;
 179                                 break;
 180
 181                         case 'x':
 182                                 frontendOnly = true;
 183                                 break;
 184
 185                         /* Output. */
 186                         case 'o':
 187                                 if ( *pc.parameterArg == 0 )
 188                                         error() << "a zero length output file name was given" << endl;
 189                                 else if ( outputFileName != 0 )
 190                                         error() << "more than one output file name was given" << endl;
 191                                 else {
 192                                         /* Ok, remember the output file name. */
 193                                         outputFileName = pc.parameterArg;
 194                                 }
 195                                 break;
 196
 197                         /* Minimization, mostly hidden options. */
 198                         case 'd':
 199                                 wantDupsRemoved = false;
 200                                 frontendArgs.append( "-d" );
 201                                 break;
 202
 203                         /* Minimization, mostly hidden options. */
 204                         case 'n':
 205                                 minimizeOpt = MinimizeNone;
 206                                 frontendArgs.append( "-n" );
 207                                 break;
 208                         case 'm':
 209                                 minimizeOpt = MinimizeEnd;
 210                                 frontendArgs.append( "-m" );
 211                                 break;
 212                         case 'l':
 213                                 minimizeOpt = MinimizeMostOps;
 214                                 frontendArgs.append( "-l" );
 215                                 break;
 216                         case 'e':
 217                                 minimizeOpt = MinimizeEveryOp;
 218                                 frontendArgs.append( "-e" );
 219                                 break;
 220                         case 'a':
 221                                 minimizeLevel = MinimizeApprox;
 222                                 frontendArgs.append( "-a" );
 223                                 break;
 224                         case 'b':
 225                                 minimizeLevel = MinimizeStable;
 226                                 frontendArgs.append( "-b" );
 227                                 break;
 228                         case 'j':
 229                                 minimizeLevel = MinimizePartition1;
 230                                 frontendArgs.append( "-j" );
 231                                 break;
 232                         case 'k':
 233                                 minimizeLevel = MinimizePartition2;
 234                                 frontendArgs.append( "-k" );
 235                                 break;
 236
 237                         /* Machine spec. */
 238                         case 'S':
 239                                 if ( *pc.parameterArg == 0 )
 240                                         error() << "please specify an argument to -S" << endl;
 241                                 else if ( machineSpec != 0 )
 242                                         error() << "more than one -S argument was given" << endl;
 243                                 else {
 244                                         /* Ok, remember the path to the machine to generate. */
 245                                         machineSpec = pc.parameterArg;
 246                                         frontendArgs.append( "-S" );
 247                                         frontendArgs.append( pc.parameterArg );
 248                                 }
 249                                 break;
 250
 251                         /* Machine path. */
 252                         case 'M':
 253                                 if ( *pc.parameterArg == 0 )
 254                                         error() << "please specify an argument to -M" << endl;
 255                                 else if ( machineName != 0 )
 256                                         error() << "more than one -M argument was given" << endl;
 257                                 else {
 258                                         /* Ok, remember the machine name to generate. */
 259                                         machineName = pc.parameterArg;
 260                                         frontendArgs.append( "-M" );
 261                                         frontendArgs.append( pc.parameterArg );
 262                                 }
 263                                 break;
 264
 265                         case 'I':
 266                                 if ( *pc.parameterArg == 0 )
 267                                         error() << "please specify an argument to -I" << endl;
 268                                 else {
 269                                         includePaths.append( pc.parameterArg );
 270                                         frontendArgs.append( "-I" );
 271                                         frontendArgs.append( pc.parameterArg );
 272                                 }
 273                                 break;
 274
 275                         /* Host language types. */
 276                         case 'C':
 277                                 hostLang = &hostLangC;
 278                                 frontendArgs.append( "-C" );
 279                                 break;
 280                         case 'D':
 281                                 hostLang = &hostLangD;
 282                                 frontendArgs.append( "-D" );
 283                                 break;
 284                         case 'J':
 285                                 hostLang = &hostLangJava;
 286                                 frontendArgs.append( "-J" );
 287                                 break;
 288                         case 'R':
 289                                 hostLang = &hostLangRuby;
 290                                 frontendArgs.append( "-R" );
 291                                 break;
 292                         case 'A':
 293                                 hostLang = &hostLangCSharp;
 294                                 frontendArgs.append( "-A" );
 295                                 break;
 296
 297                         /* Version and help. */
 298                         case 'v':
 299                                 version();
 300                                 exit(0);
 301                         case 'H': case 'h': case '?':
 302                                 usage();
 303                                 exit(0);
 304                         case 's':
 305                                 printStatistics = true;
 306                                 frontendArgs.append( "-s" );
 307                                 break;
 308                         case '-':
 309                                 if ( strcasecmp(pc.parameterArg, "help") == 0 ) {
 310                                         usage();
 311                                         exit(0);
 312                                 }
 313                                 else if ( strcasecmp(pc.parameterArg, "version") == 0 ) {
 314                                         version();
 315                                         exit(0);
 316                                 }
 317                                 else {
 318                                         error() << "--" << pc.parameterArg <<
 319                                                         " is an invalid argument" << endl;
 320                                 }
 321
 322                         /* Passthrough args. */
 323                         case 'T':
 324                                 backendArgs.append( "-T" );
 325                                 backendArgs.append( pc.parameterArg );
 326                                 break;
 327                         case 'F':
 328                                 backendArgs.append( "-F" );
 329                                 backendArgs.append( pc.parameterArg );
 330                                 break;
 331                         case 'G':
 332                                 backendArgs.append( "-G" );
 333                                 backendArgs.append( pc.parameterArg );
 334                                 break;
 335                         case 'P':
 336                                 backendArgs.append( "-P" );
 337                                 backendArgs.append( pc.parameterArg );
 338                                 break;
 339                         case 'p':
 340                                 backendArgs.append( "-p" );
 341                                 break;
 342                         case 'L':
 343                                 backendArgs.append( "-L" );
 344                                 break;
 345                         }
 346                         break;
 347
 348                 case ParamCheck::invalid:
 349                         error() << "-" << pc.parameter << " is an invalid argument" << endl;
 350                         break;
 351
 352                 case ParamCheck::noparam:
 353                         /* It is interpreted as an input file. */
 354                         if ( *pc.curArg == 0 )
 355                                 error() << "a zero length input file name was given" << endl;
 356                         else if ( inputFileName != 0 )
 357                                 error() << "more than one input file name was given" << endl;
 358                         else {
 359                                 /* OK, Remember the filename. */
 360                                 inputFileName = pc.curArg;
 361                         }
 362                         break;
 363                 }
 364         }
 365 }
 366
 367 int frontend( char *inputFileName, char *outputFileName )
 368 {
 369         /* Open the input file for reading. */
 370         assert( inputFileName != 0 );
 371         ifstream *inFile = new ifstream( inputFileName );
 372         istream *inStream = inFile;
 373         if ( ! inFile->is_open() )
 374                 error() << "could not open " << inputFileName << " for reading" << endp;
 375
 376         /* Used for just a few things. */
 377         std::ostringstream hostData;
 378
 379         if ( machineSpec == 0 && machineName == 0 )
 380                 hostData << "<host line=\"1\" col=\"1\">";
 381
 382         Scanner scanner( inputFileName, *inStream, hostData, 0, 0, 0, false );
 383         scanner.do_scan();
 384
 385         /* Finished, final check for errors.. */
 386         if ( gblErrorCount > 0 )
 387                 return 1;
 388
 389         /* Now send EOF to all parsers. */
 390         terminateAllParsers();
 391
 392         /* Finished, final check for errors.. */
 393         if ( gblErrorCount > 0 )
 394                 return 1;
 395
 396         if ( machineSpec == 0 && machineName == 0 )
 397                 hostData << "</host>\n";
 398
 399         if ( gblErrorCount > 0 )
 400                 return 1;
 401
 402         ostream *outputFile = 0;
 403         if ( outputFileName != 0 )
 404                 outputFile = new ofstream( outputFileName );
 405         else
 406                 outputFile = &cout;
 407
 408         /* Write the machines, then the surrounding code. */
 409         writeMachines( *outputFile, hostData.str(), inputFileName );
 410
 411         /* Close the intermediate file. */
 412         if ( outputFileName != 0 )
 413                 delete outputFile;
 414
 415         return gblErrorCount > 0;
 416 }
 417
 418 char *makeIntermedTemplate( char *baseFileName )
 419 {
 420         char *result = 0;
 421         const char *templ = "ragel-XXXXXX.xml";
 422         char *lastSlash = strrchr( baseFileName, '/' );
 423         if ( lastSlash == 0 ) {
 424                 result = new char[strlen(templ)+1];
 425                 strcpy( result, templ );
 426         }
 427         else {
 428                 int baseLen = lastSlash - baseFileName + 1;
 429                 result = new char[baseLen + strlen(templ) + 1];
 430                 memcpy( result, baseFileName, baseLen );
 431                 strcpy( result+baseLen, templ );
 432         }
 433         return result;
 434 };
 435
 436 char *openIntermed( char *inputFileName, char *outputFileName )
 437 {
 438         srand(time(0));
 439         char *result = 0;
 440
 441         /* Which filename do we use as the base? */
 442         char *baseFileName = outputFileName != 0 ? outputFileName : inputFileName;
 443
 444         /* The template for the intermediate file name. */
 445         char *intermedFileName = makeIntermedTemplate( baseFileName );
 446
 447         /* Randomize the name and try to open. */
 448         char fnChars[] = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 449         char *firstX = strrchr( intermedFileName, 'X' ) - 5;
 450         for ( int tries = 0; tries < 20; tries++ ) {
 451                 /* Choose a random name. */
 452                 for ( int x = 0; x < 6; x++ )
 453                         firstX[x] = fnChars[rand() % 52];
 454
 455                 /* Try to open the file. */
 456                 int fd = ::open( intermedFileName, O_WRONLY|O_EXCL|O_CREAT, S_IRUSR|S_IWUSR );
 457
 458                 if ( fd > 0 ) {
 459                         /* Success. Close the file immediately and return the name for use
 460                          * by the child processes. */
 461                         ::close( fd );
 462                         result = intermedFileName;
 463                         break;
 464                 }
 465
 466                 if ( errno == EACCES ) {
 467                         error() << "failed to open temp file " << intermedFileName <<
 468                                         ", access denied" << endp;
 469                 }
 470         }
 471
 472         if ( result == 0 )
 473                 error() << "abnormal error: cannot find unique name for temp file" << endp;
 474
 475         return result;
 476 }
 477
 478
 479 void cleanExit( char *intermed, int status )
 480 {
 481         unlink( intermed );
 482         exit( status );
 483 }
 484
 485 #ifndef WIN32
 486
 487 /* If any forward slash is found in argv0 then it is assumed that the path is
 488  * explicit and the path to the backend executable should be derived from
 489  * that. Whe check that location and also go up one then inside a directory of
 490  * the same name in case we are executing from the source tree. If no forward
 491  * slash is found it is assumed the file is being run from the installed
 492  * location. The PREFIX supplied during configuration is used. */
 493 char **makePathChecksUnix( const char *argv0, const char *progName )
 494 {
 495         char **result = new char*[3];
 496         const char *lastSlash = strrchr( argv0, '/' );
 497         int numChecks = 0;
 498
 499         if ( lastSlash != 0 ) {
 500                 char *path = strdup( argv0 );
 501                 int givenPathLen = (lastSlash - argv0) + 1;
 502                 path[givenPathLen] = 0;
 503
 504                 int progNameLen = strlen(progName);
 505                 int length = givenPathLen + progNameLen + 1;
 506                 char *check = new char[length];
 507                 sprintf( check, "%s%s", path, progName );
 508                 result[numChecks++] = check;
 509
 510                 length = givenPathLen + 3 + progNameLen + 1 + progNameLen + 1;
 511                 check = new char[length];
 512                 sprintf( check, "%s../%s/%s", path, progName, progName );
 513                 result[numChecks++] = check;
 514         }
 515         else {
 516                 int prefixLen = strlen(PREFIX);
 517                 int progNameLen = strlen(progName);
 518                 int length = prefixLen + 5 + progNameLen + 1;
 519                 char *check = new char[length];
 520
 521                 sprintf( check, PREFIX "/bin/%s", progName );
 522                 result[numChecks++] = check;
 523         }
 524
 525         result[numChecks] = 0;
 526         return result;
 527 }
 528
 529
 530 void forkAndExec( const char *progName, char **pathChecks,
 531                 ArgsVector &args, char *intermed )
 532 {
 533         pid_t pid = fork();
 534         if ( pid < 0 ) {
 535                 /* Error, no child created. */
 536                 error() << "failed to fork for " << progName << endl;
 537                 cleanExit( intermed, 1 );
 538         }
 539         else if ( pid == 0 ) {
 540                 /* child */
 541                 while ( *pathChecks != 0 ) {
 542                         /* Execv does not modify argv, it just uses the const form that is
 543                          * compatible with the most code. Ours not included. */
 544                         execv( *pathChecks, (char *const*) args.data );
 545                         pathChecks += 1;
 546                 }
 547                 error() << "failed to exec " << progName << endl;
 548                 cleanExit( intermed, 1 );
 549         }
 550
 551         /* Parent process, wait for the child. */
 552         int status;
 553         wait( &status );
 554
 555         /* What happened with the child. */
 556         if ( ! WIFEXITED( status ) ) {
 557                 error() << progName << " did not exit normally" << endl;
 558                 cleanExit( intermed, 1 );
 559         }
 560
 561         if ( WEXITSTATUS(status) != 0 )
 562                 cleanExit( intermed, WEXITSTATUS(status) );
 563 }
 564
 565 #else
 566
 567 /* GetModuleFileNameEx is used to find out where the the current process's
 568  * binary is. That location is searched first. If that fails then we go up one
 569  * directory and look for the executable inside a directory of the same name
 570  * in case we are executing from the source tree.
 571  * */
 572 char **makePathChecksWin( const char *progName )
 573 {
 574         int len = 1024;
 575         char *imageFileName = new char[len];
 576         HANDLE h = GetCurrentProcess();
 577         len = GetModuleFileNameEx( h, NULL, imageFileName, len );
 578         imageFileName[len] = 0;
 579
 580         char **result = new char*[3];
 581         const char *lastSlash = strrchr( imageFileName, '\\' );
 582         int numChecks = 0;
 583
 584         assert( lastSlash != 0 );
 585         char *path = strdup( imageFileName );
 586         int givenPathLen = (lastSlash - imageFileName) + 1;
 587         path[givenPathLen] = 0;
 588
 589         int progNameLen = strlen(progName);
 590         int length = givenPathLen + progNameLen + 1;
 591         char *check = new char[length];
 592         sprintf( check, "%s%s", path, progName );
 593         result[numChecks++] = check;
 594
 595         length = givenPathLen + 3 + progNameLen + 1 + progNameLen + 1;
 596         check = new char[length];
 597         sprintf( check, "%s..\\%s\\%s", path, progName, progName );
 598         result[numChecks++] = check;
 599
 600         result[numChecks] = 0;
 601         return result;
 602 }
 603
 604 void spawn( const char *progName, char **pathChecks,
 605                 ArgsVector &args, char *intermed )
 606 {
 607         int result = 0;
 608         while ( *pathChecks != 0 ) {
 609                 //cerr << "trying to execute " << *pathChecks << endl;
 610                 result = _spawnv( _P_WAIT, *pathChecks, args.data );
 611                 if ( result >= 0 || errno != ENOENT )
 612                         break;
 613                 pathChecks += 1;
 614         }
 615
 616         if ( result < 0 ) {
 617                 error() << "failed to spawn " << progName << endl;
 618                 cleanExit( intermed, 1 );
 619         }
 620
 621         if ( result > 0 )
 622                 cleanExit( intermed, 1 );
 623 }
 624
 625 #endif
 626
 627 void execFrontend( const char *argv0, char *inputFileName, char *intermed )
 628 {
 629         /* The frontend program name. */
 630         const char *progName = "ragel";
 631
 632         frontendArgs.insert( 0, progName );
 633         frontendArgs.insert( 1, "-x" );
 634         frontendArgs.append( "-o" );
 635         frontendArgs.append( intermed );
 636         frontendArgs.append( inputFileName );
 637         frontendArgs.append( 0 );
 638
 639 #ifndef WIN32
 640         char **pathChecks = makePathChecksUnix( argv0, progName );
 641         forkAndExec( progName, pathChecks, frontendArgs, intermed );
 642 #else
 643         char **pathChecks = makePathChecksWin( progName );
 644         spawn( progName, pathChecks, frontendArgs, intermed );
 645 #endif
 646 }
 647
 648 void execBackend( const char *argv0, char *intermed, char *outputFileName )
 649 {
 650         /* Locate the backend program */
 651         const char *progName = 0;
 652         if ( generateDot )
 653                 progName = "rlgen-dot";
 654         else {
 655                 switch ( hostLang->lang ) {
 656                         case HostLang::C:
 657                         case HostLang::D:
 658                                 progName = "rlgen-cd";
 659                                 break;
 660                         case HostLang::Java:
 661                                 progName = "rlgen-java";
 662                                 break;
 663                         case HostLang::Ruby:
 664                                 progName = "rlgen-ruby";
 665                                 break;
 666                         case HostLang::CSharp:
 667                                 progName = "rlgen-csharp";
 668                 }
 669         }
 670
 671         backendArgs.insert( 0, progName );
 672         if ( outputFileName != 0 ) {
 673                 backendArgs.append( "-o" );
 674                 backendArgs.append( outputFileName );
 675         }
 676         backendArgs.append( intermed );
 677         backendArgs.append( 0 );
 678
 679 #ifndef WIN32
 680         char **pathChecks = makePathChecksUnix( argv0, progName );
 681         forkAndExec( progName, pathChecks, backendArgs, intermed );
 682 #else
 683         char **pathChecks = makePathChecksWin( progName );
 684         spawn( progName, pathChecks, backendArgs, intermed );
 685 #endif
 686 }
 687
 688 /* Main, process args and call yyparse to start scanning input. */
 689 int main(int argc, char **argv)
 690 {
 691         char *inputFileName = 0;
 692         char *outputFileName = 0;
 693
 694         processArgs( argc, argv, inputFileName, outputFileName );
 695
 696         /* If -M or -S are given and we're not generating a dot file then invoke
 697          * the frontend. These options are not useful with code generators. */
 698         if ( machineName != 0 || machineSpec != 0 ) {
 699                 if ( !generateDot )
 700                         frontendOnly = true;
 701         }
 702
 703         /* Require an input file. If we use standard in then we won't have a file
 704          * name on which to base the output. */
 705         if ( inputFileName == 0 )
 706                 error() << "no input file given" << endl;
 707
 708         /* Bail on argument processing errors. */
 709         if ( gblErrorCount > 0 )
 710                 exit(1);
 711
 712         /* Make sure we are not writing to the same file as the input file. */
 713         if ( inputFileName != 0 && outputFileName != 0 &&
 714                         strcmp( inputFileName, outputFileName  ) == 0 )
 715         {
 716                 error() << "output file \"" << outputFileName  <<
 717                                 "\" is the same as the input file" << endp;
 718         }
 719
 720         if ( frontendOnly )
 721                 return frontend( inputFileName, outputFileName );
 722
 723         char *intermed = openIntermed( inputFileName, outputFileName );
 724
 725         /* From here on in the cleanExit function should be used to exit. */
 726
 727         /* Run the frontend, then the backend processes. */
 728         execFrontend( argv[0], inputFileName, intermed );
 729         execBackend( argv[0], intermed, outputFileName );
 730
 731         /* Clean up the intermediate. */
 732         cleanExit( intermed, 0 );
 733
 734         return 0;
 735 }