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
  71 bool printStatistics = false;
  72 bool frontendOnly = false;
  73
  74 typedef Vector<char*> ArgsVector;
  75 ArgsVector frontendArgs;
  76 ArgsVector backendArgs;
  77
  78 /* Print a summary of the options. */
  79 void usage()
  80 {
  81         cout <<
  82 "usage: ragel [options] file\n"
  83 "general:\n"
  84 "   -h, -H, -?, --help   Print this usage and exit\n"
  85 "   -v, --version        Print version information and exit\n"
  86 "   -o <file>            Write output to <file>\n"
  87 "   -s                   Print some statistics on stderr\n"
  88 "fsm minimization:\n"
  89 "   -n                   Do not perform minimization\n"
  90 "   -m                   Minimize at the end of the compilation\n"
  91 "   -l                   Minimize after most operations (default)\n"
  92 "   -e                   Minimize after every operation\n"
  93 "machine selection:\n"
  94 "   -S <spec>            FSM specification to output (for rlgen-dot)\n"
  95 "   -M <machine>         Machine definition/instantiation to output (for rlgen-dot)\n"
  96 "host language:\n"
  97 "   -C                   The host language is C, C++, Obj-C or Obj-C++ (default)\n"
  98 "   -D                   The host language is D\n"
  99 "   -J                   The host language is Java\n"
 100 "   -R                   The host language is Ruby\n"
 101         ;
 102 }
 103
 104 /* Print version information. */
 105 void version()
 106 {
 107         cout << "Ragel State Machine Compiler version " VERSION << " " PUBDATE << endl <<
 108                         "Copyright (c) 2001-2007 by Adrian Thurston" << endl;
 109 }
 110
 111 /* Total error count. */
 112 int gblErrorCount = 0;
 113
 114 /* Print the opening to a warning in the input, then return the error ostream. */
 115 ostream &warning( const InputLoc &loc )
 116 {
 117         assert( loc.fileName != 0 );
 118         cerr << loc.fileName << ":" << loc.line << ":" <<
 119                         loc.col << ": warning: ";
 120         return cerr;
 121 }
 122
 123 /* Print the opening to a program error, then return the error stream. */
 124 ostream &error()
 125 {
 126         gblErrorCount += 1;
 127         cerr << PROGNAME ": ";
 128         return cerr;
 129 }
 130
 131 ostream &error( const InputLoc &loc )
 132 {
 133         gblErrorCount += 1;
 134         assert( loc.fileName != 0 );
 135         cerr << loc.fileName << ":" << loc.line << ": ";
 136         return cerr;
 137 }
 138
 139 void escapeLineDirectivePath( std::ostream &out, char *path )
 140 {
 141         for ( char *pc = path; *pc != 0; pc++ ) {
 142                 if ( *pc == '\\' )
 143                         out << "\\\\";
 144                 else
 145                         out << *pc;
 146         }
 147 }
 148
 149 void processArgs( int argc, char **argv, char *&inputFileName, char *&outputFileName )
 150 {
 151         ParamCheck pc("fo:nmleabjkS:M:CDJRvHh?-:sT:F:G:P:Lp", argc, argv);
 152
 153         while ( pc.check() ) {
 154                 switch ( pc.state ) {
 155                 case ParamCheck::match:
 156                         switch ( pc.parameter ) {
 157                         case 'f':
 158                                 frontendOnly = true;
 159                                 break;
 160
 161                         /* Output. */
 162                         case 'o':
 163                                 if ( *pc.parameterArg == 0 )
 164                                         error() << "a zero length output file name was given" << endl;
 165                                 else if ( outputFileName != 0 )
 166                                         error() << "more than one output file name was given" << endl;
 167                                 else {
 168                                         /* Ok, remember the output file name. */
 169                                         outputFileName = pc.parameterArg;
 170                                 }
 171                                 break;
 172
 173                         /* Minimization, mostly hidden options. */
 174                         case 'n':
 175                                 minimizeOpt = MinimizeNone;
 176                                 frontendArgs.append( "-n" );
 177                                 break;
 178                         case 'm':
 179                                 minimizeOpt = MinimizeEnd;
 180                                 frontendArgs.append( "-m" );
 181                                 break;
 182                         case 'l':
 183                                 minimizeOpt = MinimizeMostOps;
 184                                 frontendArgs.append( "-l" );
 185                                 break;
 186                         case 'e':
 187                                 minimizeOpt = MinimizeEveryOp;
 188                                 frontendArgs.append( "-e" );
 189                                 break;
 190                         case 'a':
 191                                 minimizeLevel = MinimizeApprox;
 192                                 frontendArgs.append( "-a" );
 193                                 break;
 194                         case 'b':
 195                                 minimizeLevel = MinimizeStable;
 196                                 frontendArgs.append( "-b" );
 197                                 break;
 198                         case 'j':
 199                                 minimizeLevel = MinimizePartition1;
 200                                 frontendArgs.append( "-j" );
 201                                 break;
 202                         case 'k':
 203                                 minimizeLevel = MinimizePartition2;
 204                                 frontendArgs.append( "-k" );
 205                                 break;
 206
 207                         /* Machine spec. */
 208                         case 'S':
 209                                 if ( *pc.parameterArg == 0 )
 210                                         error() << "please specify an argument to -S" << endl;
 211                                 else if ( machineSpec != 0 )
 212                                         error() << "more than one -S argument was given" << endl;
 213                                 else {
 214                                         /* Ok, remember the path to the machine to generate. */
 215                                         machineSpec = pc.parameterArg;
 216                                         frontendArgs.append( "-S" );
 217                                         frontendArgs.append( pc.parameterArg );
 218                                 }
 219                                 break;
 220
 221                         /* Machine path. */
 222                         case 'M':
 223                                 if ( *pc.parameterArg == 0 )
 224                                         error() << "please specify an argument to -M" << endl;
 225                                 else if ( machineName != 0 )
 226                                         error() << "more than one -M argument was given" << endl;
 227                                 else {
 228                                         /* Ok, remember the machine name to generate. */
 229                                         machineName = pc.parameterArg;
 230                                         frontendArgs.append( "-M" );
 231                                         frontendArgs.append( pc.parameterArg );
 232                                 }
 233                                 break;
 234
 235                         /* Host language types. */
 236                         case 'C':
 237                                 hostLang = &hostLangC;
 238                                 frontendArgs.append( "-C" );
 239                                 break;
 240                         case 'D':
 241                                 hostLang = &hostLangD;
 242                                 frontendArgs.append( "-D" );
 243                                 break;
 244                         case 'J':
 245                                 hostLang = &hostLangJava;
 246                                 frontendArgs.append( "-J" );
 247                                 break;
 248                         case 'R':
 249                                 hostLang = &hostLangRuby;
 250                                 frontendArgs.append( "-R" );
 251                                 break;
 252
 253                         /* Version and help. */
 254                         case 'v':
 255                                 version();
 256                                 exit(0);
 257                         case 'H': case 'h': case '?':
 258                                 usage();
 259                                 exit(0);
 260                         case 's':
 261                                 printStatistics = true;
 262                                 frontendArgs.append( "-s" );
 263                                 break;
 264                         case '-':
 265                                 if ( strcasecmp(pc.parameterArg, "help") == 0 ) {
 266                                         usage();
 267                                         exit(0);
 268                                 }
 269                                 else if ( strcasecmp(pc.parameterArg, "version") == 0 ) {
 270                                         version();
 271                                         exit(0);
 272                                 }
 273                                 else {
 274                                         error() << "--" << pc.parameterArg <<
 275                                                         " is an invalid argument" << endl;
 276                                 }
 277
 278                         /* Passthrough args. */
 279                         case 'T':
 280                                 backendArgs.append( "-T" );
 281                                 backendArgs.append( pc.parameterArg );
 282                                 break;
 283                         case 'F':
 284                                 backendArgs.append( "-F" );
 285                                 backendArgs.append( pc.parameterArg );
 286                                 break;
 287                         case 'G':
 288                                 backendArgs.append( "-G" );
 289                                 backendArgs.append( pc.parameterArg );
 290                                 break;
 291                         case 'P':
 292                                 backendArgs.append( "-P" );
 293                                 backendArgs.append( pc.parameterArg );
 294                                 break;
 295                         case 'p':
 296                                 backendArgs.append( "-p" );
 297                                 break;
 298                         case 'L':
 299                                 backendArgs.append( "-L" );
 300                                 break;
 301                         }
 302                         break;
 303
 304                 case ParamCheck::invalid:
 305                         error() << "-" << pc.parameter << " is an invalid argument" << endl;
 306                         break;
 307
 308                 case ParamCheck::noparam:
 309                         /* It is interpreted as an input file. */
 310                         if ( *pc.curArg == 0 )
 311                                 error() << "a zero length input file name was given" << endl;
 312                         else if ( inputFileName != 0 )
 313                                 error() << "more than one input file name was given" << endl;
 314                         else {
 315                                 /* OK, Remember the filename. */
 316                                 inputFileName = pc.curArg;
 317                         }
 318                         break;
 319                 }
 320         }
 321 }
 322
 323 int frontend( char *inputFileName, char *outputFileName )
 324 {
 325         /* Open the input file for reading. */
 326         istream *inStream;
 327         if ( inputFileName != 0 ) {
 328                 /* Open the input file for reading. */
 329                 ifstream *inFile = new ifstream( inputFileName );
 330                 inStream = inFile;
 331                 if ( ! inFile->is_open() )
 332                         error() << "could not open " << inputFileName << " for reading" << endp;
 333         }
 334         else {
 335                 inputFileName = "<stdin>";
 336                 inStream = &cin;
 337         }
 338
 339         /* Used for just a few things. */
 340         std::ostringstream hostData;
 341
 342         if ( machineSpec == 0 && machineName == 0 )
 343                 hostData << "<host line=\"1\" col=\"1\">";
 344
 345         Scanner scanner( inputFileName, *inStream, hostData, 0, 0, 0, false );
 346         scanner.do_scan();
 347
 348         /* Finished, final check for errors.. */
 349         if ( gblErrorCount > 0 )
 350                 return 1;
 351
 352         /* Now send EOF to all parsers. */
 353         terminateAllParsers();
 354
 355         /* Finished, final check for errors.. */
 356         if ( gblErrorCount > 0 )
 357                 return 1;
 358
 359         if ( machineSpec == 0 && machineName == 0 )
 360                 hostData << "</host>\n";
 361
 362         if ( gblErrorCount > 0 )
 363                 return 1;
 364
 365         ostream *outputFile = 0;
 366         if ( outputFileName != 0 )
 367                 outputFile = new ofstream( outputFileName );
 368         else
 369                 outputFile = &cout;
 370
 371         /* Write the machines, then the surrounding code. */
 372         writeMachines( *outputFile, hostData.str(), inputFileName );
 373
 374         /* Close the intermediate file. */
 375         if ( outputFileName != 0 )
 376                 delete outputFile;
 377
 378         return gblErrorCount > 0;
 379 }
 380
 381 char *makeIntermedTemplate( char *baseFileName )
 382 {
 383         char *result = 0, *templ = "ragel-XXXXXX.xml";
 384         char *lastSlash = strrchr( baseFileName, '/' );
 385         if ( lastSlash == 0 ) {
 386                 result = new char[strlen(templ)+1];
 387                 strcpy( result, templ );
 388         }
 389         else {
 390                 int baseLen = lastSlash - baseFileName + 1;
 391                 result = new char[baseLen + strlen(templ) + 1];
 392                 memcpy( result, baseFileName, baseLen );
 393                 strcpy( result+baseLen, templ );
 394         }
 395         return result;
 396 };
 397
 398 char *openIntermed( char *inputFileName, char *outputFileName )
 399 {
 400         srand(time(0));
 401         char *result = 0;
 402
 403         /* Which filename do we use as the base? */
 404         char *baseFileName = outputFileName != 0 ? outputFileName : inputFileName;
 405
 406         /* The template for the intermediate file name. */
 407         char *intermedFileName = makeIntermedTemplate( baseFileName );
 408
 409         /* Randomize the name and try to open. */
 410         char fnChars[] = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 411         char *firstX = strrchr( intermedFileName, 'X' ) - 5;
 412         for ( int tries = 0; tries < 20; tries++ ) {
 413                 /* Choose a random name. */
 414                 for ( int x = 0; x < 6; x++ )
 415                         firstX[x] = fnChars[rand() % 52];
 416
 417                 /* Try to open the file. */
 418                 int fd = ::open( intermedFileName, O_WRONLY|O_EXCL|O_CREAT, S_IRUSR|S_IWUSR );
 419
 420                 if ( fd > 0 ) {
 421                         /* Success. Close the file immediately and return the name for use
 422                          * by the child processes. */
 423                         ::close( fd );
 424                         result = intermedFileName;
 425                         break;
 426                 }
 427
 428                 if ( errno == EACCES ) {
 429                         error() << "failed to open temp file " << intermedFileName <<
 430                                         ", access denied" << endp;
 431                 }
 432         }
 433
 434         if ( result == 0 )
 435                 error() << "abnormal error: cannot find unique name for temp file" << endp;
 436
 437         return result;
 438 }
 439
 440
 441 void cleanExit( char *intermed, int status )
 442 {
 443         unlink( intermed );
 444         exit( status );
 445 }
 446
 447 #ifndef WIN32
 448
 449 /* If any forward slash is found in argv0 then it is assumed that the path is
 450  * explicit and the path to the backend executable should be derived from
 451  * that. If no forward slash is found it is assumed the file is being run from
 452  * the installed location. The PREFIX supplied during configuration is used.
 453  * */
 454 char **makePathChecksUnix( const char *argv0, const char *progName )
 455 {
 456         char **result = new char*[3];
 457         const char *lastSlash = strrchr( argv0, '/' );
 458         int numChecks = 0;
 459
 460         if ( lastSlash != 0 ) {
 461                 char *path = strdup( argv0 );
 462                 int givenPathLen = (lastSlash - argv0) + 1;
 463                 path[givenPathLen] = 0;
 464
 465                 int progNameLen = strlen(progName);
 466                 int length = givenPathLen + progNameLen + 1;
 467                 char *check = new char[length];
 468                 sprintf( check, "%s%s", path, progName );
 469                 result[numChecks++] = check;
 470
 471                 length = givenPathLen + 3 + progNameLen + 1 + progNameLen + 1;
 472                 check = new char[length];
 473                 sprintf( check, "%s../%s/%s", path, progName, progName );
 474                 result[numChecks++] = check;
 475         }
 476         else {
 477                 int prefixLen = strlen(PREFIX);
 478                 int progNameLen = strlen(progName);
 479                 int length = prefixLen + 5 + progNameLen + 1;
 480                 char *check = new char[length];
 481
 482                 sprintf( check, PREFIX "/bin/%s", progName );
 483                 result[numChecks++] = check;
 484         }
 485
 486         result[numChecks] = 0;
 487         return result;
 488 }
 489
 490
 491 int forkAndExec( char *progName, char **pathChecks,
 492                 ArgsVector &args, char *intermed )
 493 {
 494         pid_t pid = fork();
 495         if ( pid < 0 ) {
 496                 /* Error, no child created. */
 497                 error() << "failed to fork for " << progName << endl;
 498                 cleanExit( intermed, 1 );
 499         }
 500         else if ( pid == 0 ) {
 501                 /* child */
 502                 while ( *pathChecks != 0 ) {
 503                         execv( *pathChecks, args.data );
 504                         pathChecks += 1;
 505                 }
 506                 error() << "failed to exec " << progName << endl;
 507                 cleanExit( intermed, 1 );
 508         }
 509
 510         /* Parent process, wait for the child. */
 511         int status;
 512         wait( &status );
 513
 514         /* What happened with the child. */
 515         if ( ! WIFEXITED( status ) ) {
 516                 error() << progName << " did not exit normally" << endl;
 517                 cleanExit( intermed, 1 );
 518         }
 519
 520         if ( WEXITSTATUS(status) != 0 )
 521                 cleanExit( intermed, WEXITSTATUS(status) );
 522
 523         return status;
 524 }
 525
 526 #else
 527
 528 /* If any forward slash is found in argv0 then it is assumed that the path is
 529  * explicit and the path to the backend executable should be derived from
 530  * that. If no forward slash is found it is assumed the file is being run from
 531  * the installed location. The PREFIX supplied during configuration is used.
 532  * */
 533 char **makePathChecksWin( const char *progName )
 534 {
 535         int len = 1024;
 536         char *imageFileName = new char[len];
 537         HANDLE h = GetCurrentProcess();
 538         len = GetModuleFileNameEx( h, NULL, imageFileName, len );
 539         imageFileName[len] = 0;
 540
 541         char **result = new char*[3];
 542         const char *lastSlash = strrchr( imageFileName, '\\' );
 543         int numChecks = 0;
 544
 545         assert( lastSlash != 0 );
 546         char *path = strdup( imageFileName );
 547         int givenPathLen = (lastSlash - imageFileName) + 1;
 548         path[givenPathLen] = 0;
 549
 550         int progNameLen = strlen(progName);
 551         int length = givenPathLen + progNameLen + 1;
 552         char *check = new char[length];
 553         sprintf( check, "%s%s", path, progName );
 554         result[numChecks++] = check;
 555
 556         length = givenPathLen + 3 + progNameLen + 1 + progNameLen + 1;
 557         check = new char[length];
 558         sprintf( check, "%s..\\%s\\%s", path, progName, progName );
 559         result[numChecks++] = check;
 560
 561         result[numChecks] = 0;
 562         return result;
 563 }
 564
 565 #endif
 566
 567 void execFrontend( const char *argv0, char *inputFileName, char *intermed )
 568 {
 569         /* The frontend program name. */
 570         char *progName = "ragel";
 571
 572         frontendArgs.insert( 0, progName );
 573         frontendArgs.insert( 1, "-f" );
 574         frontendArgs.append( "-o" );
 575         frontendArgs.append( intermed );
 576         frontendArgs.append( inputFileName );
 577         frontendArgs.append( 0 );
 578
 579 #ifndef WIN32
 580         char **pathChecks = makePathChecksUnix( argv0, progName );
 581         forkAndExec( progName, pathChecks, frontendArgs, intermed );
 582 #else
 583         char **pathChecks = makePathChecksWin( progName );
 584         while ( *pathChecks != 0 )
 585                 cerr << *pathChecks++ << endl;
 586 #endif
 587 }
 588
 589 void execBackend( const char *argv0, char *intermed, char *outputFileName )
 590 {
 591         /* Locate the backend program */
 592         char *progName = 0;
 593         switch ( hostLang->lang ) {
 594                 case HostLang::C:
 595                 case HostLang::D:
 596                         progName = "rlgen-cd";
 597                         break;
 598                 case HostLang::Java:
 599                         progName = "rlgen-java";
 600                         break;
 601                 case HostLang::Ruby:
 602                         progName = "rlgen-ruby";
 603                         break;
 604         }
 605
 606         backendArgs.insert( 0, progName );
 607         if ( outputFileName != 0 ) {
 608                 backendArgs.append( "-o" );
 609                 backendArgs.append( outputFileName );
 610         }
 611         backendArgs.append( intermed );
 612         backendArgs.append( 0 );
 613
 614 #ifndef WIN32
 615         char **pathChecks = makePathChecksUnix( argv0, progName );
 616         forkAndExec( progName, pathChecks, backendArgs, intermed );
 617 #else
 618         char **pathChecks = makePathChecksWin( progName );
 619         while ( *pathChecks != 0 )
 620                 cerr << *pathChecks++ << endl;
 621 #endif
 622 }
 623
 624 /* Main, process args and call yyparse to start scanning input. */
 625 int main(int argc, char **argv)
 626 {
 627         char *inputFileName = 0;
 628         char *outputFileName = 0;
 629
 630         processArgs( argc, argv, inputFileName, outputFileName );
 631
 632         /* Bail on above errors. */
 633         if ( gblErrorCount > 0 )
 634                 exit(1);
 635
 636         /* Make sure we are not writing to the same file as the input file. */
 637         if ( inputFileName != 0 && outputFileName != 0 &&
 638                         strcmp( inputFileName, outputFileName  ) == 0 )
 639         {
 640                 error() << "output file \"" << outputFileName  <<
 641                                 "\" is the same as the input file" << endp;
 642         }
 643
 644         if ( frontendOnly )
 645                 return frontend( inputFileName, outputFileName );
 646
 647         char *intermed = openIntermed( inputFileName, outputFileName );
 648
 649         /* Run the frontend, then the backend processes. */
 650         execFrontend( argv[0], inputFileName, intermed );
 651         execBackend( argv[0], intermed, outputFileName );
 652
 653         /* Clean up the intermediate. */
 654         cleanExit( intermed, 0 );
 655
 656         return 0;
 657 }