The XML parser and scanner are now created in ragel/main.cpp. These structures
[external/ragel.git] / 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 #ifdef _WIN32
36 #include <windows.h>
37 #include <psapi.h>
38 #include <time.h>
39 #include <io.h>
40 #include <process.h>
41
42 #if _MSC_VER
43 #define S_IRUSR _S_IREAD
44 #define S_IWUSR _S_IWRITE
45 #endif
46 #endif
47
48 /* Parsing. */
49 #include "ragel.h"
50 #include "rlscan.h"
51
52 /* Parameters and output. */
53 #include "pcheck.h"
54 #include "vector.h"
55 #include "version.h"
56 #include "common.h"
57 #include "xmlparse.h"
58
59 using std::istream;
60 using std::ostream;
61 using std::ifstream;
62 using std::ofstream;
63 using std::cin;
64 using std::cout;
65 using std::cerr;
66 using std::endl;
67 using std::ios;
68 using std::streamsize;
69
70 /* Controls minimization. */
71 MinimizeLevel minimizeLevel = MinimizePartition2;
72 MinimizeOpt minimizeOpt = MinimizeMostOps;
73
74 /* Graphviz dot file generation. */
75 const char *machineSpec = 0, *machineName = 0;
76 bool machineSpecFound = false;
77 bool wantDupsRemoved = true;
78
79 bool printStatistics = false;
80 bool frontendOnly = false;
81 bool generateDot = false;
82
83 /* Target language and output style. */
84 CodeStyleEnum codeStyle = GenTables;
85
86 int numSplitPartitions = 0;
87 bool noLineDirectives = false;
88
89 bool displayPrintables = false;
90 bool graphvizDone = false;
91
92 /* Target ruby impl */
93 RubyImplEnum rubyImpl = MRI;
94
95 ArgsVector includePaths;
96
97 istream *inStream = 0;
98 ostream *outStream = 0;
99 output_filter *outFilter = 0;
100 const char *outputFileName = 0;
101
102 /* Print a summary of the options. */
103 void usage()
104 {
105         cout <<
106 "usage: ragel [options] file\n"
107 "general:\n"
108 "   -h, -H, -?, --help   Print this usage and exit\n"
109 "   -v, --version        Print version information and exit\n"
110 "   -o <file>            Write output to <file>\n"
111 "   -s                   Print some statistics on stderr\n"
112 "   -d                   Do not remove duplicates from action lists\n"
113 "   -I <dir>             Add <dir> to the list of directories to search\n"
114 "                        for included an imported files\n"
115 "error reporting format:\n"
116 "   --error-format=gnu   file:line:column: message (default)\n"
117 "   --error-format=msvc  file(line,column): message\n"
118 "fsm minimization:\n"
119 "   -n                   Do not perform minimization\n"
120 "   -m                   Minimize at the end of the compilation\n"
121 "   -l                   Minimize after most operations (default)\n"
122 "   -e                   Minimize after every operation\n"
123 "visualization:\n"
124 "   -x                   Run the frontend only: emit XML intermediate format\n"
125 "   -V                   Generate a dot file for Graphviz\n"
126 "   -p                   Display printable characters on labels\n"
127 "   -S <spec>            FSM specification to output (for rlgen-dot)\n"
128 "   -M <machine>         Machine definition/instantiation to output (for rlgen-dot)\n"
129 "host language:\n"
130 "   -C                   The host language is C, C++, Obj-C or Obj-C++ (default)\n"
131 "   -D                   The host language is D\n"
132 "   -J                   The host language is Java\n"
133 "   -R                   The host language is Ruby\n"
134 "   -A                   The host language is C#\n"
135 "line direcives: (C/D/C# only)\n"
136 "   -L                   Inhibit writing of #line directives\n"
137 "code style: (C/Ruby/C# only)\n"
138 "   -T0                  Table driven FSM (default)\n"
139 "   -T1                  Faster table driven FSM\n"
140 "   -F0                  Flat table driven FSM\n"
141 "   -F1                  Faster flat table-driven FSM\n"
142 "code style: (C/C# only)\n"
143 "   -G0                  Goto-driven FSM\n"
144 "   -G1                  Faster goto-driven FSM\n"
145 "code style: (C only)\n"
146 "   -G2                  Really fast goto-driven FSM\n"
147 "   -P<N>                N-Way Split really fast goto-driven FSM\n"
148         ;       
149
150         exit(0);
151 }
152
153 /* Print version information and exit. */
154 void version()
155 {
156         cout << "Ragel State Machine Compiler version " VERSION << " " PUBDATE << endl <<
157                         "Copyright (c) 2001-2007 by Adrian Thurston" << endl;
158         exit(0);
159 }
160
161 /* Error reporting format. */
162 ErrorFormat errorFormat = ErrorFormatGNU;
163
164 InputLoc makeInputLoc( const char *fileName, int line, int col)
165 {
166         InputLoc loc = { fileName, line, col };
167         return loc;
168 }
169
170 ostream &operator<<( ostream &out, const InputLoc &loc )
171 {
172         assert( loc.fileName != 0 );
173         switch ( errorFormat ) {
174         case ErrorFormatMSVC:
175                 out << loc.fileName << "(" << loc.line;
176                 if ( loc.col )
177                         out << "," << loc.col;
178                 out << ")";
179                 break;
180
181         default:
182                 out << loc.fileName << ":" << loc.line;
183                 if ( loc.col )
184                         out << ":" << loc.col;
185                 break;
186         }
187         return out;
188 }
189
190 /* Total error count. */
191 int gblErrorCount = 0;
192
193 /* Print the opening to a warning in the input, then return the error ostream. */
194 ostream &warning( const InputLoc &loc )
195 {
196         cerr << loc << ": warning: ";
197         return cerr;
198 }
199
200 /* Print the opening to a program error, then return the error stream. */
201 ostream &error()
202 {
203         gblErrorCount += 1;
204         cerr << PROGNAME ": ";
205         return cerr;
206 }
207
208 ostream &error( const InputLoc &loc )
209 {
210         gblErrorCount += 1;
211         cerr << loc << ": ";
212         return cerr;
213 }
214
215 void escapeLineDirectivePath( std::ostream &out, char *path )
216 {
217         for ( char *pc = path; *pc != 0; pc++ ) {
218                 if ( *pc == '\\' )
219                         out << "\\\\";
220                 else
221                         out << *pc;
222         }
223 }
224
225 void processArgs( int argc, const char **argv, const char *&inputFileName )
226 {
227         ParamCheck pc("xo:dnmleabjkS:M:I:CDJRAvHh?-:sT:F:G:P:LpV", argc, argv);
228
229         /* FIXME: Need to check code styles VS langauge. */
230
231         while ( pc.check() ) {
232                 switch ( pc.state ) {
233                 case ParamCheck::match:
234                         switch ( pc.parameter ) {
235                         case 'V':
236                                 generateDot = true;
237                                 break;
238
239                         case 'x':
240                                 frontendOnly = true;
241                                 break;
242
243                         /* Output. */
244                         case 'o':
245                                 if ( *pc.paramArg == 0 )
246                                         error() << "a zero length output file name was given" << endl;
247                                 else if ( outputFileName != 0 )
248                                         error() << "more than one output file name was given" << endl;
249                                 else {
250                                         /* Ok, remember the output file name. */
251                                         outputFileName = pc.paramArg;
252                                 }
253                                 break;
254
255                         /* Flag for turning off duplicate action removal. */
256                         case 'd':
257                                 wantDupsRemoved = false;
258                                 break;
259
260                         /* Minimization, mostly hidden options. */
261                         case 'n':
262                                 minimizeOpt = MinimizeNone;
263                                 break;
264                         case 'm':
265                                 minimizeOpt = MinimizeEnd;
266                                 break;
267                         case 'l':
268                                 minimizeOpt = MinimizeMostOps;
269                                 break;
270                         case 'e':
271                                 minimizeOpt = MinimizeEveryOp;
272                                 break;
273                         case 'a':
274                                 minimizeLevel = MinimizeApprox;
275                                 break;
276                         case 'b':
277                                 minimizeLevel = MinimizeStable;
278                                 break;
279                         case 'j':
280                                 minimizeLevel = MinimizePartition1;
281                                 break;
282                         case 'k':
283                                 minimizeLevel = MinimizePartition2;
284                                 break;
285
286                         /* Machine spec. */
287                         case 'S':
288                                 if ( *pc.paramArg == 0 )
289                                         error() << "please specify an argument to -S" << endl;
290                                 else if ( machineSpec != 0 )
291                                         error() << "more than one -S argument was given" << endl;
292                                 else {
293                                         /* Ok, remember the path to the machine to generate. */
294                                         machineSpec = pc.paramArg;
295                                 }
296                                 break;
297
298                         /* Machine path. */
299                         case 'M':
300                                 if ( *pc.paramArg == 0 )
301                                         error() << "please specify an argument to -M" << endl;
302                                 else if ( machineName != 0 )
303                                         error() << "more than one -M argument was given" << endl;
304                                 else {
305                                         /* Ok, remember the machine name to generate. */
306                                         machineName = pc.paramArg;
307                                 }
308                                 break;
309
310                         case 'I':
311                                 if ( *pc.paramArg == 0 )
312                                         error() << "please specify an argument to -I" << endl;
313                                 else {
314                                         includePaths.append( pc.paramArg );
315                                 }
316                                 break;
317
318                         /* Host language types. */
319                         case 'C':
320                                 hostLang = &hostLangC;
321                                 break;
322                         case 'D':
323                                 hostLang = &hostLangD;
324                                 break;
325                         case 'J':
326                                 hostLang = &hostLangJava;
327                                 break;
328                         case 'R':
329                                 hostLang = &hostLangRuby;
330                                 break;
331                         case 'A':
332                                 hostLang = &hostLangCSharp;
333                                 break;
334
335                         /* Version and help. */
336                         case 'v':
337                                 version();
338                                 break;
339                         case 'H': case 'h': case '?':
340                                 usage();
341                                 break;
342                         case 's':
343                                 printStatistics = true;
344                                 break;
345                         case '-': {
346                                 char *eq = strchr( pc.paramArg, '=' );
347
348                                 if ( eq != 0 )
349                                         *eq++ = 0;
350
351                                 if ( strcmp( pc.paramArg, "help" ) == 0 )
352                                         usage();
353                                 else if ( strcmp( pc.paramArg, "version" ) == 0 )
354                                         version();
355                                 else if ( strcmp( pc.paramArg, "error-format" ) == 0 ) {
356                                         if ( eq == 0 )
357                                                 error() << "expecting '=value' for error-format" << endl;
358                                         else if ( strcmp( eq, "gnu" ) == 0 )
359                                                 errorFormat = ErrorFormatGNU;
360                                         else if ( strcmp( eq, "msvc" ) == 0 )
361                                                 errorFormat = ErrorFormatMSVC;
362                                         else
363                                                 error() << "invalid value for error-format" << endl;
364                                 }
365                                 else if ( strcmp( pc.paramArg, "rbx" ) == 0 )
366                                         rubyImpl = Rubinius;
367                                 else {
368                                         error() << "--" << pc.paramArg << 
369                                                         " is an invalid argument" << endl;
370                                 }
371                                 break;
372                         }
373
374                         /* Passthrough args. */
375                         case 'T': 
376                                 if ( pc.paramArg[0] == '0' )
377                                         codeStyle = GenTables;
378                                 else if ( pc.paramArg[0] == '1' )
379                                         codeStyle = GenFTables;
380                                 else {
381                                         error() << "-T" << pc.paramArg[0] << 
382                                                         " is an invalid argument" << endl;
383                                         exit(1);
384                                 }
385                                 break;
386                         case 'F': 
387                                 if ( pc.paramArg[0] == '0' )
388                                         codeStyle = GenFlat;
389                                 else if ( pc.paramArg[0] == '1' )
390                                         codeStyle = GenFFlat;
391                                 else {
392                                         error() << "-F" << pc.paramArg[0] << 
393                                                         " is an invalid argument" << endl;
394                                         exit(1);
395                                 }
396                                 break;
397                         case 'G': 
398                                 if ( pc.paramArg[0] == '0' )
399                                         codeStyle = GenGoto;
400                                 else if ( pc.paramArg[0] == '1' )
401                                         codeStyle = GenFGoto;
402                                 else if ( pc.paramArg[0] == '2' )
403                                         codeStyle = GenIpGoto;
404                                 else {
405                                         error() << "-G" << pc.paramArg[0] << 
406                                                         " is an invalid argument" << endl;
407                                         exit(1);
408                                 }
409                                 break;
410                         case 'P':
411                                 codeStyle = GenSplit;
412                                 numSplitPartitions = atoi( pc.paramArg );
413                                 break;
414
415                         case 'p':
416                                 displayPrintables = true;
417                                 break;
418
419                         case 'L':
420                                 noLineDirectives = true;
421                                 break;
422                         }
423                         break;
424
425                 case ParamCheck::invalid:
426                         error() << "-" << pc.parameter << " is an invalid argument" << endl;
427                         break;
428
429                 case ParamCheck::noparam:
430                         /* It is interpreted as an input file. */
431                         if ( *pc.curArg == 0 )
432                                 error() << "a zero length input file name was given" << endl;
433                         else if ( inputFileName != 0 )
434                                 error() << "more than one input file name was given" << endl;
435                         else {
436                                 /* OK, Remember the filename. */
437                                 inputFileName = pc.curArg;
438                         }
439                         break;
440                 }
441         }
442 }
443
444 void process( const char *inputFileName, const char *intermed )
445 {
446         /* Open the input file for reading. */
447         assert( inputFileName != 0 );
448         ifstream *inFile = new ifstream( inputFileName );
449         istream *inStream = inFile;
450         if ( ! inFile->is_open() )
451                 error() << "could not open " << inputFileName << " for reading" << endp;
452
453         /* Used for just a few things. */
454         std::ostringstream hostData;
455
456         if ( machineSpec == 0 && machineName == 0 )
457                 hostData << "<host line=\"1\" col=\"1\">";
458
459         Scanner scanner( inputFileName, *inStream, hostData, 0, 0, 0, false );
460         scanner.do_scan();
461
462         /* Finished, final check for errors.. */
463         if ( gblErrorCount > 0 )
464                 exit(1);
465         
466         /* Now send EOF to all parsers. */
467         terminateAllParsers();
468
469         /* Finished, final check for errors.. */
470         if ( gblErrorCount > 0 )
471                 exit(1);
472
473         if ( machineSpec == 0 && machineName == 0 )
474                 hostData << "</host>\n";
475
476         if ( gblErrorCount > 0 )
477                 exit(1);
478         
479         ostream *outputFile = new ofstream( intermed );
480
481         /* Write the machines, then the surrounding code. */
482         writeMachines( *outputFile, hostData.str(), inputFileName );
483
484         /* Close the input and the intermediate file. */
485         delete outputFile;
486         delete inFile;
487
488         /* Bail on above error. */
489         if ( gblErrorCount > 0 )
490                 exit(1);
491
492         const char *xmlInputFileName = intermed;
493
494         bool wantComplete = true;
495         bool outputActive = true;
496
497         /* Open the input file for reading. */
498         inFile = new ifstream( xmlInputFileName );
499         inStream = inFile;
500         if ( ! inFile->is_open() )
501                 error() << "could not open " << xmlInputFileName << " for reading" << endl;
502
503         /* Bail on above error. */
504         if ( gblErrorCount > 0 )
505                 exit(1);
506
507         /* Locate the backend program */
508         if ( generateDot ) {
509                 wantComplete = false;
510                 outputActive = false;
511         }
512
513         XmlScanner xmlScanner( xmlInputFileName, *inStream );
514         XmlParser xmlParser( xmlInputFileName, outputActive, wantComplete );
515         xmlParser.init();
516
517         xml_parse( *inStream, xmlInputFileName, 
518                 outputActive, wantComplete,
519                 xmlScanner, xmlParser );
520
521         /* If writing to a file, delete the ostream, causing it to flush.
522          * Standard out is flushed automatically. */
523         if ( outputFileName != 0 ) {
524                 delete outStream;
525                 delete outFilter;
526         }
527
528         /* Finished, final check for errors.. */
529         if ( gblErrorCount > 0 ) {
530                 /* If we opened an output file, remove it. */
531                 if ( outputFileName != 0 )
532                         unlink( outputFileName );
533                 exit(1);
534         }
535 }
536
537 char *makeIntermedTemplate( const char *baseFileName )
538 {
539         char *result = 0;
540         const char *templ = "ragel-XXXXXX.xml";
541         char *lastSlash = strrchr( baseFileName, '/' );
542         if ( lastSlash == 0 ) {
543                 result = new char[strlen(templ)+1];
544                 strcpy( result, templ );
545         }
546         else {
547                 int baseLen = lastSlash - baseFileName + 1;
548                 result = new char[baseLen + strlen(templ) + 1];
549                 memcpy( result, baseFileName, baseLen );
550                 strcpy( result+baseLen, templ );
551         }
552         return result;
553 };
554
555 const char *openIntermed( const char *inputFileName, const char *outputFileName )
556 {
557         srand(time(0));
558         const char *result = 0;
559
560         /* Which filename do we use as the base? */
561         const char *baseFileName = outputFileName != 0 ? outputFileName : inputFileName;
562
563         /* The template for the intermediate file name. */
564         const char *intermedFileName = makeIntermedTemplate( baseFileName );
565
566         /* Randomize the name and try to open. */
567         char fnChars[] = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
568         char *firstX = strrchr( intermedFileName, 'X' ) - 5;
569         for ( int tries = 0; tries < 20; tries++ ) {
570                 /* Choose a random name. */
571                 for ( int x = 0; x < 6; x++ )
572                         firstX[x] = fnChars[rand() % 52];
573
574                 /* Try to open the file. */
575                 int fd = ::open( intermedFileName, O_WRONLY|O_EXCL|O_CREAT, S_IRUSR|S_IWUSR );
576
577                 if ( fd > 0 ) {
578                         /* Success. Close the file immediately and return the name for use
579                          * by the child processes. */
580                         ::close( fd );
581                         result = intermedFileName;
582                         break;
583                 }
584
585                 if ( errno == EACCES ) {
586                         error() << "failed to open temp file " << intermedFileName << 
587                                         ", access denied" << endp;
588                 }
589         }
590
591         if ( result == 0 )
592                 error() << "abnormal error: cannot find unique name for temp file" << endp;
593
594         return result;
595 }
596
597
598 void cleanExit( const char *intermed, int status )
599 {
600         unlink( intermed );
601         exit( status );
602 }
603
604 /* Main, process args and call yyparse to start scanning input. */
605 int main( int argc, const char **argv )
606 {
607         const char *inputFileName = 0;
608         processArgs( argc, argv, inputFileName );
609
610         /* If -M or -S are given and we're not generating a dot file then invoke
611          * the frontend. These options are not useful with code generators. */
612         if ( machineName != 0 || machineSpec != 0 ) {
613                 if ( !generateDot )
614                         frontendOnly = true;
615         }
616
617         /* Require an input file. If we use standard in then we won't have a file
618          * name on which to base the output. */
619         if ( inputFileName == 0 )
620                 error() << "no input file given" << endl;
621
622         /* Bail on argument processing errors. */
623         if ( gblErrorCount > 0 )
624                 exit(1);
625
626         /* Make sure we are not writing to the same file as the input file. */
627         if ( inputFileName != 0 && outputFileName != 0 && 
628                         strcmp( inputFileName, outputFileName  ) == 0 )
629         {
630                 error() << "output file \"" << outputFileName  << 
631                                 "\" is the same as the input file" << endp;
632         }
633
634         const char *intermed = openIntermed( inputFileName, outputFileName );
635         process( inputFileName, intermed );
636
637         /* Clean up the intermediate. */
638         cleanExit( intermed, 0 );
639
640         return 0;
641 }