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.line = line;
 417                         inputItem->loc.col = column;
 418                         inputItem->name = parser->sectionName;
 419                         inputItem->pd = parser->pd;
 420                         id.inputItems.append( inputItem );
 421                 }
 422         }
 423
 424         action write_arg
 425         {
 426                 if ( active() && machineSpec == 0 && machineName == 0 )
 427                         id.inputItems.tail->writeArgs.append( strdup(tokdata) );
 428         }
 429
 430         action write_close
 431         {
 432                 if ( active() && machineSpec == 0 && machineName == 0 )
 433                         id.inputItems.tail->writeArgs.append( 0 );
 434         }
 435
 436         write_stmt =
 437                 ( KW_Write @write_command
 438                 ( TK_Word @write_arg )+ ';' @write_close )
 439                 <>err write_err <>eof write_err;
 440
 441         action handle_token
 442         {
 443                 /* Send the token off to the parser. */
 444                 if ( active() )
 445                         directToParser( parser, fileName, line, column, type, tokdata, toklen );
 446         }
 447
 448         # Catch everything else.
 449         everything_else =
 450                 ^( KW_Machine | KW_Include | KW_Import | KW_Write ) @handle_token;
 451
 452         main := (
 453                 machine_stmt |
 454                 include_stmt |
 455                 import_stmt |
 456                 write_stmt |
 457                 everything_else
 458         )*;
 459 }%%
 460
 461 void Scanner::token( int type, char c )
 462 {
 463         token( type, &c, &c + 1 );
 464 }
 465
 466 void Scanner::token( int type )
 467 {
 468         token( type, 0, 0 );
 469 }
 470
 471 void Scanner::token( int type, char *start, char *end )
 472 {
 473         char *tokdata = 0;
 474         int toklen = 0;
 475         if ( start != 0 ) {
 476                 toklen = end-start;
 477                 tokdata = new char[toklen+1];
 478                 memcpy( tokdata, start, toklen );
 479                 tokdata[toklen] = 0;
 480         }
 481
 482         processToken( type, tokdata, toklen );
 483 }
 484
 485 void Scanner::processToken( int type, char *tokdata, int toklen )
 486 {
 487         int *p, *pe, *eof;
 488
 489         if ( type < 0 )
 490                 p = pe = eof = 0;
 491         else {
 492                 p = &type;
 493                 pe = &type + 1;
 494                 eof = 0;
 495         }
 496
 497         %%{
 498                 machine section_parse;
 499                 write exec;
 500         }%%
 501
 502         updateCol();
 503
 504         /* Record the last token for use in controlling the scan of subsequent
 505          * tokens. */
 506         lastToken = type;
 507 }
 508
 509 void Scanner::startSection( )
 510 {
 511         parserExistsError = false;
 512
 513         sectionLoc.fileName = fileName;
 514         sectionLoc.line = line;
 515         sectionLoc.col = column;
 516 }
 517
 518 void Scanner::endSection( )
 519 {
 520         /* Execute the eof actions for the section parser. */
 521         processToken( -1, 0, 0 );
 522
 523         /* Close off the section with the parser. */
 524         if ( active() ) {
 525                 InputLoc loc;
 526                 loc.fileName = fileName;
 527                 loc.line = line;
 528                 loc.col = column;
 529
 530                 parser->token( loc, TK_EndSection, 0, 0 );
 531         }
 532
 533         if ( includeDepth == 0 ) {
 534                 if ( machineSpec == 0 && machineName == 0 ) {
 535                         /* The end section may include a newline on the end, so
 536                          * we use the last line, which will count the newline. */
 537                         InputItem *inputItem = new InputItem;
 538                         inputItem->type = InputItem::HostData;
 539                         inputItem->loc.line = line;
 540                         inputItem->loc.col = column;
 541                         id.inputItems.append( inputItem );
 542                 }
 543         }
 544 }
 545
 546 bool isAbsolutePath( const char *path )
 547 {
 548 #ifdef _WIN32
 549         return isalpha( path[0] ) && path[1] == ':' && path[2] == '\\';
 550 #else
 551         return path[0] == '/';
 552 #endif
 553 }
 554
 555 char **Scanner::makeIncludePathChecks( const char *thisFileName,
 556                 const char *fileName, int fnlen )
 557 {
 558         char **checks = new char*[2];
 559         long nextCheck = 0;
 560
 561         bool caseInsensitive = false;
 562         long length = 0;
 563         char *data = prepareLitString( InputLoc(), fileName, fnlen,
 564                         length, caseInsensitive );
 565
 566         /* Absolute path? */
 567         if ( isAbsolutePath( data ) )
 568                 checks[nextCheck++] = data;
 569         else {
 570                 /* Search from the the location of the current file. */
 571                 const char *lastSlash = strrchr( thisFileName, PATH_SEP );
 572                 if ( lastSlash == 0 )
 573                         checks[nextCheck++] = data;
 574                 else {
 575                         long givenPathLen = (lastSlash - thisFileName) + 1;
 576                         long checklen = givenPathLen + length;
 577                         char *check = new char[checklen+1];
 578                         memcpy( check, thisFileName, givenPathLen );
 579                         memcpy( check+givenPathLen, data, length );
 580                         check[checklen] = 0;
 581                         checks[nextCheck++] = check;
 582                 }
 583
 584                 /* Search from the include paths given on the command line. */
 585                 for ( ArgsVector::Iter incp = id.includePaths; incp.lte(); incp++ ) {
 586                         long pathLen = strlen( *incp );
 587                         long checkLen = pathLen + 1 + length;
 588                         char *check = new char[checkLen+1];
 589                         memcpy( check, *incp, pathLen );
 590                         check[pathLen] = PATH_SEP;
 591                         memcpy( check+pathLen+1, data, length );
 592                         check[checkLen] = 0;
 593                         checks[nextCheck++] = check;
 594                 }
 595         }
 596
 597         checks[nextCheck] = 0;
 598         return checks;
 599 }
 600
 601 ifstream *Scanner::tryOpenInclude( char **pathChecks, long &found )
 602 {
 603         char **check = pathChecks;
 604         ifstream *inFile = new ifstream;
 605
 606         while ( *check != 0 ) {
 607                 inFile->open( *check );
 608                 if ( inFile->is_open() ) {
 609                         found = check - pathChecks;
 610                         return inFile;
 611                 }
 612                 check += 1;
 613         }
 614
 615         found = -1;
 616         delete inFile;
 617         return 0;
 618 }
 619
 620 %%{
 621         machine rlscan;
 622
 623         # This is sent by the driver code.
 624         EOF = 0;
 625
 626         action inc_nl {
 627                 lastnl = p;
 628                 column = 0;
 629                 line++;
 630         }
 631         NL = '\n' @inc_nl;
 632
 633         # Identifiers, numbers, commetns, and other common things.
 634         ident = ( alpha | '_' ) ( alpha |digit |'_' )*;
 635         number = digit+;
 636         hex_number = '0x' [0-9a-fA-F]+;
 637
 638         c_comment =
 639                 '/*' ( any | NL )* :>> '*/';
 640
 641         cpp_comment =
 642                 '//' [^\n]* NL;
 643
 644         c_cpp_comment = c_comment | cpp_comment;
 645
 646         ruby_comment = '#' [^\n]* NL;
 647
 648         # These literal forms are common to host code and ragel.
 649         s_literal = "'" ([^'\\] | NL | '\\' (any | NL))* "'";
 650         d_literal = '"' ([^"\\] | NL | '\\' (any | NL))* '"';
 651         host_re_literal = '/' ([^/\\] | NL | '\\' (any | NL))* '/';
 652
 653         whitespace = [ \t] | NL;
 654         pound_comment = '#' [^\n]* NL;
 655
 656         # An inline block of code for Ruby.
 657         inline_code_ruby := |*
 658                 # Inline expression keywords.
 659                 "fpc" => { token( KW_PChar ); };
 660                 "fc" => { token( KW_Char ); };
 661                 "fcurs" => { token( KW_CurState ); };
 662                 "ftargs" => { token( KW_TargState ); };
 663                 "fentry" => {
 664                         whitespaceOn = false;
 665                         token( KW_Entry );
 666                 };
 667
 668                 # Inline statement keywords.
 669                 "fhold" => {
 670                         whitespaceOn = false;
 671                         token( KW_Hold );
 672                 };
 673                 "fexec" => { token( KW_Exec, 0, 0 ); };
 674                 "fgoto" => {
 675                         whitespaceOn = false;
 676                         token( KW_Goto );
 677                 };
 678                 "fnext" => {
 679                         whitespaceOn = false;
 680                         token( KW_Next );
 681                 };
 682                 "fcall" => {
 683                         whitespaceOn = false;
 684                         token( KW_Call );
 685                 };
 686                 "fret" => {
 687                         whitespaceOn = false;
 688                         token( KW_Ret );
 689                 };
 690                 "fbreak" => {
 691                         whitespaceOn = false;
 692                         token( KW_Break );
 693                 };
 694
 695                 ident => { token( TK_Word, ts, te ); };
 696
 697                 number => { token( TK_UInt, ts, te ); };
 698                 hex_number => { token( TK_Hex, ts, te ); };
 699
 700                 ( s_literal | d_literal | host_re_literal )
 701                         => { token( IL_Literal, ts, te ); };
 702
 703                 whitespace+ => {
 704                         if ( whitespaceOn )
 705                                 token( IL_WhiteSpace, ts, te );
 706                 };
 707
 708                 ruby_comment => { token( IL_Comment, ts, te ); };
 709
 710                 "::" => { token( TK_NameSep, ts, te ); };
 711
 712                 # Some symbols need to go to the parser as with their cardinal value as
 713                 # the token type (as opposed to being sent as anonymous symbols)
 714                 # because they are part of the sequences which we interpret. The * ) ;
 715                 # symbols cause whitespace parsing to come back on. This gets turned
 716                 # off by some keywords.
 717
 718                 ";" => {
 719                         whitespaceOn = true;
 720                         token( *ts, ts, te );
 721                         if ( inlineBlockType == SemiTerminated )
 722                                 fret;
 723                 };
 724
 725                 [*)] => {
 726                         whitespaceOn = true;
 727                         token( *ts, ts, te );
 728                 };
 729
 730                 [,(] => { token( *ts, ts, te ); };
 731
 732                 '{' => {
 733                         token( IL_Symbol, ts, te );
 734                         curly_count += 1;
 735                 };
 736
 737                 '}' => {
 738                         if ( --curly_count == 0 && inlineBlockType == CurlyDelimited ) {
 739                                 /* Inline code block ends. */
 740                                 token( '}' );
 741                                 fret;
 742                         }
 743                         else {
 744                                 /* Either a semi terminated inline block or only the closing
 745                                  * brace of some inner scope, not the block's closing brace. */
 746                                 token( IL_Symbol, ts, te );
 747                         }
 748                 };
 749
 750                 EOF => {
 751                         scan_error() << "unterminated code block" << endl;
 752                 };
 753
 754                 # Send every other character as a symbol.
 755                 any => { token( IL_Symbol, ts, te ); };
 756         *|;
 757
 758
 759         # An inline block of code for languages other than Ruby.
 760         inline_code := |*
 761                 # Inline expression keywords.
 762                 "fpc" => { token( KW_PChar ); };
 763                 "fc" => { token( KW_Char ); };
 764                 "fcurs" => { token( KW_CurState ); };
 765                 "ftargs" => { token( KW_TargState ); };
 766                 "fentry" => {
 767                         whitespaceOn = false;
 768                         token( KW_Entry );
 769                 };
 770
 771                 # Inline statement keywords.
 772                 "fhold" => {
 773                         whitespaceOn = false;
 774                         token( KW_Hold );
 775                 };
 776                 "fexec" => { token( KW_Exec, 0, 0 ); };
 777                 "fgoto" => {
 778                         whitespaceOn = false;
 779                         token( KW_Goto );
 780                 };
 781                 "fnext" => {
 782                         whitespaceOn = false;
 783                         token( KW_Next );
 784                 };
 785                 "fcall" => {
 786                         whitespaceOn = false;
 787                         token( KW_Call );
 788                 };
 789                 "fret" => {
 790                         whitespaceOn = false;
 791                         token( KW_Ret );
 792                 };
 793                 "fbreak" => {
 794                         whitespaceOn = false;
 795                         token( KW_Break );
 796                 };
 797
 798                 ident => { token( TK_Word, ts, te ); };
 799
 800                 number => { token( TK_UInt, ts, te ); };
 801                 hex_number => { token( TK_Hex, ts, te ); };
 802
 803                 ( s_literal | d_literal )
 804                         => { token( IL_Literal, ts, te ); };
 805
 806                 whitespace+ => {
 807                         if ( whitespaceOn )
 808                                 token( IL_WhiteSpace, ts, te );
 809                 };
 810
 811                 c_cpp_comment => { token( IL_Comment, ts, te ); };
 812
 813                 "::" => { token( TK_NameSep, ts, te ); };
 814
 815                 # Some symbols need to go to the parser as with their cardinal value as
 816                 # the token type (as opposed to being sent as anonymous symbols)
 817                 # because they are part of the sequences which we interpret. The * ) ;
 818                 # symbols cause whitespace parsing to come back on. This gets turned
 819                 # off by some keywords.
 820
 821                 ";" => {
 822                         whitespaceOn = true;
 823                         token( *ts, ts, te );
 824                         if ( inlineBlockType == SemiTerminated )
 825                                 fret;
 826                 };
 827
 828                 [*)] => {
 829                         whitespaceOn = true;
 830                         token( *ts, ts, te );
 831                 };
 832
 833                 [,(] => { token( *ts, ts, te ); };
 834
 835                 '{' => {
 836                         token( IL_Symbol, ts, te );
 837                         curly_count += 1;
 838                 };
 839
 840                 '}' => {
 841                         if ( --curly_count == 0 && inlineBlockType == CurlyDelimited ) {
 842                                 /* Inline code block ends. */
 843                                 token( '}' );
 844                                 fret;
 845                         }
 846                         else {
 847                                 /* Either a semi terminated inline block or only the closing
 848                                  * brace of some inner scope, not the block's closing brace. */
 849                                 token( IL_Symbol, ts, te );
 850                         }
 851                 };
 852
 853                 EOF => {
 854                         scan_error() << "unterminated code block" << endl;
 855                 };
 856
 857                 # Send every other character as a symbol.
 858                 any => { token( IL_Symbol, ts, te ); };
 859         *|;
 860
 861         or_literal := |*
 862                 # Escape sequences in OR expressions.
 863                 '\\0' => { token( RE_Char, '\0' ); };
 864                 '\\a' => { token( RE_Char, '\a' ); };
 865                 '\\b' => { token( RE_Char, '\b' ); };
 866                 '\\t' => { token( RE_Char, '\t' ); };
 867                 '\\n' => { token( RE_Char, '\n' ); };
 868                 '\\v' => { token( RE_Char, '\v' ); };
 869                 '\\f' => { token( RE_Char, '\f' ); };
 870                 '\\r' => { token( RE_Char, '\r' ); };
 871                 '\\\n' => { updateCol(); };
 872                 '\\' any => { token( RE_Char, ts+1, te ); };
 873
 874                 # Range dash in an OR expression.
 875                 '-' => { token( RE_Dash, 0, 0 ); };
 876
 877                 # Terminate an OR expression.
 878                 ']'     => { token( RE_SqClose ); fret; };
 879
 880                 EOF => {
 881                         scan_error() << "unterminated OR literal" << endl;
 882                 };
 883
 884                 # Characters in an OR expression.
 885                 [^\]] => { token( RE_Char, ts, te ); };
 886
 887         *|;
 888
 889         ragel_re_literal := |*
 890                 # Escape sequences in regular expressions.
 891                 '\\0' => { token( RE_Char, '\0' ); };
 892                 '\\a' => { token( RE_Char, '\a' ); };
 893                 '\\b' => { token( RE_Char, '\b' ); };
 894                 '\\t' => { token( RE_Char, '\t' ); };
 895                 '\\n' => { token( RE_Char, '\n' ); };
 896                 '\\v' => { token( RE_Char, '\v' ); };
 897                 '\\f' => { token( RE_Char, '\f' ); };
 898                 '\\r' => { token( RE_Char, '\r' ); };
 899                 '\\\n' => { updateCol(); };
 900                 '\\' any => { token( RE_Char, ts+1, te ); };
 901
 902                 # Terminate an OR expression.
 903                 '/' [i]? => {
 904                         token( RE_Slash, ts, te );
 905                         fgoto parser_def;
 906                 };
 907
 908                 # Special characters.
 909                 '.' => { token( RE_Dot ); };
 910                 '*' => { token( RE_Star ); };
 911
 912                 '[' => { token( RE_SqOpen ); fcall or_literal; };
 913                 '[^' => { token( RE_SqOpenNeg ); fcall or_literal; };
 914
 915                 EOF => {
 916                         scan_error() << "unterminated regular expression" << endl;
 917                 };
 918
 919                 # Characters in an OR expression.
 920                 [^\/] => { token( RE_Char, ts, te ); };
 921         *|;
 922
 923         # We need a separate token space here to avoid the ragel keywords.
 924         write_statement := |*
 925                 ident => { token( TK_Word, ts, te ); } ;
 926                 [ \t\n]+ => { updateCol(); };
 927                 ';' => { token( ';' ); fgoto parser_def; };
 928
 929                 EOF => {
 930                         scan_error() << "unterminated write statement" << endl;
 931                 };
 932         *|;
 933
 934         # Parser definitions.
 935         parser_def := |*
 936                 'length_cond' => { token( KW_Length ); };
 937                 'machine' => { token( KW_Machine ); };
 938                 'include' => { token( KW_Include ); };
 939                 'import' => { token( KW_Import ); };
 940                 'write' => {
 941                         token( KW_Write );
 942                         fgoto write_statement;
 943                 };
 944                 'action' => { token( KW_Action ); };
 945                 'alphtype' => { token( KW_AlphType ); };
 946                 'prepush' => { token( KW_PrePush ); };
 947                 'postpop' => { token( KW_PostPop ); };
 948
 949                 # FIXME: Enable this post 5.17.
 950                 # 'range' => { token( KW_Range ); };
 951
 952                 'getkey' => {
 953                         token( KW_GetKey );
 954                         inlineBlockType = SemiTerminated;
 955                         if ( hostLang->lang == HostLang::Ruby )
 956                                 fcall inline_code_ruby;
 957                         else
 958                                 fcall inline_code;
 959                 };
 960                 'access' => {
 961                         token( KW_Access );
 962                         inlineBlockType = SemiTerminated;
 963                         if ( hostLang->lang == HostLang::Ruby )
 964                                 fcall inline_code_ruby;
 965                         else
 966                                 fcall inline_code;
 967                 };
 968                 'variable' => {
 969                         token( KW_Variable );
 970                         inlineBlockType = SemiTerminated;
 971                         if ( hostLang->lang == HostLang::Ruby )
 972                                 fcall inline_code_ruby;
 973                         else
 974                                 fcall inline_code;
 975                 };
 976                 'when' => { token( KW_When ); };
 977                 'inwhen' => { token( KW_InWhen ); };
 978                 'outwhen' => { token( KW_OutWhen ); };
 979                 'eof' => { token( KW_Eof ); };
 980                 'err' => { token( KW_Err ); };
 981                 'lerr' => { token( KW_Lerr ); };
 982                 'to' => { token( KW_To ); };
 983                 'from' => { token( KW_From ); };
 984                 'export' => { token( KW_Export ); };
 985
 986                 # Identifiers.
 987                 ident => { token( TK_Word, ts, te ); } ;
 988
 989                 # Numbers
 990                 number => { token( TK_UInt, ts, te ); };
 991                 hex_number => { token( TK_Hex, ts, te ); };
 992
 993                 # Literals, with optionals.
 994                 ( s_literal | d_literal ) [i]?
 995                         => { token( TK_Literal, ts, te ); };
 996
 997                 '[' => { token( RE_SqOpen ); fcall or_literal; };
 998                 '[^' => { token( RE_SqOpenNeg ); fcall or_literal; };
 999
1000                 '/' => { token( RE_Slash ); fgoto ragel_re_literal; };
1001
1002                 # Ignore.
1003                 pound_comment => { updateCol(); };
1004
1005                 ':=' => { token( TK_ColonEquals ); };
1006
1007                 # To State Actions.
1008                 ">~" => { token( TK_StartToState ); };
1009                 "$~" => { token( TK_AllToState ); };
1010                 "%~" => { token( TK_FinalToState ); };
1011                 "<~" => { token( TK_NotStartToState ); };
1012                 "@~" => { token( TK_NotFinalToState ); };
1013                 "<>~" => { token( TK_MiddleToState ); };
1014
1015                 # From State actions
1016                 ">*" => { token( TK_StartFromState ); };
1017                 "$*" => { token( TK_AllFromState ); };
1018                 "%*" => { token( TK_FinalFromState ); };
1019                 "<*" => { token( TK_NotStartFromState ); };
1020                 "@*" => { token( TK_NotFinalFromState ); };
1021                 "<>*" => { token( TK_MiddleFromState ); };
1022
1023                 # EOF Actions.
1024                 ">/" => { token( TK_StartEOF ); };
1025                 "$/" => { token( TK_AllEOF ); };
1026                 "%/" => { token( TK_FinalEOF ); };
1027                 "</" => { token( TK_NotStartEOF ); };
1028                 "@/" => { token( TK_NotFinalEOF ); };
1029                 "<>/" => { token( TK_MiddleEOF ); };
1030
1031                 # Global Error actions.
1032                 ">!" => { token( TK_StartGblError ); };
1033                 "$!" => { token( TK_AllGblError ); };
1034                 "%!" => { token( TK_FinalGblError ); };
1035                 "<!" => { token( TK_NotStartGblError ); };
1036                 "@!" => { token( TK_NotFinalGblError ); };
1037                 "<>!" => { token( TK_MiddleGblError ); };
1038
1039                 # Local error actions.
1040                 ">^" => { token( TK_StartLocalError ); };
1041                 "$^" => { token( TK_AllLocalError ); };
1042                 "%^" => { token( TK_FinalLocalError ); };
1043                 "<^" => { token( TK_NotStartLocalError ); };
1044                 "@^" => { token( TK_NotFinalLocalError ); };
1045                 "<>^" => { token( TK_MiddleLocalError ); };
1046
1047                 # Middle.
1048                 "<>" => { token( TK_Middle ); };
1049
1050                 # Conditions.
1051                 '>?' => { token( TK_StartCond ); };
1052                 '$?' => { token( TK_AllCond ); };
1053                 '%?' => { token( TK_LeavingCond ); };
1054
1055                 '..' => { token( TK_DotDot ); };
1056                 '**' => { token( TK_StarStar ); };
1057                 '--' => { token( TK_DashDash ); };
1058                 '->' => { token( TK_Arrow ); };
1059                 '=>' => { token( TK_DoubleArrow ); };
1060
1061                 ":>"  => { token( TK_ColonGt ); };
1062                 ":>>" => { token( TK_ColonGtGt ); };
1063                 "<:"  => { token( TK_LtColon ); };
1064
1065                 # Opening of longest match.
1066                 "|*" => { token( TK_BarStar ); };
1067
1068                 # Separater for name references.
1069                 "::" => { token( TK_NameSep, ts, te ); };
1070
1071                 '}%%' => {
1072                         updateCol();
1073                         endSection();
1074                         fret;
1075                 };
1076
1077                 [ \t\r]+ => { updateCol(); };
1078
1079                 # If we are in a single line machine then newline may end the spec.
1080                 NL => {
1081                         updateCol();
1082                         if ( singleLineSpec ) {
1083                                 endSection();
1084                                 fret;
1085                         }
1086                 };
1087
1088                 '{' => {
1089                         if ( lastToken == KW_Export || lastToken == KW_Entry )
1090                                 token( '{' );
1091                         else {
1092                                 token( '{' );
1093                                 curly_count = 1;
1094                                 inlineBlockType = CurlyDelimited;
1095                                 if ( hostLang->lang == HostLang::Ruby )
1096                                         fcall inline_code_ruby;
1097                                 else
1098                                         fcall inline_code;
1099                         }
1100                 };
1101
1102                 EOF => {
1103                         scan_error() << "unterminated ragel section" << endl;
1104                 };
1105
1106                 any => { token( *ts ); } ;
1107         *|;
1108
1109         # Outside code scanner. These tokens get passed through.
1110         main_ruby := |*
1111                 ident => { pass( IMP_Word, ts, te ); };
1112                 number => { pass( IMP_UInt, ts, te ); };
1113                 ruby_comment => { pass(); };
1114                 ( s_literal | d_literal | host_re_literal )
1115                         => { pass( IMP_Literal, ts, te ); };
1116
1117                 '%%{' => {
1118                         updateCol();
1119                         singleLineSpec = false;
1120                         startSection();
1121                         fcall parser_def;
1122                 };
1123                 '%%' => {
1124                         updateCol();
1125                         singleLineSpec = true;
1126                         startSection();
1127                         fcall parser_def;
1128                 };
1129                 whitespace+ => { pass(); };
1130                 EOF;
1131                 any => { pass( *ts, 0, 0 ); };
1132         *|;
1133
1134         # Outside code scanner. These tokens get passed through.
1135         main := |*
1136                 'define' => { pass( IMP_Define, 0, 0 ); };
1137                 ident => { pass( IMP_Word, ts, te ); };
1138                 number => { pass( IMP_UInt, ts, te ); };
1139                 c_cpp_comment => { pass(); };
1140                 ( s_literal | d_literal ) => { pass( IMP_Literal, ts, te ); };
1141
1142                 '%%{' => {
1143                         updateCol();
1144                         singleLineSpec = false;
1145                         startSection();
1146                         fcall parser_def;
1147                 };
1148                 '%%' => {
1149                         updateCol();
1150                         singleLineSpec = true;
1151                         startSection();
1152                         fcall parser_def;
1153                 };
1154                 whitespace+ => { pass(); };
1155                 EOF;
1156                 any => { pass( *ts, 0, 0 ); };
1157         *|;
1158 }%%
1159
1160 %% write data;
1161
1162 void Scanner::do_scan()
1163 {
1164         int bufsize = 8;
1165         char *buf = new char[bufsize];
1166         int cs, act, have = 0;
1167         int top;
1168
1169         /* The stack is two deep, one level for going into ragel defs from the main
1170          * machines which process outside code, and another for going into or literals
1171          * from either a ragel spec, or a regular expression. */
1172         int stack[2];
1173         int curly_count = 0;
1174         bool execute = true;
1175         bool singleLineSpec = false;
1176         InlineBlockType inlineBlockType = CurlyDelimited;
1177
1178         /* Init the section parser and the character scanner. */
1179         init();
1180         %% write init;
1181
1182         /* Set up the start state. FIXME: After 5.20 is released the nocs write
1183          * init option should be used, the main machine eliminated and this statement moved
1184          * above the write init. */
1185         if ( hostLang->lang == HostLang::Ruby )
1186                 cs = rlscan_en_main_ruby;
1187         else
1188                 cs = rlscan_en_main;
1189
1190         while ( execute ) {
1191                 char *p = buf + have;
1192                 int space = bufsize - have;
1193
1194                 if ( space == 0 ) {
1195                         /* We filled up the buffer trying to scan a token. Grow it. */
1196                         bufsize = bufsize * 2;
1197                         char *newbuf = new char[bufsize];
1198
1199                         /* Recompute p and space. */
1200                         p = newbuf + have;
1201                         space = bufsize - have;
1202
1203                         /* Patch up pointers possibly in use. */
1204                         if ( ts != 0 )
1205                                 ts = newbuf + ( ts - buf );
1206                         te = newbuf + ( te - buf );
1207
1208                         /* Copy the new buffer in. */
1209                         memcpy( newbuf, buf, have );
1210                         delete[] buf;
1211                         buf = newbuf;
1212                 }
1213
1214                 input.read( p, space );
1215                 int len = input.gcount();
1216                 char *pe = p + len;
1217
1218                 /* If we see eof then append the eof var. */
1219                 char *eof = 0;
1220                 if ( len == 0 ) {
1221                         eof = pe;
1222                         execute = false;
1223                 }
1224
1225                 %% write exec;
1226
1227                 /* Check if we failed. */
1228                 if ( cs == rlscan_error ) {
1229                         /* Machine failed before finding a token. I'm not yet sure if this
1230                          * is reachable. */
1231                         scan_error() << "scanner error" << endl;
1232                         exit(1);
1233                 }
1234
1235                 /* Decide if we need to preserve anything. */
1236                 char *preserve = ts;
1237
1238                 /* Now set up the prefix. */
1239                 if ( preserve == 0 )
1240                         have = 0;
1241                 else {
1242                         /* There is data that needs to be shifted over. */
1243                         have = pe - preserve;
1244                         memmove( buf, preserve, have );
1245                         unsigned int shiftback = preserve - buf;
1246                         if ( ts != 0 )
1247                                 ts -= shiftback;
1248                         te -= shiftback;
1249
1250                         preserve = buf;
1251                 }
1252         }
1253
1254         delete[] buf;
1255 }