ragel/rlscan.rl

   1 /*
   2  *  Copyright 2006-2007 Adrian Thurston <thurston@complang.org>
   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 <iostream>
  23 #include <fstream>
  24 #include <string.h>
  25
  26 #include "ragel.h"
  27 #include "rlscan.h"
  28 #include "inputdata.h"
  29
  30 //#define LOG_TOKENS
  31
  32 using std::ifstream;
  33 using std::istream;
  34 using std::ostream;
  35 using std::cout;
  36 using std::cerr;
  37 using std::endl;
  38
  39 enum InlineBlockType
  40 {
  41         CurlyDelimited,
  42         SemiTerminated
  43 };
  44
  45 #ifdef _WIN32
  46 #define PATH_SEP '\\'
  47 #else
  48 #define PATH_SEP '/'
  49 #endif
  50
  51
  52 /*
  53  * The Scanner for Importing
  54  */
  55
  56 %%{
  57         machine inline_token_scan;
  58         alphtype int;
  59         access tok_;
  60
  61         # Import scanner tokens.
  62         import "rlparse.h";
  63
  64         main := |*
  65                 # Define of number.
  66                 IMP_Define IMP_Word IMP_UInt => {
  67                         int base = tok_ts - token_data;
  68                         int nameOff = 1;
  69                         int numOff = 2;
  70
  71                         directToParser( inclToParser, fileName, line, column, TK_Word,
  72                                         token_strings[base+nameOff], token_lens[base+nameOff] );
  73                         directToParser( inclToParser, fileName, line, column, '=', 0, 0 );
  74                         directToParser( inclToParser, fileName, line, column, TK_UInt,
  75                                         token_strings[base+numOff], token_lens[base+numOff] );
  76                         directToParser( inclToParser, fileName, line, column, ';', 0, 0 );
  77                 };
  78
  79                 # Assignment of number.
  80                 IMP_Word '=' IMP_UInt => {
  81                         int base = tok_ts - token_data;
  82                         int nameOff = 0;
  83                         int numOff = 2;
  84
  85                         directToParser( inclToParser, fileName, line, column, TK_Word,
  86                                         token_strings[base+nameOff], token_lens[base+nameOff] );
  87                         directToParser( inclToParser, fileName, line, column, '=', 0, 0 );
  88                         directToParser( inclToParser, fileName, line, column, TK_UInt,
  89                                         token_strings[base+numOff], token_lens[base+numOff] );
  90                         directToParser( inclToParser, fileName, line, column, ';', 0, 0 );
  91                 };
  92
  93                 # Define of literal.
  94                 IMP_Define IMP_Word IMP_Literal => {
  95                         int base = tok_ts - token_data;
  96                         int nameOff = 1;
  97                         int litOff = 2;
  98
  99                         directToParser( inclToParser, fileName, line, column, TK_Word,
 100                                         token_strings[base+nameOff], token_lens[base+nameOff] );
 101                         directToParser( inclToParser, fileName, line, column, '=', 0, 0 );
 102                         directToParser( inclToParser, fileName, line, column, TK_Literal,
 103                                         token_strings[base+litOff], token_lens[base+litOff] );
 104                         directToParser( inclToParser, fileName, line, column, ';', 0, 0 );
 105                 };
 106
 107                 # Assignment of literal.
 108                 IMP_Word '=' IMP_Literal => {
 109                         int base = tok_ts - token_data;
 110                         int nameOff = 0;
 111                         int litOff = 2;
 112
 113                         directToParser( inclToParser, fileName, line, column, TK_Word,
 114                                         token_strings[base+nameOff], token_lens[base+nameOff] );
 115                         directToParser( inclToParser, fileName, line, column, '=', 0, 0 );
 116                         directToParser( inclToParser, fileName, line, column, TK_Literal,
 117                                         token_strings[base+litOff], token_lens[base+litOff] );
 118                         directToParser( inclToParser, fileName, line, column, ';', 0, 0 );
 119                 };
 120
 121                 # Catch everything else.
 122                 any;
 123         *|;
 124 }%%
 125
 126 %% write data;
 127
 128 void Scanner::flushImport()
 129 {
 130         int *p = token_data;
 131         int *pe = token_data + cur_token;
 132         int *eof = 0;
 133
 134         %%{
 135                 machine inline_token_scan;
 136                 write init;
 137                 write exec;
 138         }%%
 139
 140         if ( tok_ts == 0 )
 141                 cur_token = 0;
 142         else {
 143                 cur_token = pe - tok_ts;
 144                 int ts_offset = tok_ts - token_data;
 145                 memmove( token_data, token_data+ts_offset, cur_token*sizeof(token_data[0]) );
 146                 memmove( token_strings, token_strings+ts_offset, cur_token*sizeof(token_strings[0]) );
 147                 memmove( token_lens, token_lens+ts_offset, cur_token*sizeof(token_lens[0]) );
 148         }
 149 }
 150
 151 void Scanner::directToParser( Parser *toParser, const char *tokFileName, int tokLine,
 152                 int tokColumn, int type, char *tokdata, int toklen )
 153 {
 154         InputLoc loc;
 155
 156         #ifdef LOG_TOKENS
 157         cerr << "scanner:" << tokLine << ":" << tokColumn <<
 158                         ": sending token to the parser " << Parser_lelNames[type];
 159         cerr << " " << toklen;
 160         if ( tokdata != 0 )
 161                 cerr << " " << tokdata;
 162         cerr << endl;
 163         #endif
 164
 165         loc.fileName = tokFileName;
 166         loc.line = tokLine;
 167         loc.col = tokColumn;
 168
 169         toParser->token( loc, type, tokdata, toklen );
 170 }
 171
 172 void Scanner::importToken( int token, char *start, char *end )
 173 {
 174         if ( cur_token == max_tokens )
 175                 flushImport();
 176
 177         token_data[cur_token] = token;
 178         if ( start == 0 ) {
 179                 token_strings[cur_token] = 0;
 180                 token_lens[cur_token] = 0;
 181         }
 182         else {
 183                 int toklen = end-start;
 184                 token_lens[cur_token] = toklen;
 185                 token_strings[cur_token] = new char[toklen+1];
 186                 memcpy( token_strings[cur_token], start, toklen );
 187                 token_strings[cur_token][toklen] = 0;
 188         }
 189         cur_token++;
 190 }
 191
 192 void Scanner::pass( int token, char *start, char *end )
 193 {
 194         if ( importMachines )
 195                 importToken( token, start, end );
 196         pass();
 197 }
 198
 199 void Scanner::pass()
 200 {
 201         updateCol();
 202
 203         /* If no errors and we are at the bottom of the include stack (the
 204          * source file listed on the command line) then write out the data. */
 205         if ( includeDepth == 0 && machineSpec == 0 && machineName == 0 )
 206                 id.inputItems.tail->data.write( ts, te-ts );
 207 }
 208
 209 /*
 210  * The scanner for processing sections, includes, imports, etc.
 211  */
 212
 213 %%{
 214         machine section_parse;
 215         alphtype int;
 216         write data;
 217 }%%
 218
 219
 220 void Scanner::init( )
 221 {
 222         %% write init;
 223 }
 224
 225 bool Scanner::active()
 226 {
 227         if ( ignoreSection )
 228                 return false;
 229
 230         if ( parser == 0 && ! parserExistsError ) {
 231                 scan_error() << "this specification has no name, nor does any previous"
 232                         " specification" << endl;
 233                 parserExistsError = true;
 234         }
 235
 236         if ( parser == 0 )
 237                 return false;
 238
 239         return true;
 240 }
 241
 242 ostream &Scanner::scan_error()
 243 {
 244         /* Maintain the error count. */
 245         gblErrorCount += 1;
 246         cerr << makeInputLoc( fileName, line, column ) << ": ";
 247         return cerr;
 248 }
 249
 250 /* An approximate check for duplicate includes. Due to aliasing of files it's
 251  * possible for duplicates to creep in. */
 252 bool Scanner::duplicateInclude( char *inclFileName, char *inclSectionName )
 253 {
 254         for ( IncludeHistory::Iter hi = parser->includeHistory; hi.lte(); hi++ ) {
 255                 if ( strcmp( hi->fileName, inclFileName ) == 0 &&
 256                                 strcmp( hi->sectionName, inclSectionName ) == 0 )
 257                 {
 258                         return true;
 259                 }
 260         }
 261         return false;
 262 }
 263
 264 void Scanner::updateCol()
 265 {
 266         char *from = lastnl;
 267         if ( from == 0 )
 268                 from = ts;
 269         //cerr << "adding " << te - from << " to column" << endl;
 270         column += te - from;
 271         lastnl = 0;
 272 }
 273
 274 void Scanner::handleMachine()
 275 {
 276         /* Assign a name to the machine. */
 277         char *machine = word;
 278
 279         if ( !importMachines && inclSectionTarg == 0 ) {
 280                 ignoreSection = false;
 281
 282                 ParserDictEl *pdEl = id.parserDict.find( machine );
 283                 if ( pdEl == 0 ) {
 284                         pdEl = new ParserDictEl( machine );
 285                         pdEl->value = new Parser( fileName, machine, sectionLoc );
 286                         pdEl->value->init();
 287                         id.parserDict.insert( pdEl );
 288                         id.parserList.append( pdEl->value );
 289                 }
 290
 291                 parser = pdEl->value;
 292         }
 293         else if ( !importMachines && strcmp( inclSectionTarg, machine ) == 0 ) {
 294                 /* found include target */
 295                 ignoreSection = false;
 296                 parser = inclToParser;
 297         }
 298         else {
 299                 /* ignoring section */
 300                 ignoreSection = true;
 301                 parser = 0;
 302         }
 303 }
 304
 305 void Scanner::handleInclude()
 306 {
 307         if ( active() ) {
 308                 char *inclSectionName = word;
 309                 char **includeChecks = 0;
 310
 311                 /* Implement defaults for the input file and section name. */
 312                 if ( inclSectionName == 0 )
 313                         inclSectionName = parser->sectionName;
 314
 315                 if ( lit != 0 )
 316                         includeChecks = makeIncludePathChecks( fileName, lit, lit_len );
 317                 else {
 318                         char *test = new char[strlen(fileName)+1];
 319                         strcpy( test, fileName );
 320
 321                         includeChecks = new char*[2];
 322
 323                         includeChecks[0] = test;
 324                         includeChecks[1] = 0;
 325                 }
 326
 327                 long found = 0;
 328                 ifstream *inFile = tryOpenInclude( includeChecks, found );
 329                 if ( inFile == 0 ) {
 330                         scan_error() << "include: failed to locate file" << endl;
 331                         char **tried = includeChecks;
 332                         while ( *tried != 0 )
 333                                 scan_error() << "include: attempted: \"" << *tried++ << '\"' << endl;
 334                 }
 335                 else {
 336                         /* Don't include anything that's already been included. */
 337                         if ( !duplicateInclude( includeChecks[found], inclSectionName ) ) {
 338                                 parser->includeHistory.append( IncludeHistoryItem(
 339                                                 includeChecks[found], inclSectionName ) );
 340
 341                                 Scanner scanner( id, includeChecks[found], *inFile, parser,
 342                                                 inclSectionName, includeDepth+1, false );
 343                                 scanner.do_scan( );
 344                                 delete inFile;
 345                         }
 346                 }
 347         }
 348 }
 349
 350 void Scanner::handleImport()
 351 {
 352         if ( active() ) {
 353                 char **importChecks = makeIncludePathChecks( fileName, lit, lit_len );
 354
 355                 /* Open the input file for reading. */
 356                 long found = 0;
 357                 ifstream *inFile = tryOpenInclude( importChecks, found );
 358                 if ( inFile == 0 ) {
 359                         scan_error() << "import: could not open import file " <<
 360                                         "for reading" << endl;
 361                         char **tried = importChecks;
 362                         while ( *tried != 0 )
 363                                 scan_error() << "import: attempted: \"" << *tried++ << '\"' << endl;
 364                 }
 365
 366                 Scanner scanner( id, importChecks[found], *inFile, parser,
 367                                 0, includeDepth+1, true );
 368                 scanner.do_scan( );
 369                 scanner.importToken( 0, 0, 0 );
 370                 scanner.flushImport();
 371                 delete inFile;
 372         }
 373 }
 374
 375 %%{
 376         machine section_parse;
 377
 378         # Need the defines representing tokens.
 379         import "rlparse.h";
 380
 381         action clear_words { word = lit = 0; word_len = lit_len = 0; }
 382         action store_word { word = tokdata; word_len = toklen; }
 383         action store_lit { lit = tokdata; lit_len = toklen; }
 384
 385         action mach_err { scan_error() << "bad machine statement" << endl; }
 386         action incl_err { scan_error() << "bad include statement" << endl; }
 387         action import_err { scan_error() << "bad import statement" << endl; }
 388         action write_err { scan_error() << "bad write statement" << endl; }
 389
 390         action handle_machine { handleMachine(); }
 391         action handle_include { handleInclude(); }
 392         action handle_import { handleImport(); }
 393
 394         machine_stmt =
 395                 ( KW_Machine TK_Word @store_word ';' ) @handle_machine
 396                 <>err mach_err <>eof mach_err;
 397
 398         include_names = (
 399                 TK_Word @store_word ( TK_Literal @store_lit )? |
 400                 TK_Literal @store_lit
 401         ) >clear_words;
 402
 403         include_stmt =
 404                 ( KW_Include include_names ';' ) @handle_include
 405                 <>err incl_err <>eof incl_err;
 406
 407         import_stmt =
 408                 ( KW_Import TK_Literal @store_lit ';' ) @handle_import
 409                 <>err import_err <>eof import_err;
 410
 411         action write_command
 412         {
 413                 if ( active() && machineSpec == 0 && machineName == 0 ) {
 414                         InputItem *inputItem = new InputItem;
 415                         inputItem->type = InputItem::Write;
 416                         inputItem->loc.fileName = fileName;
 417                         inputItem->loc.line = line;
 418                         inputItem->loc.col = column;
 419                         inputItem->name = parser->sectionName;
 420                         inputItem->pd = parser->pd;
 421                         id.inputItems.append( inputItem );
 422                 }
 423         }
 424
 425         action write_arg
 426         {
 427                 if ( active() && machineSpec == 0 && machineName == 0 )
 428                         id.inputItems.tail->writeArgs.append( strdup(tokdata) );
 429         }
 430
 431         action write_close
 432         {
 433                 if ( active() && machineSpec == 0 && machineName == 0 )
 434                         id.inputItems.tail->writeArgs.append( 0 );
 435         }
 436
 437         write_stmt =
 438                 ( KW_Write @write_command
 439                 ( TK_Word @write_arg )+ ';' @write_close )
 440                 <>err write_err <>eof write_err;
 441
 442         action handle_token
 443         {
 444                 /* Send the token off to the parser. */
 445                 if ( active() )
 446                         directToParser( parser, fileName, line, column, type, tokdata, toklen );
 447         }
 448
 449         # Catch everything else.
 450         everything_else =
 451                 ^( KW_Machine | KW_Include | KW_Import | KW_Write ) @handle_token;
 452
 453         main := (
 454                 machine_stmt |
 455                 include_stmt |
 456                 import_stmt |
 457                 write_stmt |
 458                 everything_else
 459         )*;
 460 }%%
 461
 462 void Scanner::token( int type, char c )
 463 {
 464         token( type, &c, &c + 1 );
 465 }
 466
 467 void Scanner::token( int type )
 468 {
 469         token( type, 0, 0 );
 470 }
 471
 472 void Scanner::token( int type, char *start, char *end )
 473 {
 474         char *tokdata = 0;
 475         int toklen = 0;
 476         if ( start != 0 ) {
 477                 toklen = end-start;
 478                 tokdata = new char[toklen+1];
 479                 memcpy( tokdata, start, toklen );
 480                 tokdata[toklen] = 0;
 481         }
 482
 483         processToken( type, tokdata, toklen );
 484 }
 485
 486 void Scanner::processToken( int type, char *tokdata, int toklen )
 487 {
 488         int *p, *pe, *eof;
 489
 490         if ( type < 0 )
 491                 p = pe = eof = 0;
 492         else {
 493                 p = &type;
 494                 pe = &type + 1;
 495                 eof = 0;
 496         }
 497
 498         %%{
 499                 machine section_parse;
 500                 write exec;
 501         }%%
 502
 503         updateCol();
 504
 505         /* Record the last token for use in controlling the scan of subsequent
 506          * tokens. */
 507         lastToken = type;
 508 }
 509
 510 void Scanner::startSection( )
 511 {
 512         parserExistsError = false;
 513
 514         sectionLoc.fileName = fileName;
 515         sectionLoc.line = line;
 516         sectionLoc.col = column;
 517 }
 518
 519 void Scanner::endSection( )
 520 {
 521         /* Execute the eof actions for the section parser. */
 522         processToken( -1, 0, 0 );
 523
 524         /* Close off the section with the parser. */
 525         if ( active() ) {
 526                 InputLoc loc;
 527                 loc.fileName = fileName;
 528                 loc.line = line;
 529                 loc.col = column;
 530
 531                 parser->token( loc, TK_EndSection, 0, 0 );
 532         }
 533
 534         if ( includeDepth == 0 ) {
 535                 if ( machineSpec == 0 && machineName == 0 ) {
 536                         /* The end section may include a newline on the end, so
 537                          * we use the last line, which will count the newline. */
 538                         InputItem *inputItem = new InputItem;
 539                         inputItem->type = InputItem::HostData;
 540                         inputItem->loc.line = line;
 541                         inputItem->loc.col = column;
 542                         id.inputItems.append( inputItem );
 543                 }
 544         }
 545 }
 546
 547 bool isAbsolutePath( const char *path )
 548 {
 549 #ifdef _WIN32
 550         return isalpha( path[0] ) && path[1] == ':' && path[2] == '\\';
 551 #else
 552         return path[0] == '/';
 553 #endif
 554 }
 555
 556 char **Scanner::makeIncludePathChecks( const char *thisFileName,
 557                 const char *fileName, int fnlen )
 558 {
 559         char **checks = 0;
 560         long nextCheck = 0;
 561         long length = 0;
 562         bool caseInsensitive = false;
 563         char *data = prepareLitString( InputLoc(), fileName, fnlen,
 564                         length, caseInsensitive );
 565
 566         /* Absolute path? */
 567         if ( isAbsolutePath( data ) ) {
 568                 checks = new char*[2];
 569                 checks[nextCheck++] = data;
 570         }
 571         else {
 572                 checks = new char*[2 + id.includePaths.length()];
 573
 574                 /* Search from the the location of the current file. */
 575                 const char *lastSlash = strrchr( thisFileName, PATH_SEP );
 576                 if ( lastSlash == 0 )
 577                         checks[nextCheck++] = data;
 578                 else {
 579                         long givenPathLen = (lastSlash - thisFileName) + 1;
 580                         long checklen = givenPathLen + length;
 581                         char *check = new char[checklen+1];
 582                         memcpy( check, thisFileName, givenPathLen );
 583                         memcpy( check+givenPathLen, data, length );
 584                         check[checklen] = 0;
 585                         checks[nextCheck++] = check;
 586                 }
 587
 588                 /* Search from the include paths given on the command line. */
 589                 for ( ArgsVector::Iter incp = id.includePaths; incp.lte(); incp++ ) {
 590                         long pathLen = strlen( *incp );
 591                         long checkLen = pathLen + 1 + length;
 592                         char *check = new char[checkLen+1];
 593                         memcpy( check, *incp, pathLen );
 594                         check[pathLen] = PATH_SEP;
 595                         memcpy( check+pathLen+1, data, length );
 596                         check[checkLen] = 0;
 597                         checks[nextCheck++] = check;
 598                 }
 599         }
 600
 601         checks[nextCheck] = 0;
 602         return checks;
 603 }
 604
 605 ifstream *Scanner::tryOpenInclude( char **pathChecks, long &found )
 606 {
 607         char **check = pathChecks;
 608         ifstream *inFile = new ifstream;
 609
 610         while ( *check != 0 ) {
 611                 inFile->open( *check );
 612                 if ( inFile->is_open() ) {
 613                         found = check - pathChecks;
 614                         return inFile;
 615                 }
 616                 check += 1;
 617         }
 618
 619         found = -1;
 620         delete inFile;
 621         return 0;
 622 }
 623
 624 %%{
 625         machine rlscan;
 626
 627         # This is sent by the driver code.
 628         EOF = 0;
 629
 630         action inc_nl {
 631                 lastnl = p;
 632                 column = 0;
 633                 line++;
 634         }
 635         NL = '\n' @inc_nl;
 636
 637         # Identifiers, numbers, commetns, and other common things.
 638         ident = ( alpha | '_' ) ( alpha |digit |'_' )*;
 639         number = digit+;
 640         hex_number = '0x' [0-9a-fA-F]+;
 641
 642         c_comment =
 643                 '/*' ( any | NL )* :>> '*/';
 644
 645         cpp_comment =
 646                 '//' [^\n]* NL;
 647
 648         c_cpp_comment = c_comment | cpp_comment;
 649
 650         ruby_comment = '#' [^\n]* NL;
 651
 652         # These literal forms are common to host code and ragel.
 653         s_literal = "'" ([^'\\] | NL | '\\' (any | NL))* "'";
 654         d_literal = '"' ([^"\\] | NL | '\\' (any | NL))* '"';
 655         host_re_literal = '/' ([^/\\] | NL | '\\' (any | NL))* '/';
 656
 657         whitespace = [ \t] | NL;
 658         pound_comment = '#' [^\n]* NL;
 659
 660         # An inline block of code for Ruby.
 661         inline_code_ruby := |*
 662                 # Inline expression keywords.
 663                 "fpc" => { token( KW_PChar ); };
 664                 "fc" => { token( KW_Char ); };
 665                 "fcurs" => { token( KW_CurState ); };
 666                 "ftargs" => { token( KW_TargState ); };
 667                 "fentry" => {
 668                         whitespaceOn = false;
 669                         token( KW_Entry );
 670                 };
 671
 672                 # Inline statement keywords.
 673                 "fhold" => {
 674                         whitespaceOn = false;
 675                         token( KW_Hold );
 676                 };
 677                 "fexec" => { token( KW_Exec, 0, 0 ); };
 678                 "fgoto" => {
 679                         whitespaceOn = false;
 680                         token( KW_Goto );
 681                 };
 682                 "fnext" => {
 683                         whitespaceOn = false;
 684                         token( KW_Next );
 685                 };
 686                 "fcall" => {
 687                         whitespaceOn = false;
 688                         token( KW_Call );
 689                 };
 690                 "fret" => {
 691                         whitespaceOn = false;
 692                         token( KW_Ret );
 693                 };
 694                 "fbreak" => {
 695                         whitespaceOn = false;
 696                         token( KW_Break );
 697                 };
 698
 699                 ident => { token( TK_Word, ts, te ); };
 700
 701                 number => { token( TK_UInt, ts, te ); };
 702                 hex_number => { token( TK_Hex, ts, te ); };
 703
 704                 ( s_literal | d_literal | host_re_literal )
 705                         => { token( IL_Literal, ts, te ); };
 706
 707                 whitespace+ => {
 708                         if ( whitespaceOn )
 709                                 token( IL_WhiteSpace, ts, te );
 710                 };
 711
 712                 ruby_comment => { token( IL_Comment, ts, te ); };
 713
 714                 "::" => { token( TK_NameSep, ts, te ); };
 715
 716                 # Some symbols need to go to the parser as with their cardinal value as
 717                 # the token type (as opposed to being sent as anonymous symbols)
 718                 # because they are part of the sequences which we interpret. The * ) ;
 719                 # symbols cause whitespace parsing to come back on. This gets turned
 720                 # off by some keywords.
 721
 722                 ";" => {
 723                         whitespaceOn = true;
 724                         token( *ts, ts, te );
 725                         if ( inlineBlockType == SemiTerminated )
 726                                 fret;
 727                 };
 728
 729                 [*)] => {
 730                         whitespaceOn = true;
 731                         token( *ts, ts, te );
 732                 };
 733
 734                 [,(] => { token( *ts, ts, te ); };
 735
 736                 '{' => {
 737                         token( IL_Symbol, ts, te );
 738                         curly_count += 1;
 739                 };
 740
 741                 '}' => {
 742                         if ( --curly_count == 0 && inlineBlockType == CurlyDelimited ) {
 743                                 /* Inline code block ends. */
 744                                 token( '}' );
 745                                 fret;
 746                         }
 747                         else {
 748                                 /* Either a semi terminated inline block or only the closing
 749                                  * brace of some inner scope, not the block's closing brace. */
 750                                 token( IL_Symbol, ts, te );
 751                         }
 752                 };
 753
 754                 EOF => {
 755                         scan_error() << "unterminated code block" << endl;
 756                 };
 757
 758                 # Send every other character as a symbol.
 759                 any => { token( IL_Symbol, ts, te ); };
 760         *|;
 761
 762
 763         # An inline block of code for languages other than Ruby.
 764         inline_code := |*
 765                 # Inline expression keywords.
 766                 "fpc" => { token( KW_PChar ); };
 767                 "fc" => { token( KW_Char ); };
 768                 "fcurs" => { token( KW_CurState ); };
 769                 "ftargs" => { token( KW_TargState ); };
 770                 "fentry" => {
 771                         whitespaceOn = false;
 772                         token( KW_Entry );
 773                 };
 774
 775                 # Inline statement keywords.
 776                 "fhold" => {
 777                         whitespaceOn = false;
 778                         token( KW_Hold );
 779                 };
 780                 "fexec" => { token( KW_Exec, 0, 0 ); };
 781                 "fgoto" => {
 782                         whitespaceOn = false;
 783                         token( KW_Goto );
 784                 };
 785                 "fnext" => {
 786                         whitespaceOn = false;
 787                         token( KW_Next );
 788                 };
 789                 "fcall" => {
 790                         whitespaceOn = false;
 791                         token( KW_Call );
 792                 };
 793                 "fret" => {
 794                         whitespaceOn = false;
 795                         token( KW_Ret );
 796                 };
 797                 "fbreak" => {
 798                         whitespaceOn = false;
 799                         token( KW_Break );
 800                 };
 801
 802                 ident => { token( TK_Word, ts, te ); };
 803
 804                 number => { token( TK_UInt, ts, te ); };
 805                 hex_number => { token( TK_Hex, ts, te ); };
 806
 807                 ( s_literal | d_literal )
 808                         => { token( IL_Literal, ts, te ); };
 809
 810                 whitespace+ => {
 811                         if ( whitespaceOn )
 812                                 token( IL_WhiteSpace, ts, te );
 813                 };
 814
 815                 c_cpp_comment => { token( IL_Comment, ts, te ); };
 816
 817                 "::" => { token( TK_NameSep, ts, te ); };
 818
 819                 # Some symbols need to go to the parser as with their cardinal value as
 820                 # the token type (as opposed to being sent as anonymous symbols)
 821                 # because they are part of the sequences which we interpret. The * ) ;
 822                 # symbols cause whitespace parsing to come back on. This gets turned
 823                 # off by some keywords.
 824
 825                 ";" => {
 826                         whitespaceOn = true;
 827                         token( *ts, ts, te );
 828                         if ( inlineBlockType == SemiTerminated )
 829                                 fret;
 830                 };
 831
 832                 [*)] => {
 833                         whitespaceOn = true;
 834                         token( *ts, ts, te );
 835                 };
 836
 837                 [,(] => { token( *ts, ts, te ); };
 838
 839                 '{' => {
 840                         token( IL_Symbol, ts, te );
 841                         curly_count += 1;
 842                 };
 843
 844                 '}' => {
 845                         if ( --curly_count == 0 && inlineBlockType == CurlyDelimited ) {
 846                                 /* Inline code block ends. */
 847                                 token( '}' );
 848                                 fret;
 849                         }
 850                         else {
 851                                 /* Either a semi terminated inline block or only the closing
 852                                  * brace of some inner scope, not the block's closing brace. */
 853                                 token( IL_Symbol, ts, te );
 854                         }
 855                 };
 856
 857                 EOF => {
 858                         scan_error() << "unterminated code block" << endl;
 859                 };
 860
 861                 # Send every other character as a symbol.
 862                 any => { token( IL_Symbol, ts, te ); };
 863         *|;
 864
 865         or_literal := |*
 866                 # Escape sequences in OR expressions.
 867                 '\\0' => { token( RE_Char, '\0' ); };
 868                 '\\a' => { token( RE_Char, '\a' ); };
 869                 '\\b' => { token( RE_Char, '\b' ); };
 870                 '\\t' => { token( RE_Char, '\t' ); };
 871                 '\\n' => { token( RE_Char, '\n' ); };
 872                 '\\v' => { token( RE_Char, '\v' ); };
 873                 '\\f' => { token( RE_Char, '\f' ); };
 874                 '\\r' => { token( RE_Char, '\r' ); };
 875                 '\\\n' => { updateCol(); };
 876                 '\\' any => { token( RE_Char, ts+1, te ); };
 877
 878                 # Range dash in an OR expression.
 879                 '-' => { token( RE_Dash, 0, 0 ); };
 880
 881                 # Terminate an OR expression.
 882                 ']'     => { token( RE_SqClose ); fret; };
 883
 884                 EOF => {
 885                         scan_error() << "unterminated OR literal" << endl;
 886                 };
 887
 888                 # Characters in an OR expression.
 889                 [^\]] => { token( RE_Char, ts, te ); };
 890
 891         *|;
 892
 893         ragel_re_literal := |*
 894                 # Escape sequences in regular expressions.
 895                 '\\0' => { token( RE_Char, '\0' ); };
 896                 '\\a' => { token( RE_Char, '\a' ); };
 897                 '\\b' => { token( RE_Char, '\b' ); };
 898                 '\\t' => { token( RE_Char, '\t' ); };
 899                 '\\n' => { token( RE_Char, '\n' ); };
 900                 '\\v' => { token( RE_Char, '\v' ); };
 901                 '\\f' => { token( RE_Char, '\f' ); };
 902                 '\\r' => { token( RE_Char, '\r' ); };
 903                 '\\\n' => { updateCol(); };
 904                 '\\' any => { token( RE_Char, ts+1, te ); };
 905
 906                 # Terminate an OR expression.
 907                 '/' [i]? => {
 908                         token( RE_Slash, ts, te );
 909                         fgoto parser_def;
 910                 };
 911
 912                 # Special characters.
 913                 '.' => { token( RE_Dot ); };
 914                 '*' => { token( RE_Star ); };
 915
 916                 '[' => { token( RE_SqOpen ); fcall or_literal; };
 917                 '[^' => { token( RE_SqOpenNeg ); fcall or_literal; };
 918
 919                 EOF => {
 920                         scan_error() << "unterminated regular expression" << endl;
 921                 };
 922
 923                 # Characters in an OR expression.
 924                 [^\/] => { token( RE_Char, ts, te ); };
 925         *|;
 926
 927         # We need a separate token space here to avoid the ragel keywords.
 928         write_statement := |*
 929                 ident => { token( TK_Word, ts, te ); } ;
 930                 [ \t\n]+ => { updateCol(); };
 931                 ';' => { token( ';' ); fgoto parser_def; };
 932
 933                 EOF => {
 934                         scan_error() << "unterminated write statement" << endl;
 935                 };
 936         *|;
 937
 938         # Parser definitions.
 939         parser_def := |*
 940                 'length_cond' => { token( KW_Length ); };
 941                 'machine' => { token( KW_Machine ); };
 942                 'include' => { token( KW_Include ); };
 943                 'import' => { token( KW_Import ); };
 944                 'write' => {
 945                         token( KW_Write );
 946                         fgoto write_statement;
 947                 };
 948                 'action' => { token( KW_Action ); };
 949                 'alphtype' => { token( KW_AlphType ); };
 950                 'prepush' => { token( KW_PrePush ); };
 951                 'postpop' => { token( KW_PostPop ); };
 952
 953                 # FIXME: Enable this post 5.17.
 954                 # 'range' => { token( KW_Range ); };
 955
 956                 'getkey' => {
 957                         token( KW_GetKey );
 958                         inlineBlockType = SemiTerminated;
 959                         if ( hostLang->lang == HostLang::Ruby )
 960                                 fcall inline_code_ruby;
 961                         else
 962                                 fcall inline_code;
 963                 };
 964                 'access' => {
 965                         token( KW_Access );
 966                         inlineBlockType = SemiTerminated;
 967                         if ( hostLang->lang == HostLang::Ruby )
 968                                 fcall inline_code_ruby;
 969                         else
 970                                 fcall inline_code;
 971                 };
 972                 'variable' => {
 973                         token( KW_Variable );
 974                         inlineBlockType = SemiTerminated;
 975                         if ( hostLang->lang == HostLang::Ruby )
 976                                 fcall inline_code_ruby;
 977                         else
 978                                 fcall inline_code;
 979                 };
 980                 'when' => { token( KW_When ); };
 981                 'inwhen' => { token( KW_InWhen ); };
 982                 'outwhen' => { token( KW_OutWhen ); };
 983                 'eof' => { token( KW_Eof ); };
 984                 'err' => { token( KW_Err ); };
 985                 'lerr' => { token( KW_Lerr ); };
 986                 'to' => { token( KW_To ); };
 987                 'from' => { token( KW_From ); };
 988                 'export' => { token( KW_Export ); };
 989
 990                 # Identifiers.
 991                 ident => { token( TK_Word, ts, te ); } ;
 992
 993                 # Numbers
 994                 number => { token( TK_UInt, ts, te ); };
 995                 hex_number => { token( TK_Hex, ts, te ); };
 996
 997                 # Literals, with optionals.
 998                 ( s_literal | d_literal ) [i]?
 999                         => { token( TK_Literal, ts, te ); };
1000
1001                 '[' => { token( RE_SqOpen ); fcall or_literal; };
1002                 '[^' => { token( RE_SqOpenNeg ); fcall or_literal; };
1003
1004                 '/' => { token( RE_Slash ); fgoto ragel_re_literal; };
1005
1006                 # Ignore.
1007                 pound_comment => { updateCol(); };
1008
1009                 ':=' => { token( TK_ColonEquals ); };
1010
1011                 # To State Actions.
1012                 ">~" => { token( TK_StartToState ); };
1013                 "$~" => { token( TK_AllToState ); };
1014                 "%~" => { token( TK_FinalToState ); };
1015                 "<~" => { token( TK_NotStartToState ); };
1016                 "@~" => { token( TK_NotFinalToState ); };
1017                 "<>~" => { token( TK_MiddleToState ); };
1018
1019                 # From State actions
1020                 ">*" => { token( TK_StartFromState ); };
1021                 "$*" => { token( TK_AllFromState ); };
1022                 "%*" => { token( TK_FinalFromState ); };
1023                 "<*" => { token( TK_NotStartFromState ); };
1024                 "@*" => { token( TK_NotFinalFromState ); };
1025                 "<>*" => { token( TK_MiddleFromState ); };
1026
1027                 # EOF Actions.
1028                 ">/" => { token( TK_StartEOF ); };
1029                 "$/" => { token( TK_AllEOF ); };
1030                 "%/" => { token( TK_FinalEOF ); };
1031                 "</" => { token( TK_NotStartEOF ); };
1032                 "@/" => { token( TK_NotFinalEOF ); };
1033                 "<>/" => { token( TK_MiddleEOF ); };
1034
1035                 # Global Error actions.
1036                 ">!" => { token( TK_StartGblError ); };
1037                 "$!" => { token( TK_AllGblError ); };
1038                 "%!" => { token( TK_FinalGblError ); };
1039                 "<!" => { token( TK_NotStartGblError ); };
1040                 "@!" => { token( TK_NotFinalGblError ); };
1041                 "<>!" => { token( TK_MiddleGblError ); };
1042
1043                 # Local error actions.
1044                 ">^" => { token( TK_StartLocalError ); };
1045                 "$^" => { token( TK_AllLocalError ); };
1046                 "%^" => { token( TK_FinalLocalError ); };
1047                 "<^" => { token( TK_NotStartLocalError ); };
1048                 "@^" => { token( TK_NotFinalLocalError ); };
1049                 "<>^" => { token( TK_MiddleLocalError ); };
1050
1051                 # Middle.
1052                 "<>" => { token( TK_Middle ); };
1053
1054                 # Conditions.
1055                 '>?' => { token( TK_StartCond ); };
1056                 '$?' => { token( TK_AllCond ); };
1057                 '%?' => { token( TK_LeavingCond ); };
1058
1059                 '..' => { token( TK_DotDot ); };
1060                 '**' => { token( TK_StarStar ); };
1061                 '--' => { token( TK_DashDash ); };
1062                 '->' => { token( TK_Arrow ); };
1063                 '=>' => { token( TK_DoubleArrow ); };
1064
1065                 ":>"  => { token( TK_ColonGt ); };
1066                 ":>>" => { token( TK_ColonGtGt ); };
1067                 "<:"  => { token( TK_LtColon ); };
1068
1069                 # Opening of longest match.
1070                 "|*" => { token( TK_BarStar ); };
1071
1072                 # Separater for name references.
1073                 "::" => { token( TK_NameSep, ts, te ); };
1074
1075                 '}%%' => {
1076                         updateCol();
1077                         endSection();
1078                         fret;
1079                 };
1080
1081                 [ \t\r]+ => { updateCol(); };
1082
1083                 # If we are in a single line machine then newline may end the spec.
1084                 NL => {
1085                         updateCol();
1086                         if ( singleLineSpec ) {
1087                                 endSection();
1088                                 fret;
1089                         }
1090                 };
1091
1092                 '{' => {
1093                         if ( lastToken == KW_Export || lastToken == KW_Entry )
1094                                 token( '{' );
1095                         else {
1096                                 token( '{' );
1097                                 curly_count = 1;
1098                                 inlineBlockType = CurlyDelimited;
1099                                 if ( hostLang->lang == HostLang::Ruby )
1100                                         fcall inline_code_ruby;
1101                                 else
1102                                         fcall inline_code;
1103                         }
1104                 };
1105
1106                 EOF => {
1107                         scan_error() << "unterminated ragel section" << endl;
1108                 };
1109
1110                 any => { token( *ts ); } ;
1111         *|;
1112
1113         # Outside code scanner. These tokens get passed through.
1114         main_ruby := |*
1115                 ident => { pass( IMP_Word, ts, te ); };
1116                 number => { pass( IMP_UInt, ts, te ); };
1117                 ruby_comment => { pass(); };
1118                 ( s_literal | d_literal | host_re_literal )
1119                         => { pass( IMP_Literal, ts, te ); };
1120
1121                 '%%{' => {
1122                         updateCol();
1123                         singleLineSpec = false;
1124                         startSection();
1125                         fcall parser_def;
1126                 };
1127                 '%%' => {
1128                         updateCol();
1129                         singleLineSpec = true;
1130                         startSection();
1131                         fcall parser_def;
1132                 };
1133                 whitespace+ => { pass(); };
1134                 EOF;
1135                 any => { pass( *ts, 0, 0 ); };
1136         *|;
1137
1138         # Outside code scanner. These tokens get passed through.
1139         main := |*
1140                 'define' => { pass( IMP_Define, 0, 0 ); };
1141                 ident => { pass( IMP_Word, ts, te ); };
1142                 number => { pass( IMP_UInt, ts, te ); };
1143                 c_cpp_comment => { pass(); };
1144                 ( s_literal | d_literal ) => { pass( IMP_Literal, ts, te ); };
1145
1146                 '%%{' => {
1147                         updateCol();
1148                         singleLineSpec = false;
1149                         startSection();
1150                         fcall parser_def;
1151                 };
1152                 '%%' => {
1153                         updateCol();
1154                         singleLineSpec = true;
1155                         startSection();
1156                         fcall parser_def;
1157                 };
1158                 whitespace+ => { pass(); };
1159                 EOF;
1160                 any => { pass( *ts, 0, 0 ); };
1161         *|;
1162 }%%
1163
1164 %% write data;
1165
1166 void Scanner::do_scan()
1167 {
1168         int bufsize = 8;
1169         char *buf = new char[bufsize];
1170         int cs, act, have = 0;
1171         int top;
1172
1173         /* The stack is two deep, one level for going into ragel defs from the main
1174          * machines which process outside code, and another for going into or literals
1175          * from either a ragel spec, or a regular expression. */
1176         int stack[2];
1177         int curly_count = 0;
1178         bool execute = true;
1179         bool singleLineSpec = false;
1180         InlineBlockType inlineBlockType = CurlyDelimited;
1181
1182         /* Init the section parser and the character scanner. */
1183         init();
1184         %% write init;
1185
1186         /* Set up the start state. FIXME: After 5.20 is released the nocs write
1187          * init option should be used, the main machine eliminated and this statement moved
1188          * above the write init. */
1189         if ( hostLang->lang == HostLang::Ruby )
1190                 cs = rlscan_en_main_ruby;
1191         else
1192                 cs = rlscan_en_main;
1193
1194         while ( execute ) {
1195                 char *p = buf + have;
1196                 int space = bufsize - have;
1197
1198                 if ( space == 0 ) {
1199                         /* We filled up the buffer trying to scan a token. Grow it. */
1200                         bufsize = bufsize * 2;
1201                         char *newbuf = new char[bufsize];
1202
1203                         /* Recompute p and space. */
1204                         p = newbuf + have;
1205                         space = bufsize - have;
1206
1207                         /* Patch up pointers possibly in use. */
1208                         if ( ts != 0 )
1209                                 ts = newbuf + ( ts - buf );
1210                         te = newbuf + ( te - buf );
1211
1212                         /* Copy the new buffer in. */
1213                         memcpy( newbuf, buf, have );
1214                         delete[] buf;
1215                         buf = newbuf;
1216                 }
1217
1218                 input.read( p, space );
1219                 int len = input.gcount();
1220                 char *pe = p + len;
1221
1222                 /* If we see eof then append the eof var. */
1223                 char *eof = 0;
1224                 if ( len == 0 ) {
1225                         eof = pe;
1226                         execute = false;
1227                 }
1228
1229                 %% write exec;
1230
1231                 /* Check if we failed. */
1232                 if ( cs == rlscan_error ) {
1233                         /* Machine failed before finding a token. I'm not yet sure if this
1234                          * is reachable. */
1235                         scan_error() << "scanner error" << endl;
1236                         exit(1);
1237                 }
1238
1239                 /* Decide if we need to preserve anything. */
1240                 char *preserve = ts;
1241
1242                 /* Now set up the prefix. */
1243                 if ( preserve == 0 )
1244                         have = 0;
1245                 else {
1246                         /* There is data that needs to be shifted over. */
1247                         have = pe - preserve;
1248                         memmove( buf, preserve, have );
1249                         unsigned int shiftback = preserve - buf;
1250                         if ( ts != 0 )
1251                                 ts -= shiftback;
1252                         te -= shiftback;
1253
1254                         preserve = buf;
1255                 }
1256         }
1257
1258         delete[] buf;
1259 }