ragel/rlscan.cpp

   1
   2 #line 1 "rlscan.rl"
   3 /*
   4  *  Copyright 2006-2007 Adrian Thurston <thurston@complang.org>
   5  */
   6
   7 /*  This file is part of Ragel.
   8  *
   9  *  Ragel is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  Ragel is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with Ragel; if not, write to the Free Software
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 #include <iostream>
  25 #include <fstream>
  26 #include <string.h>
  27
  28 #include "ragel.h"
  29 #include "rlscan.h"
  30 #include "inputdata.h"
  31
  32 //#define LOG_TOKENS
  33
  34 using std::ifstream;
  35 using std::istream;
  36 using std::ostream;
  37 using std::cout;
  38 using std::cerr;
  39 using std::endl;
  40
  41 enum InlineBlockType
  42 {
  43         CurlyDelimited,
  44         SemiTerminated
  45 };
  46
  47 #ifdef _WIN32
  48 #define PATH_SEP '\\'
  49 #else
  50 #define PATH_SEP '/'
  51 #endif
  52
  53
  54 /*
  55  * The Scanner for Importing
  56  */
  57
  58
  59 #line 124 "rlscan.rl"
  60
  61
  62
  63 #line 64 "rlscan.cpp"
  64 static const int inline_token_scan_start = 2;
  65 static const int inline_token_scan_first_final = 2;
  66 static const int inline_token_scan_error = -1;
  67
  68 static const int inline_token_scan_en_main = 2;
  69
  70
  71 #line 127 "rlscan.rl"
  72
  73 void Scanner::flushImport()
  74 {
  75         int *p = token_data;
  76         int *pe = token_data + cur_token;
  77         int *eof = 0;
  78
  79
  80 #line 81 "rlscan.cpp"
  81         {
  82          tok_cs = inline_token_scan_start;
  83          tok_ts = 0;
  84          tok_te = 0;
  85          tok_act = 0;
  86         }
  87
  88 #line 89 "rlscan.cpp"
  89         {
  90         if ( p == pe )
  91                 goto _test_eof;
  92         switch (  tok_cs )
  93         {
  94 tr0:
  95 #line 122 "rlscan.rl"
  96         {{p = (( tok_te))-1;}}
  97         goto st2;
  98 tr1:
  99 #line 108 "rlscan.rl"
 100         { tok_te = p+1;{
 101                         int base = tok_ts - token_data;
 102                         int nameOff = 0;
 103                         int litOff = 2;
 104
 105                         directToParser( inclToParser, fileName, line, column, TK_Word,
 106                                         token_strings[base+nameOff], token_lens[base+nameOff] );
 107                         directToParser( inclToParser, fileName, line, column, '=', 0, 0 );
 108                         directToParser( inclToParser, fileName, line, column, TK_Literal,
 109                                         token_strings[base+litOff], token_lens[base+litOff] );
 110                         directToParser( inclToParser, fileName, line, column, ';', 0, 0 );
 111                 }}
 112         goto st2;
 113 tr2:
 114 #line 80 "rlscan.rl"
 115         { tok_te = p+1;{
 116                         int base = tok_ts - token_data;
 117                         int nameOff = 0;
 118                         int numOff = 2;
 119
 120                         directToParser( inclToParser, fileName, line, column, TK_Word,
 121                                         token_strings[base+nameOff], token_lens[base+nameOff] );
 122                         directToParser( inclToParser, fileName, line, column, '=', 0, 0 );
 123                         directToParser( inclToParser, fileName, line, column, TK_UInt,
 124                                         token_strings[base+numOff], token_lens[base+numOff] );
 125                         directToParser( inclToParser, fileName, line, column, ';', 0, 0 );
 126                 }}
 127         goto st2;
 128 tr3:
 129 #line 94 "rlscan.rl"
 130         { tok_te = p+1;{
 131                         int base = tok_ts - token_data;
 132                         int nameOff = 1;
 133                         int litOff = 2;
 134
 135                         directToParser( inclToParser, fileName, line, column, TK_Word,
 136                                         token_strings[base+nameOff], token_lens[base+nameOff] );
 137                         directToParser( inclToParser, fileName, line, column, '=', 0, 0 );
 138                         directToParser( inclToParser, fileName, line, column, TK_Literal,
 139                                         token_strings[base+litOff], token_lens[base+litOff] );
 140                         directToParser( inclToParser, fileName, line, column, ';', 0, 0 );
 141                 }}
 142         goto st2;
 143 tr4:
 144 #line 66 "rlscan.rl"
 145         { tok_te = p+1;{
 146                         int base = tok_ts - token_data;
 147                         int nameOff = 1;
 148                         int numOff = 2;
 149
 150                         directToParser( inclToParser, fileName, line, column, TK_Word,
 151                                         token_strings[base+nameOff], token_lens[base+nameOff] );
 152                         directToParser( inclToParser, fileName, line, column, '=', 0, 0 );
 153                         directToParser( inclToParser, fileName, line, column, TK_UInt,
 154                                         token_strings[base+numOff], token_lens[base+numOff] );
 155                         directToParser( inclToParser, fileName, line, column, ';', 0, 0 );
 156                 }}
 157         goto st2;
 158 tr5:
 159 #line 122 "rlscan.rl"
 160         { tok_te = p+1;}
 161         goto st2;
 162 tr8:
 163 #line 122 "rlscan.rl"
 164         { tok_te = p;p--;}
 165         goto st2;
 166 st2:
 167 #line 1 "rlscan.rl"
 168         { tok_ts = 0;}
 169         if ( ++p == pe )
 170                 goto _test_eof2;
 171 case 2:
 172 #line 1 "rlscan.rl"
 173         { tok_ts = p;}
 174 #line 175 "rlscan.cpp"
 175         switch( (*p) ) {
 176                 case 128: goto tr6;
 177                 case 131: goto tr7;
 178         }
 179         goto tr5;
 180 tr6:
 181 #line 1 "rlscan.rl"
 182         { tok_te = p+1;}
 183         goto st3;
 184 st3:
 185         if ( ++p == pe )
 186                 goto _test_eof3;
 187 case 3:
 188 #line 189 "rlscan.cpp"
 189         if ( (*p) == 61 )
 190                 goto st0;
 191         goto tr8;
 192 st0:
 193         if ( ++p == pe )
 194                 goto _test_eof0;
 195 case 0:
 196         switch( (*p) ) {
 197                 case 129: goto tr1;
 198                 case 130: goto tr2;
 199         }
 200         goto tr0;
 201 tr7:
 202 #line 1 "rlscan.rl"
 203         { tok_te = p+1;}
 204         goto st4;
 205 st4:
 206         if ( ++p == pe )
 207                 goto _test_eof4;
 208 case 4:
 209 #line 210 "rlscan.cpp"
 210         if ( (*p) == 128 )
 211                 goto st1;
 212         goto tr8;
 213 st1:
 214         if ( ++p == pe )
 215                 goto _test_eof1;
 216 case 1:
 217         switch( (*p) ) {
 218                 case 129: goto tr3;
 219                 case 130: goto tr4;
 220         }
 221         goto tr0;
 222         }
 223         _test_eof2:  tok_cs = 2; goto _test_eof;
 224         _test_eof3:  tok_cs = 3; goto _test_eof;
 225         _test_eof0:  tok_cs = 0; goto _test_eof;
 226         _test_eof4:  tok_cs = 4; goto _test_eof;
 227         _test_eof1:  tok_cs = 1; goto _test_eof;
 228
 229         _test_eof: {}
 230         if ( p == eof )
 231         {
 232         switch (  tok_cs ) {
 233         case 3: goto tr8;
 234         case 0: goto tr0;
 235         case 4: goto tr8;
 236         case 1: goto tr0;
 237         }
 238         }
 239
 240         }
 241
 242 #line 138 "rlscan.rl"
 243
 244
 245         if ( tok_ts == 0 )
 246                 cur_token = 0;
 247         else {
 248                 cur_token = pe - tok_ts;
 249                 int ts_offset = tok_ts - token_data;
 250                 memmove( token_data, token_data+ts_offset, cur_token*sizeof(token_data[0]) );
 251                 memmove( token_strings, token_strings+ts_offset, cur_token*sizeof(token_strings[0]) );
 252                 memmove( token_lens, token_lens+ts_offset, cur_token*sizeof(token_lens[0]) );
 253         }
 254 }
 255
 256 void Scanner::directToParser( Parser *toParser, const char *tokFileName, int tokLine,
 257                 int tokColumn, int type, char *tokdata, int toklen )
 258 {
 259         InputLoc loc;
 260
 261         #ifdef LOG_TOKENS
 262         cerr << "scanner:" << tokLine << ":" << tokColumn <<
 263                         ": sending token to the parser " << Parser_lelNames[type];
 264         cerr << " " << toklen;
 265         if ( tokdata != 0 )
 266                 cerr << " " << tokdata;
 267         cerr << endl;
 268         #endif
 269
 270         loc.fileName = tokFileName;
 271         loc.line = tokLine;
 272         loc.col = tokColumn;
 273
 274         toParser->token( loc, type, tokdata, toklen );
 275 }
 276
 277 void Scanner::importToken( int token, char *start, char *end )
 278 {
 279         if ( cur_token == max_tokens )
 280                 flushImport();
 281
 282         token_data[cur_token] = token;
 283         if ( start == 0 ) {
 284                 token_strings[cur_token] = 0;
 285                 token_lens[cur_token] = 0;
 286         }
 287         else {
 288                 int toklen = end-start;
 289                 token_lens[cur_token] = toklen;
 290                 token_strings[cur_token] = new char[toklen+1];
 291                 memcpy( token_strings[cur_token], start, toklen );
 292                 token_strings[cur_token][toklen] = 0;
 293         }
 294         cur_token++;
 295 }
 296
 297 void Scanner::pass( int token, char *start, char *end )
 298 {
 299         if ( importMachines )
 300                 importToken( token, start, end );
 301         pass();
 302 }
 303
 304 void Scanner::pass()
 305 {
 306         updateCol();
 307
 308         /* If no errors and we are at the bottom of the include stack (the
 309          * source file listed on the command line) then write out the data. */
 310         if ( includeDepth == 0 && machineSpec == 0 && machineName == 0 )
 311                 id.inputItems.tail->data.write( ts, te-ts );
 312 }
 313
 314 /*
 315  * The scanner for processing sections, includes, imports, etc.
 316  */
 317
 318
 319 #line 320 "rlscan.cpp"
 320 static const int section_parse_start = 10;
 321 static const int section_parse_first_final = 10;
 322 static const int section_parse_error = 0;
 323
 324 static const int section_parse_en_main = 10;
 325
 326
 327 #line 217 "rlscan.rl"
 328
 329
 330
 331 void Scanner::init( )
 332 {
 333
 334 #line 335 "rlscan.cpp"
 335         {
 336         cs = section_parse_start;
 337         }
 338
 339 #line 223 "rlscan.rl"
 340 }
 341
 342 bool Scanner::active()
 343 {
 344         if ( ignoreSection )
 345                 return false;
 346
 347         if ( parser == 0 && ! parserExistsError ) {
 348                 scan_error() << "this specification has no name, nor does any previous"
 349                         " specification" << endl;
 350                 parserExistsError = true;
 351         }
 352
 353         if ( parser == 0 )
 354                 return false;
 355
 356         return true;
 357 }
 358
 359 ostream &Scanner::scan_error()
 360 {
 361         /* Maintain the error count. */
 362         gblErrorCount += 1;
 363         cerr << makeInputLoc( fileName, line, column ) << ": ";
 364         return cerr;
 365 }
 366
 367 /* An approximate check for duplicate includes. Due to aliasing of files it's
 368  * possible for duplicates to creep in. */
 369 bool Scanner::duplicateInclude( char *inclFileName, char *inclSectionName )
 370 {
 371         for ( IncludeHistory::Iter hi = parser->includeHistory; hi.lte(); hi++ ) {
 372                 if ( strcmp( hi->fileName, inclFileName ) == 0 &&
 373                                 strcmp( hi->sectionName, inclSectionName ) == 0 )
 374                 {
 375                         return true;
 376                 }
 377         }
 378         return false;
 379 }
 380
 381 void Scanner::updateCol()
 382 {
 383         char *from = lastnl;
 384         if ( from == 0 )
 385                 from = ts;
 386         //cerr << "adding " << te - from << " to column" << endl;
 387         column += te - from;
 388         lastnl = 0;
 389 }
 390
 391 void Scanner::handleMachine()
 392 {
 393         /* Assign a name to the machine. */
 394         char *machine = word;
 395
 396         if ( !importMachines && inclSectionTarg == 0 ) {
 397                 ignoreSection = false;
 398
 399                 ParserDictEl *pdEl = id.parserDict.find( machine );
 400                 if ( pdEl == 0 ) {
 401                         pdEl = new ParserDictEl( machine );
 402                         pdEl->value = new Parser( fileName, machine, sectionLoc );
 403                         pdEl->value->init();
 404                         id.parserDict.insert( pdEl );
 405                         id.parserList.append( pdEl->value );
 406                 }
 407
 408                 parser = pdEl->value;
 409         }
 410         else if ( !importMachines && strcmp( inclSectionTarg, machine ) == 0 ) {
 411                 /* found include target */
 412                 ignoreSection = false;
 413                 parser = inclToParser;
 414         }
 415         else {
 416                 /* ignoring section */
 417                 ignoreSection = true;
 418                 parser = 0;
 419         }
 420 }
 421
 422 void Scanner::handleInclude()
 423 {
 424         if ( active() ) {
 425                 char *inclSectionName = word;
 426                 char **includeChecks = 0;
 427
 428                 /* Implement defaults for the input file and section name. */
 429                 if ( inclSectionName == 0 )
 430                         inclSectionName = parser->sectionName;
 431
 432                 if ( lit != 0 )
 433                         includeChecks = makeIncludePathChecks( fileName, lit, lit_len );
 434                 else {
 435                         char *test = new char[strlen(fileName)+1];
 436                         strcpy( test, fileName );
 437
 438                         includeChecks = new char*[2];
 439
 440                         includeChecks[0] = test;
 441                         includeChecks[1] = 0;
 442                 }
 443
 444                 long found = 0;
 445                 ifstream *inFile = tryOpenInclude( includeChecks, found );
 446                 if ( inFile == 0 ) {
 447                         scan_error() << "include: failed to locate file" << endl;
 448                         char **tried = includeChecks;
 449                         while ( *tried != 0 )
 450                                 scan_error() << "include: attempted: \"" << *tried++ << '\"' << endl;
 451                 }
 452                 else {
 453                         /* Don't include anything that's already been included. */
 454                         if ( !duplicateInclude( includeChecks[found], inclSectionName ) ) {
 455                                 parser->includeHistory.append( IncludeHistoryItem(
 456                                                 includeChecks[found], inclSectionName ) );
 457
 458                                 Scanner scanner( id, includeChecks[found], *inFile, parser,
 459                                                 inclSectionName, includeDepth+1, false );
 460                                 scanner.do_scan( );
 461                                 delete inFile;
 462                         }
 463                 }
 464         }
 465 }
 466
 467 void Scanner::handleImport()
 468 {
 469         if ( active() ) {
 470                 char **importChecks = makeIncludePathChecks( fileName, lit, lit_len );
 471
 472                 /* Open the input file for reading. */
 473                 long found = 0;
 474                 ifstream *inFile = tryOpenInclude( importChecks, found );
 475                 if ( inFile == 0 ) {
 476                         scan_error() << "import: could not open import file " <<
 477                                         "for reading" << endl;
 478                         char **tried = importChecks;
 479                         while ( *tried != 0 )
 480                                 scan_error() << "import: attempted: \"" << *tried++ << '\"' << endl;
 481                 }
 482
 483                 Scanner scanner( id, importChecks[found], *inFile, parser,
 484                                 0, includeDepth+1, true );
 485                 scanner.do_scan( );
 486                 scanner.importToken( 0, 0, 0 );
 487                 scanner.flushImport();
 488                 delete inFile;
 489         }
 490 }
 491
 492
 493 #line 460 "rlscan.rl"
 494
 495
 496 void Scanner::token( int type, char c )
 497 {
 498         token( type, &c, &c + 1 );
 499 }
 500
 501 void Scanner::token( int type )
 502 {
 503         token( type, 0, 0 );
 504 }
 505
 506 void Scanner::token( int type, char *start, char *end )
 507 {
 508         char *tokdata = 0;
 509         int toklen = 0;
 510         if ( start != 0 ) {
 511                 toklen = end-start;
 512                 tokdata = new char[toklen+1];
 513                 memcpy( tokdata, start, toklen );
 514                 tokdata[toklen] = 0;
 515         }
 516
 517         processToken( type, tokdata, toklen );
 518 }
 519
 520 void Scanner::processToken( int type, char *tokdata, int toklen )
 521 {
 522         int *p, *pe, *eof;
 523
 524         if ( type < 0 )
 525                 p = pe = eof = 0;
 526         else {
 527                 p = &type;
 528                 pe = &type + 1;
 529                 eof = 0;
 530         }
 531
 532
 533 #line 534 "rlscan.cpp"
 534         {
 535         if ( p == pe )
 536                 goto _test_eof;
 537         switch ( cs )
 538         {
 539 tr2:
 540 #line 390 "rlscan.rl"
 541         { handleMachine(); }
 542         goto st10;
 543 tr6:
 544 #line 391 "rlscan.rl"
 545         { handleInclude(); }
 546         goto st10;
 547 tr10:
 548 #line 392 "rlscan.rl"
 549         { handleImport(); }
 550         goto st10;
 551 tr13:
 552 #line 432 "rlscan.rl"
 553         {
 554                 if ( active() && machineSpec == 0 && machineName == 0 )
 555                         id.inputItems.tail->writeArgs.append( 0 );
 556         }
 557         goto st10;
 558 tr14:
 559 #line 443 "rlscan.rl"
 560         {
 561                 /* Send the token off to the parser. */
 562                 if ( active() )
 563                         directToParser( parser, fileName, line, column, type, tokdata, toklen );
 564         }
 565         goto st10;
 566 st10:
 567         if ( ++p == pe )
 568                 goto _test_eof10;
 569 case 10:
 570 #line 571 "rlscan.cpp"
 571         switch( (*p) ) {
 572                 case 191: goto st1;
 573                 case 192: goto st3;
 574                 case 193: goto st6;
 575                 case 194: goto tr18;
 576         }
 577         goto tr14;
 578 st1:
 579         if ( ++p == pe )
 580                 goto _test_eof1;
 581 case 1:
 582         if ( (*p) == 128 )
 583                 goto tr1;
 584         goto tr0;
 585 tr0:
 586 #line 385 "rlscan.rl"
 587         { scan_error() << "bad machine statement" << endl; }
 588         goto st0;
 589 tr3:
 590 #line 386 "rlscan.rl"
 591         { scan_error() << "bad include statement" << endl; }
 592         goto st0;
 593 tr8:
 594 #line 387 "rlscan.rl"
 595         { scan_error() << "bad import statement" << endl; }
 596         goto st0;
 597 tr11:
 598 #line 388 "rlscan.rl"
 599         { scan_error() << "bad write statement" << endl; }
 600         goto st0;
 601 #line 602 "rlscan.cpp"
 602 st0:
 603 cs = 0;
 604         goto _out;
 605 tr1:
 606 #line 382 "rlscan.rl"
 607         { word = tokdata; word_len = toklen; }
 608         goto st2;
 609 st2:
 610         if ( ++p == pe )
 611                 goto _test_eof2;
 612 case 2:
 613 #line 614 "rlscan.cpp"
 614         if ( (*p) == 59 )
 615                 goto tr2;
 616         goto tr0;
 617 st3:
 618         if ( ++p == pe )
 619                 goto _test_eof3;
 620 case 3:
 621         switch( (*p) ) {
 622                 case 128: goto tr4;
 623                 case 129: goto tr5;
 624         }
 625         goto tr3;
 626 tr4:
 627 #line 381 "rlscan.rl"
 628         { word = lit = 0; word_len = lit_len = 0; }
 629 #line 382 "rlscan.rl"
 630         { word = tokdata; word_len = toklen; }
 631         goto st4;
 632 st4:
 633         if ( ++p == pe )
 634                 goto _test_eof4;
 635 case 4:
 636 #line 637 "rlscan.cpp"
 637         switch( (*p) ) {
 638                 case 59: goto tr6;
 639                 case 129: goto tr7;
 640         }
 641         goto tr3;
 642 tr5:
 643 #line 381 "rlscan.rl"
 644         { word = lit = 0; word_len = lit_len = 0; }
 645 #line 383 "rlscan.rl"
 646         { lit = tokdata; lit_len = toklen; }
 647         goto st5;
 648 tr7:
 649 #line 383 "rlscan.rl"
 650         { lit = tokdata; lit_len = toklen; }
 651         goto st5;
 652 st5:
 653         if ( ++p == pe )
 654                 goto _test_eof5;
 655 case 5:
 656 #line 657 "rlscan.cpp"
 657         if ( (*p) == 59 )
 658                 goto tr6;
 659         goto tr3;
 660 st6:
 661         if ( ++p == pe )
 662                 goto _test_eof6;
 663 case 6:
 664         if ( (*p) == 129 )
 665                 goto tr9;
 666         goto tr8;
 667 tr9:
 668 #line 383 "rlscan.rl"
 669         { lit = tokdata; lit_len = toklen; }
 670         goto st7;
 671 st7:
 672         if ( ++p == pe )
 673                 goto _test_eof7;
 674 case 7:
 675 #line 676 "rlscan.cpp"
 676         if ( (*p) == 59 )
 677                 goto tr10;
 678         goto tr8;
 679 tr18:
 680 #line 412 "rlscan.rl"
 681         {
 682                 if ( active() && machineSpec == 0 && machineName == 0 ) {
 683                         InputItem *inputItem = new InputItem;
 684                         inputItem->type = InputItem::Write;
 685                         inputItem->loc.fileName = fileName;
 686                         inputItem->loc.line = line;
 687                         inputItem->loc.col = column;
 688                         inputItem->name = parser->sectionName;
 689                         inputItem->pd = parser->pd;
 690                         id.inputItems.append( inputItem );
 691                 }
 692         }
 693         goto st8;
 694 st8:
 695         if ( ++p == pe )
 696                 goto _test_eof8;
 697 case 8:
 698 #line 699 "rlscan.cpp"
 699         if ( (*p) == 128 )
 700                 goto tr12;
 701         goto tr11;
 702 tr12:
 703 #line 426 "rlscan.rl"
 704         {
 705                 if ( active() && machineSpec == 0 && machineName == 0 )
 706                         id.inputItems.tail->writeArgs.append( strdup(tokdata) );
 707         }
 708         goto st9;
 709 st9:
 710         if ( ++p == pe )
 711                 goto _test_eof9;
 712 case 9:
 713 #line 714 "rlscan.cpp"
 714         switch( (*p) ) {
 715                 case 59: goto tr13;
 716                 case 128: goto tr12;
 717         }
 718         goto tr11;
 719         }
 720         _test_eof10: cs = 10; goto _test_eof;
 721         _test_eof1: cs = 1; goto _test_eof;
 722         _test_eof2: cs = 2; goto _test_eof;
 723         _test_eof3: cs = 3; goto _test_eof;
 724         _test_eof4: cs = 4; goto _test_eof;
 725         _test_eof5: cs = 5; goto _test_eof;
 726         _test_eof6: cs = 6; goto _test_eof;
 727         _test_eof7: cs = 7; goto _test_eof;
 728         _test_eof8: cs = 8; goto _test_eof;
 729         _test_eof9: cs = 9; goto _test_eof;
 730
 731         _test_eof: {}
 732         if ( p == eof )
 733         {
 734         switch ( cs ) {
 735         case 1:
 736         case 2:
 737 #line 385 "rlscan.rl"
 738         { scan_error() << "bad machine statement" << endl; }
 739         break;
 740         case 3:
 741         case 4:
 742         case 5:
 743 #line 386 "rlscan.rl"
 744         { scan_error() << "bad include statement" << endl; }
 745         break;
 746         case 6:
 747         case 7:
 748 #line 387 "rlscan.rl"
 749         { scan_error() << "bad import statement" << endl; }
 750         break;
 751         case 8:
 752         case 9:
 753 #line 388 "rlscan.rl"
 754         { scan_error() << "bad write statement" << endl; }
 755         break;
 756 #line 757 "rlscan.cpp"
 757         }
 758         }
 759
 760         _out: {}
 761         }
 762
 763 #line 501 "rlscan.rl"
 764
 765
 766         updateCol();
 767
 768         /* Record the last token for use in controlling the scan of subsequent
 769          * tokens. */
 770         lastToken = type;
 771 }
 772
 773 void Scanner::startSection( )
 774 {
 775         parserExistsError = false;
 776
 777         sectionLoc.fileName = fileName;
 778         sectionLoc.line = line;
 779         sectionLoc.col = column;
 780 }
 781
 782 void Scanner::endSection( )
 783 {
 784         /* Execute the eof actions for the section parser. */
 785         processToken( -1, 0, 0 );
 786
 787         /* Close off the section with the parser. */
 788         if ( active() ) {
 789                 InputLoc loc;
 790                 loc.fileName = fileName;
 791                 loc.line = line;
 792                 loc.col = column;
 793
 794                 parser->token( loc, TK_EndSection, 0, 0 );
 795         }
 796
 797         if ( includeDepth == 0 ) {
 798                 if ( machineSpec == 0 && machineName == 0 ) {
 799                         /* The end section may include a newline on the end, so
 800                          * we use the last line, which will count the newline. */
 801                         InputItem *inputItem = new InputItem;
 802                         inputItem->type = InputItem::HostData;
 803                         inputItem->loc.line = line;
 804                         inputItem->loc.col = column;
 805                         id.inputItems.append( inputItem );
 806                 }
 807         }
 808 }
 809
 810 bool isAbsolutePath( const char *path )
 811 {
 812 #ifdef _WIN32
 813         return isalpha( path[0] ) && path[1] == ':' && path[2] == '\\';
 814 #else
 815         return path[0] == '/';
 816 #endif
 817 }
 818
 819 char **Scanner::makeIncludePathChecks( const char *thisFileName,
 820                 const char *fileName, int fnlen )
 821 {
 822         char **checks = 0;
 823         long nextCheck = 0;
 824         long length = 0;
 825         bool caseInsensitive = false;
 826         char *data = prepareLitString( InputLoc(), fileName, fnlen,
 827                         length, caseInsensitive );
 828
 829         /* Absolute path? */
 830         if ( isAbsolutePath( data ) ) {
 831                 checks = new char*[2];
 832                 checks[nextCheck++] = data;
 833         }
 834         else {
 835                 checks = new char*[2 + id.includePaths.length()];
 836
 837                 /* Search from the the location of the current file. */
 838                 const char *lastSlash = strrchr( thisFileName, PATH_SEP );
 839                 if ( lastSlash == 0 )
 840                         checks[nextCheck++] = data;
 841                 else {
 842                         long givenPathLen = (lastSlash - thisFileName) + 1;
 843                         long checklen = givenPathLen + length;
 844                         char *check = new char[checklen+1];
 845                         memcpy( check, thisFileName, givenPathLen );
 846                         memcpy( check+givenPathLen, data, length );
 847                         check[checklen] = 0;
 848                         checks[nextCheck++] = check;
 849                 }
 850
 851                 /* Search from the include paths given on the command line. */
 852                 for ( ArgsVector::Iter incp = id.includePaths; incp.lte(); incp++ ) {
 853                         long pathLen = strlen( *incp );
 854                         long checkLen = pathLen + 1 + length;
 855                         char *check = new char[checkLen+1];
 856                         memcpy( check, *incp, pathLen );
 857                         check[pathLen] = PATH_SEP;
 858                         memcpy( check+pathLen+1, data, length );
 859                         check[checkLen] = 0;
 860                         checks[nextCheck++] = check;
 861                 }
 862         }
 863
 864         checks[nextCheck] = 0;
 865         return checks;
 866 }
 867
 868 ifstream *Scanner::tryOpenInclude( char **pathChecks, long &found )
 869 {
 870         char **check = pathChecks;
 871         ifstream *inFile = new ifstream;
 872
 873         while ( *check != 0 ) {
 874                 inFile->open( *check );
 875                 if ( inFile->is_open() ) {
 876                         found = check - pathChecks;
 877                         return inFile;
 878                 }
 879                 check += 1;
 880         }
 881
 882         found = -1;
 883         delete inFile;
 884         return 0;
 885 }
 886
 887
 888 #line 1162 "rlscan.rl"
 889
 890
 891
 892 #line 893 "rlscan.cpp"
 893 static const int rlscan_start = 38;
 894 static const int rlscan_first_final = 38;
 895 static const int rlscan_error = 0;
 896
 897 static const int rlscan_en_inline_code_ruby = 52;
 898 static const int rlscan_en_inline_code = 95;
 899 static const int rlscan_en_or_literal = 137;
 900 static const int rlscan_en_ragel_re_literal = 139;
 901 static const int rlscan_en_write_statement = 143;
 902 static const int rlscan_en_parser_def = 146;
 903 static const int rlscan_en_main_ruby = 253;
 904 static const int rlscan_en_main = 38;
 905
 906
 907 #line 1165 "rlscan.rl"
 908
 909 void Scanner::do_scan()
 910 {
 911         int bufsize = 8;
 912         char *buf = new char[bufsize];
 913         int cs, act, have = 0;
 914         int top;
 915
 916         /* The stack is two deep, one level for going into ragel defs from the main
 917          * machines which process outside code, and another for going into or literals
 918          * from either a ragel spec, or a regular expression. */
 919         int stack[2];
 920         int curly_count = 0;
 921         bool execute = true;
 922         bool singleLineSpec = false;
 923         InlineBlockType inlineBlockType = CurlyDelimited;
 924
 925         /* Init the section parser and the character scanner. */
 926         init();
 927
 928 #line 929 "rlscan.cpp"
 929         {
 930         cs = rlscan_start;
 931         top = 0;
 932         ts = 0;
 933         te = 0;
 934         act = 0;
 935         }
 936
 937 #line 1185 "rlscan.rl"
 938
 939         /* Set up the start state. FIXME: After 5.20 is released the nocs write
 940          * init option should be used, the main machine eliminated and this statement moved
 941          * above the write init. */
 942         if ( hostLang->lang == HostLang::Ruby )
 943                 cs = rlscan_en_main_ruby;
 944         else
 945                 cs = rlscan_en_main;
 946
 947         while ( execute ) {
 948                 char *p = buf + have;
 949                 int space = bufsize - have;
 950
 951                 if ( space == 0 ) {
 952                         /* We filled up the buffer trying to scan a token. Grow it. */
 953                         bufsize = bufsize * 2;
 954                         char *newbuf = new char[bufsize];
 955
 956                         /* Recompute p and space. */
 957                         p = newbuf + have;
 958                         space = bufsize - have;
 959
 960                         /* Patch up pointers possibly in use. */
 961                         if ( ts != 0 )
 962                                 ts = newbuf + ( ts - buf );
 963                         te = newbuf + ( te - buf );
 964
 965                         /* Copy the new buffer in. */
 966                         memcpy( newbuf, buf, have );
 967                         delete[] buf;
 968                         buf = newbuf;
 969                 }
 970
 971                 input.read( p, space );
 972                 int len = input.gcount();
 973                 char *pe = p + len;
 974
 975                 /* If we see eof then append the eof var. */
 976                 char *eof = 0;
 977                 if ( len == 0 ) {
 978                         eof = pe;
 979                         execute = false;
 980                 }
 981
 982
 983 #line 984 "rlscan.cpp"
 984         {
 985         if ( p == pe )
 986                 goto _test_eof;
 987         goto _resume;
 988
 989 _again:
 990         switch ( cs ) {
 991                 case 38: goto st38;
 992                 case 39: goto st39;
 993                 case 40: goto st40;
 994                 case 1: goto st1;
 995                 case 2: goto st2;
 996                 case 41: goto st41;
 997                 case 42: goto st42;
 998                 case 43: goto st43;
 999                 case 3: goto st3;
1000                 case 4: goto st4;
1001                 case 44: goto st44;
1002                 case 5: goto st5;
1003                 case 6: goto st6;
1004                 case 7: goto st7;
1005                 case 45: goto st45;
1006                 case 46: goto st46;
1007                 case 47: goto st47;
1008                 case 48: goto st48;
1009                 case 49: goto st49;
1010                 case 50: goto st50;
1011                 case 51: goto st51;
1012                 case 52: goto st52;
1013                 case 53: goto st53;
1014                 case 54: goto st54;
1015                 case 8: goto st8;
1016                 case 9: goto st9;
1017                 case 55: goto st55;
1018                 case 10: goto st10;
1019                 case 56: goto st56;
1020                 case 11: goto st11;
1021                 case 12: goto st12;
1022                 case 57: goto st57;
1023                 case 13: goto st13;
1024                 case 14: goto st14;
1025                 case 58: goto st58;
1026                 case 59: goto st59;
1027                 case 15: goto st15;
1028                 case 60: goto st60;
1029                 case 61: goto st61;
1030                 case 62: goto st62;
1031                 case 63: goto st63;
1032                 case 64: goto st64;
1033                 case 65: goto st65;
1034                 case 66: goto st66;
1035                 case 67: goto st67;
1036                 case 68: goto st68;
1037                 case 69: goto st69;
1038                 case 70: goto st70;
1039                 case 71: goto st71;
1040                 case 72: goto st72;
1041                 case 73: goto st73;
1042                 case 74: goto st74;
1043                 case 75: goto st75;
1044                 case 76: goto st76;
1045                 case 77: goto st77;
1046                 case 78: goto st78;
1047                 case 79: goto st79;
1048                 case 80: goto st80;
1049                 case 81: goto st81;
1050                 case 82: goto st82;
1051                 case 83: goto st83;
1052                 case 84: goto st84;
1053                 case 85: goto st85;
1054                 case 86: goto st86;
1055                 case 87: goto st87;
1056                 case 88: goto st88;
1057                 case 89: goto st89;
1058                 case 90: goto st90;
1059                 case 91: goto st91;
1060                 case 92: goto st92;
1061                 case 93: goto st93;
1062                 case 94: goto st94;
1063                 case 95: goto st95;
1064                 case 96: goto st96;
1065                 case 97: goto st97;
1066                 case 16: goto st16;
1067                 case 17: goto st17;
1068                 case 98: goto st98;
1069                 case 18: goto st18;
1070                 case 19: goto st19;
1071                 case 99: goto st99;
1072                 case 20: goto st20;
1073                 case 21: goto st21;
1074                 case 22: goto st22;
1075                 case 100: goto st100;
1076                 case 101: goto st101;
1077                 case 23: goto st23;
1078                 case 102: goto st102;
1079                 case 103: goto st103;
1080                 case 104: goto st104;
1081                 case 105: goto st105;
1082                 case 106: goto st106;
1083                 case 107: goto st107;
1084                 case 108: goto st108;
1085                 case 109: goto st109;
1086                 case 110: goto st110;
1087                 case 111: goto st111;
1088                 case 112: goto st112;
1089                 case 113: goto st113;
1090                 case 114: goto st114;
1091                 case 115: goto st115;
1092                 case 116: goto st116;
1093                 case 117: goto st117;
1094                 case 118: goto st118;
1095                 case 119: goto st119;
1096                 case 120: goto st120;
1097                 case 121: goto st121;
1098                 case 122: goto st122;
1099                 case 123: goto st123;
1100                 case 124: goto st124;
1101                 case 125: goto st125;
1102                 case 126: goto st126;
1103                 case 127: goto st127;
1104                 case 128: goto st128;
1105                 case 129: goto st129;
1106                 case 130: goto st130;
1107                 case 131: goto st131;
1108                 case 132: goto st132;
1109                 case 133: goto st133;
1110                 case 134: goto st134;
1111                 case 135: goto st135;
1112                 case 136: goto st136;
1113                 case 137: goto st137;
1114                 case 138: goto st138;
1115                 case 139: goto st139;
1116                 case 140: goto st140;
1117                 case 141: goto st141;
1118                 case 142: goto st142;
1119                 case 143: goto st143;
1120                 case 0: goto st0;
1121                 case 144: goto st144;
1122                 case 145: goto st145;
1123                 case 146: goto st146;
1124                 case 147: goto st147;
1125                 case 148: goto st148;
1126                 case 24: goto st24;
1127                 case 149: goto st149;
1128                 case 25: goto st25;
1129                 case 150: goto st150;
1130                 case 26: goto st26;
1131                 case 151: goto st151;
1132                 case 152: goto st152;
1133                 case 153: goto st153;
1134                 case 27: goto st27;
1135                 case 28: goto st28;
1136                 case 154: goto st154;
1137                 case 155: goto st155;
1138                 case 156: goto st156;
1139                 case 157: goto st157;
1140                 case 158: goto st158;
1141                 case 29: goto st29;
1142                 case 159: goto st159;
1143                 case 160: goto st160;
1144                 case 161: goto st161;
1145                 case 162: goto st162;
1146                 case 163: goto st163;
1147                 case 164: goto st164;
1148                 case 165: goto st165;
1149                 case 166: goto st166;
1150                 case 167: goto st167;
1151                 case 168: goto st168;
1152                 case 169: goto st169;
1153                 case 170: goto st170;
1154                 case 171: goto st171;
1155                 case 172: goto st172;
1156                 case 173: goto st173;
1157                 case 174: goto st174;
1158                 case 175: goto st175;
1159                 case 176: goto st176;
1160                 case 177: goto st177;
1161                 case 178: goto st178;
1162                 case 179: goto st179;
1163                 case 180: goto st180;
1164                 case 181: goto st181;
1165                 case 182: goto st182;
1166                 case 183: goto st183;
1167                 case 184: goto st184;
1168                 case 185: goto st185;
1169                 case 186: goto st186;
1170                 case 187: goto st187;
1171                 case 188: goto st188;
1172                 case 189: goto st189;
1173                 case 190: goto st190;
1174                 case 191: goto st191;
1175                 case 192: goto st192;
1176                 case 193: goto st193;
1177                 case 194: goto st194;
1178                 case 195: goto st195;
1179                 case 196: goto st196;
1180                 case 197: goto st197;
1181                 case 198: goto st198;
1182                 case 199: goto st199;
1183                 case 200: goto st200;
1184                 case 201: goto st201;
1185                 case 202: goto st202;
1186                 case 203: goto st203;
1187                 case 204: goto st204;
1188                 case 205: goto st205;
1189                 case 206: goto st206;
1190                 case 207: goto st207;
1191                 case 208: goto st208;
1192                 case 209: goto st209;
1193                 case 210: goto st210;
1194                 case 211: goto st211;
1195                 case 212: goto st212;
1196                 case 213: goto st213;
1197                 case 214: goto st214;
1198                 case 215: goto st215;
1199                 case 216: goto st216;
1200                 case 217: goto st217;
1201                 case 218: goto st218;
1202                 case 219: goto st219;
1203                 case 220: goto st220;
1204                 case 221: goto st221;
1205                 case 222: goto st222;
1206                 case 223: goto st223;
1207                 case 224: goto st224;
1208                 case 225: goto st225;
1209                 case 226: goto st226;
1210                 case 227: goto st227;
1211                 case 228: goto st228;
1212                 case 229: goto st229;
1213                 case 230: goto st230;
1214                 case 231: goto st231;
1215                 case 232: goto st232;
1216                 case 233: goto st233;
1217                 case 234: goto st234;
1218                 case 235: goto st235;
1219                 case 236: goto st236;
1220                 case 237: goto st237;
1221                 case 238: goto st238;
1222                 case 239: goto st239;
1223                 case 240: goto st240;
1224                 case 241: goto st241;
1225                 case 242: goto st242;
1226                 case 243: goto st243;
1227                 case 244: goto st244;
1228                 case 245: goto st245;
1229                 case 246: goto st246;
1230                 case 247: goto st247;
1231                 case 248: goto st248;
1232                 case 249: goto st249;
1233                 case 250: goto st250;
1234                 case 251: goto st251;
1235                 case 252: goto st252;
1236                 case 30: goto st30;
1237                 case 253: goto st253;
1238                 case 254: goto st254;
1239                 case 255: goto st255;
1240                 case 31: goto st31;
1241                 case 32: goto st32;
1242                 case 256: goto st256;
1243                 case 33: goto st33;
1244                 case 257: goto st257;
1245                 case 258: goto st258;
1246                 case 259: goto st259;
1247                 case 34: goto st34;
1248                 case 35: goto st35;
1249                 case 260: goto st260;
1250                 case 36: goto st36;
1251                 case 37: goto st37;
1252                 case 261: goto st261;
1253                 case 262: goto st262;
1254         default: break;
1255         }
1256
1257         if ( ++p == pe )
1258                 goto _test_eof;
1259 _resume:
1260         switch ( cs )
1261         {
1262 tr0:
1263 #line 1160 "rlscan.rl"
1264         {{p = ((te))-1;}{ pass( *ts, 0, 0 ); }}
1265         goto st38;
1266 tr3:
1267 #line 1144 "rlscan.rl"
1268         {te = p+1;{ pass( IMP_Literal, ts, te ); }}
1269         goto st38;
1270 tr11:
1271 #line 1143 "rlscan.rl"
1272         {te = p+1;{ pass(); }}
1273         goto st38;
1274 tr13:
1275 #line 630 "rlscan.rl"
1276         {
1277                 lastnl = p;
1278                 column = 0;
1279                 line++;
1280         }
1281 #line 1143 "rlscan.rl"
1282         {te = p+1;{ pass(); }}
1283         goto st38;
1284 tr71:
1285 #line 1160 "rlscan.rl"
1286         {te = p+1;{ pass( *ts, 0, 0 ); }}
1287         goto st38;
1288 tr72:
1289 #line 1159 "rlscan.rl"
1290         {te = p+1;}
1291         goto st38;
1292 tr82:
1293 #line 1158 "rlscan.rl"
1294         {te = p;p--;{ pass(); }}
1295         goto st38;
1296 tr83:
1297 #line 1160 "rlscan.rl"
1298         {te = p;p--;{ pass( *ts, 0, 0 ); }}
1299         goto st38;
1300 tr85:
1301 #line 1152 "rlscan.rl"
1302         {te = p;p--;{
1303                         updateCol();
1304                         singleLineSpec = true;
1305                         startSection();
1306                         {stack[top++] = 38; goto st146;}
1307                 }}
1308         goto st38;
1309 tr86:
1310 #line 1146 "rlscan.rl"
1311         {te = p+1;{
1312                         updateCol();
1313                         singleLineSpec = false;
1314                         startSection();
1315                         {stack[top++] = 38; goto st146;}
1316                 }}
1317         goto st38;
1318 tr87:
1319 #line 1142 "rlscan.rl"
1320         {te = p;p--;{ pass( IMP_UInt, ts, te ); }}
1321         goto st38;
1322 tr88:
1323 #line 1 "rlscan.rl"
1324         {       switch( act ) {
1325         case 176:
1326         {{p = ((te))-1;} pass( IMP_Define, 0, 0 ); }
1327         break;
1328         case 177:
1329         {{p = ((te))-1;} pass( IMP_Word, ts, te ); }
1330         break;
1331         }
1332         }
1333         goto st38;
1334 tr89:
1335 #line 1141 "rlscan.rl"
1336         {te = p;p--;{ pass( IMP_Word, ts, te ); }}
1337         goto st38;
1338 st38:
1339 #line 1 "rlscan.rl"
1340         {ts = 0;}
1341         if ( ++p == pe )
1342                 goto _test_eof38;
1343 case 38:
1344 #line 1 "rlscan.rl"
1345         {ts = p;}
1346 #line 1347 "rlscan.cpp"
1347         switch( (*p) ) {
1348                 case 0: goto tr72;
1349                 case 9: goto st39;
1350                 case 10: goto tr74;
1351                 case 32: goto st39;
1352                 case 34: goto tr75;
1353                 case 37: goto st41;
1354                 case 39: goto tr77;
1355                 case 47: goto tr78;
1356                 case 95: goto tr80;
1357                 case 100: goto st47;
1358         }
1359         if ( (*p) < 65 ) {
1360                 if ( 48 <= (*p) && (*p) <= 57 )
1361                         goto st45;
1362         } else if ( (*p) > 90 ) {
1363                 if ( 97 <= (*p) && (*p) <= 122 )
1364                         goto tr80;
1365         } else
1366                 goto tr80;
1367         goto tr71;
1368 tr74:
1369 #line 630 "rlscan.rl"
1370         {
1371                 lastnl = p;
1372                 column = 0;
1373                 line++;
1374         }
1375         goto st39;
1376 st39:
1377         if ( ++p == pe )
1378                 goto _test_eof39;
1379 case 39:
1380 #line 1381 "rlscan.cpp"
1381         switch( (*p) ) {
1382                 case 9: goto st39;
1383                 case 10: goto tr74;
1384                 case 32: goto st39;
1385         }
1386         goto tr82;
1387 tr75:
1388 #line 1 "rlscan.rl"
1389         {te = p+1;}
1390         goto st40;
1391 st40:
1392         if ( ++p == pe )
1393                 goto _test_eof40;
1394 case 40:
1395 #line 1396 "rlscan.cpp"
1396         switch( (*p) ) {
1397                 case 10: goto tr2;
1398                 case 34: goto tr3;
1399                 case 92: goto st2;
1400         }
1401         goto st1;
1402 tr2:
1403 #line 630 "rlscan.rl"
1404         {
1405                 lastnl = p;
1406                 column = 0;
1407                 line++;
1408         }
1409         goto st1;
1410 st1:
1411         if ( ++p == pe )
1412                 goto _test_eof1;
1413 case 1:
1414 #line 1415 "rlscan.cpp"
1415         switch( (*p) ) {
1416                 case 10: goto tr2;
1417                 case 34: goto tr3;
1418                 case 92: goto st2;
1419         }
1420         goto st1;
1421 st2:
1422         if ( ++p == pe )
1423                 goto _test_eof2;
1424 case 2:
1425         if ( (*p) == 10 )
1426                 goto tr2;
1427         goto st1;
1428 st41:
1429         if ( ++p == pe )
1430                 goto _test_eof41;
1431 case 41:
1432         if ( (*p) == 37 )
1433                 goto st42;
1434         goto tr83;
1435 st42:
1436         if ( ++p == pe )
1437                 goto _test_eof42;
1438 case 42:
1439         if ( (*p) == 123 )
1440                 goto tr86;
1441         goto tr85;
1442 tr77:
1443 #line 1 "rlscan.rl"
1444         {te = p+1;}
1445         goto st43;
1446 st43:
1447         if ( ++p == pe )
1448                 goto _test_eof43;
1449 case 43:
1450 #line 1451 "rlscan.cpp"
1451         switch( (*p) ) {
1452                 case 10: goto tr6;
1453                 case 39: goto tr3;
1454                 case 92: goto st4;
1455         }
1456         goto st3;
1457 tr6:
1458 #line 630 "rlscan.rl"
1459         {
1460                 lastnl = p;
1461                 column = 0;
1462                 line++;
1463         }
1464         goto st3;
1465 st3:
1466         if ( ++p == pe )
1467                 goto _test_eof3;
1468 case 3:
1469 #line 1470 "rlscan.cpp"
1470         switch( (*p) ) {
1471                 case 10: goto tr6;
1472                 case 39: goto tr3;
1473                 case 92: goto st4;
1474         }
1475         goto st3;
1476 st4:
1477         if ( ++p == pe )
1478                 goto _test_eof4;
1479 case 4:
1480         if ( (*p) == 10 )
1481                 goto tr6;
1482         goto st3;
1483 tr78:
1484 #line 1 "rlscan.rl"
1485         {te = p+1;}
1486         goto st44;
1487 st44:
1488         if ( ++p == pe )
1489                 goto _test_eof44;
1490 case 44:
1491 #line 1492 "rlscan.cpp"
1492         switch( (*p) ) {
1493                 case 42: goto st5;
1494                 case 47: goto st7;
1495         }
1496         goto tr83;
1497 tr9:
1498 #line 630 "rlscan.rl"
1499         {
1500                 lastnl = p;
1501                 column = 0;
1502                 line++;
1503         }
1504         goto st5;
1505 st5:
1506         if ( ++p == pe )
1507                 goto _test_eof5;
1508 case 5:
1509 #line 1510 "rlscan.cpp"
1510         switch( (*p) ) {
1511                 case 10: goto tr9;
1512                 case 42: goto st6;
1513         }
1514         goto st5;
1515 st6:
1516         if ( ++p == pe )
1517                 goto _test_eof6;
1518 case 6:
1519         switch( (*p) ) {
1520                 case 10: goto tr9;
1521                 case 42: goto st6;
1522                 case 47: goto tr11;
1523         }
1524         goto st5;
1525 st7:
1526         if ( ++p == pe )
1527                 goto _test_eof7;
1528 case 7:
1529         if ( (*p) == 10 )
1530                 goto tr13;
1531         goto st7;
1532 st45:
1533         if ( ++p == pe )
1534                 goto _test_eof45;
1535 case 45:
1536         if ( 48 <= (*p) && (*p) <= 57 )
1537                 goto st45;
1538         goto tr87;
1539 tr80:
1540 #line 1 "rlscan.rl"
1541         {te = p+1;}
1542 #line 1141 "rlscan.rl"
1543         {act = 177;}
1544         goto st46;
1545 tr94:
1546 #line 1 "rlscan.rl"
1547         {te = p+1;}
1548 #line 1140 "rlscan.rl"
1549         {act = 176;}
1550         goto st46;
1551 st46:
1552         if ( ++p == pe )
1553                 goto _test_eof46;
1554 case 46:
1555 #line 1556 "rlscan.cpp"
1556         if ( (*p) == 95 )
1557                 goto tr80;
1558         if ( (*p) < 65 ) {
1559                 if ( 48 <= (*p) && (*p) <= 57 )
1560                         goto tr80;
1561         } else if ( (*p) > 90 ) {
1562                 if ( 97 <= (*p) && (*p) <= 122 )
1563                         goto tr80;
1564         } else
1565                 goto tr80;
1566         goto tr88;
1567 st47:
1568         if ( ++p == pe )
1569                 goto _test_eof47;
1570 case 47:
1571         switch( (*p) ) {
1572                 case 95: goto tr80;
1573                 case 101: goto st48;
1574         }
1575         if ( (*p) < 65 ) {
1576                 if ( 48 <= (*p) && (*p) <= 57 )
1577                         goto tr80;
1578         } else if ( (*p) > 90 ) {
1579                 if ( 97 <= (*p) && (*p) <= 122 )
1580                         goto tr80;
1581         } else
1582                 goto tr80;
1583         goto tr89;
1584 st48:
1585         if ( ++p == pe )
1586                 goto _test_eof48;
1587 case 48:
1588         switch( (*p) ) {
1589                 case 95: goto tr80;
1590                 case 102: goto st49;
1591         }
1592         if ( (*p) < 65 ) {
1593                 if ( 48 <= (*p) && (*p) <= 57 )
1594                         goto tr80;
1595         } else if ( (*p) > 90 ) {
1596                 if ( 97 <= (*p) && (*p) <= 122 )
1597                         goto tr80;
1598         } else
1599                 goto tr80;
1600         goto tr89;
1601 st49:
1602         if ( ++p == pe )
1603                 goto _test_eof49;
1604 case 49:
1605         switch( (*p) ) {
1606                 case 95: goto tr80;
1607                 case 105: goto st50;
1608         }
1609         if ( (*p) < 65 ) {
1610                 if ( 48 <= (*p) && (*p) <= 57 )
1611                         goto tr80;
1612         } else if ( (*p) > 90 ) {
1613                 if ( 97 <= (*p) && (*p) <= 122 )
1614                         goto tr80;
1615         } else
1616                 goto tr80;
1617         goto tr89;
1618 st50:
1619         if ( ++p == pe )
1620                 goto _test_eof50;
1621 case 50:
1622         switch( (*p) ) {
1623                 case 95: goto tr80;
1624                 case 110: goto st51;
1625         }
1626         if ( (*p) < 65 ) {
1627                 if ( 48 <= (*p) && (*p) <= 57 )
1628                         goto tr80;
1629         } else if ( (*p) > 90 ) {
1630                 if ( 97 <= (*p) && (*p) <= 122 )
1631                         goto tr80;
1632         } else
1633                 goto tr80;
1634         goto tr89;
1635 st51:
1636         if ( ++p == pe )
1637                 goto _test_eof51;
1638 case 51:
1639         switch( (*p) ) {
1640                 case 95: goto tr80;
1641                 case 101: goto tr94;
1642         }
1643         if ( (*p) < 65 ) {
1644                 if ( 48 <= (*p) && (*p) <= 57 )
1645                         goto tr80;
1646         } else if ( (*p) > 90 ) {
1647                 if ( 97 <= (*p) && (*p) <= 122 )
1648                         goto tr80;
1649         } else
1650                 goto tr80;
1651         goto tr89;
1652 tr14:
1653 #line 759 "rlscan.rl"
1654         {{p = ((te))-1;}{ token( IL_Symbol, ts, te ); }}
1655         goto st52;
1656 tr17:
1657 #line 705 "rlscan.rl"
1658         {te = p+1;{ token( IL_Literal, ts, te ); }}
1659         goto st52;
1660 tr20:
1661 #line 630 "rlscan.rl"
1662         {
1663                 lastnl = p;
1664                 column = 0;
1665                 line++;
1666         }
1667 #line 712 "rlscan.rl"
1668         {te = p+1;{ token( IL_Comment, ts, te ); }}
1669         goto st52;
1670 tr27:
1671 #line 701 "rlscan.rl"
1672         {{p = ((te))-1;}{ token( TK_UInt, ts, te ); }}
1673         goto st52;
1674 tr95:
1675 #line 759 "rlscan.rl"
1676         {te = p+1;{ token( IL_Symbol, ts, te ); }}
1677         goto st52;
1678 tr96:
1679 #line 754 "rlscan.rl"
1680         {te = p+1;{
1681                         scan_error() << "unterminated code block" << endl;
1682                 }}
1683         goto st52;
1684 tr102:
1685 #line 734 "rlscan.rl"
1686         {te = p+1;{ token( *ts, ts, te ); }}
1687         goto st52;
1688 tr103:
1689 #line 729 "rlscan.rl"
1690         {te = p+1;{
1691                         whitespaceOn = true;
1692                         token( *ts, ts, te );
1693                 }}
1694         goto st52;
1695 tr108:
1696 #line 722 "rlscan.rl"
1697         {te = p+1;{
1698                         whitespaceOn = true;
1699                         token( *ts, ts, te );
1700                         if ( inlineBlockType == SemiTerminated )
1701                                 {cs = stack[--top];goto _again;}
1702                 }}
1703         goto st52;
1704 tr111:
1705 #line 736 "rlscan.rl"
1706         {te = p+1;{
1707                         token( IL_Symbol, ts, te );
1708                         curly_count += 1;
1709                 }}
1710         goto st52;
1711 tr112:
1712 #line 741 "rlscan.rl"
1713         {te = p+1;{
1714                         if ( --curly_count == 0 && inlineBlockType == CurlyDelimited ) {
1715                                 /* Inline code block ends. */
1716                                 token( '}' );
1717                                 {cs = stack[--top];goto _again;}
1718                         }
1719                         else {
1720                                 /* Either a semi terminated inline block or only the closing
1721                                  * brace of some inner scope, not the block's closing brace. */
1722                                 token( IL_Symbol, ts, te );
1723                         }
1724                 }}
1725         goto st52;
1726 tr113:
1727 #line 707 "rlscan.rl"
1728         {te = p;p--;{
1729                         if ( whitespaceOn )
1730                                 token( IL_WhiteSpace, ts, te );
1731                 }}
1732         goto st52;
1733 tr114:
1734 #line 759 "rlscan.rl"
1735         {te = p;p--;{ token( IL_Symbol, ts, te ); }}
1736         goto st52;
1737 tr115:
1738 #line 701 "rlscan.rl"
1739         {te = p;p--;{ token( TK_UInt, ts, te ); }}
1740         goto st52;
1741 tr117:
1742 #line 702 "rlscan.rl"
1743         {te = p;p--;{ token( TK_Hex, ts, te ); }}
1744         goto st52;
1745 tr118:
1746 #line 714 "rlscan.rl"
1747         {te = p+1;{ token( TK_NameSep, ts, te ); }}
1748         goto st52;
1749 tr119:
1750 #line 1 "rlscan.rl"
1751         {       switch( act ) {
1752         case 1:
1753         {{p = ((te))-1;} token( KW_PChar ); }
1754         break;
1755         case 3:
1756         {{p = ((te))-1;} token( KW_CurState ); }
1757         break;
1758         case 4:
1759         {{p = ((te))-1;} token( KW_TargState ); }
1760         break;
1761         case 5:
1762         {{p = ((te))-1;}
1763                         whitespaceOn = false;
1764                         token( KW_Entry );
1765                 }
1766         break;
1767         case 6:
1768         {{p = ((te))-1;}
1769                         whitespaceOn = false;
1770                         token( KW_Hold );
1771                 }
1772         break;
1773         case 7:
1774         {{p = ((te))-1;} token( KW_Exec, 0, 0 ); }
1775         break;
1776         case 8:
1777         {{p = ((te))-1;}
1778                         whitespaceOn = false;
1779                         token( KW_Goto );
1780                 }
1781         break;
1782         case 9:
1783         {{p = ((te))-1;}
1784                         whitespaceOn = false;
1785                         token( KW_Next );
1786                 }
1787         break;
1788         case 10:
1789         {{p = ((te))-1;}
1790                         whitespaceOn = false;
1791                         token( KW_Call );
1792                 }
1793         break;
1794         case 11:
1795         {{p = ((te))-1;}
1796                         whitespaceOn = false;
1797                         token( KW_Ret );
1798                 }
1799         break;
1800         case 12:
1801         {{p = ((te))-1;}
1802                         whitespaceOn = false;
1803                         token( KW_Break );
1804                 }
1805         break;
1806         case 13:
1807         {{p = ((te))-1;} token( TK_Word, ts, te ); }
1808         break;
1809         }
1810         }
1811         goto st52;
1812 tr120:
1813 #line 699 "rlscan.rl"
1814         {te = p;p--;{ token( TK_Word, ts, te ); }}
1815         goto st52;
1816 tr134:
1817 #line 664 "rlscan.rl"
1818         {te = p;p--;{ token( KW_Char ); }}
1819         goto st52;
1820 st52:
1821 #line 1 "rlscan.rl"
1822         {ts = 0;}
1823         if ( ++p == pe )
1824                 goto _test_eof52;
1825 case 52:
1826 #line 1 "rlscan.rl"
1827         {ts = p;}
1828 #line 1829 "rlscan.cpp"
1829         switch( (*p) ) {
1830                 case 0: goto tr96;
1831                 case 9: goto st53;
1832                 case 10: goto tr98;
1833                 case 32: goto st53;
1834                 case 34: goto tr99;
1835                 case 35: goto tr100;
1836                 case 39: goto tr101;
1837                 case 40: goto tr102;
1838                 case 44: goto tr102;
1839                 case 47: goto tr104;
1840                 case 48: goto tr105;
1841                 case 58: goto st61;
1842                 case 59: goto tr108;
1843                 case 95: goto tr109;
1844                 case 102: goto st63;
1845                 case 123: goto tr111;
1846                 case 125: goto tr112;
1847         }
1848         if ( (*p) < 49 ) {
1849                 if ( 41 <= (*p) && (*p) <= 42 )
1850                         goto tr103;
1851         } else if ( (*p) > 57 ) {
1852                 if ( (*p) > 90 ) {
1853                         if ( 97 <= (*p) && (*p) <= 122 )
1854                                 goto tr109;
1855                 } else if ( (*p) >= 65 )
1856                         goto tr109;
1857         } else
1858                 goto st59;
1859         goto tr95;
1860 tr98:
1861 #line 630 "rlscan.rl"
1862         {
1863                 lastnl = p;
1864                 column = 0;
1865                 line++;
1866         }
1867         goto st53;
1868 st53:
1869         if ( ++p == pe )
1870                 goto _test_eof53;
1871 case 53:
1872 #line 1873 "rlscan.cpp"
1873         switch( (*p) ) {
1874                 case 9: goto st53;
1875                 case 10: goto tr98;
1876                 case 32: goto st53;
1877         }
1878         goto tr113;
1879 tr99:
1880 #line 1 "rlscan.rl"
1881         {te = p+1;}
1882         goto st54;
1883 st54:
1884         if ( ++p == pe )
1885                 goto _test_eof54;
1886 case 54:
1887 #line 1888 "rlscan.cpp"
1888         switch( (*p) ) {
1889                 case 10: goto tr16;
1890                 case 34: goto tr17;
1891                 case 92: goto st9;
1892         }
1893         goto st8;
1894 tr16:
1895 #line 630 "rlscan.rl"
1896         {
1897                 lastnl = p;
1898                 column = 0;
1899                 line++;
1900         }
1901         goto st8;
1902 st8:
1903         if ( ++p == pe )
1904                 goto _test_eof8;
1905 case 8:
1906 #line 1907 "rlscan.cpp"
1907         switch( (*p) ) {
1908                 case 10: goto tr16;
1909                 case 34: goto tr17;
1910                 case 92: goto st9;
1911         }
1912         goto st8;
1913 st9:
1914         if ( ++p == pe )
1915                 goto _test_eof9;
1916 case 9:
1917         if ( (*p) == 10 )
1918                 goto tr16;
1919         goto st8;
1920 tr100:
1921 #line 1 "rlscan.rl"
1922         {te = p+1;}
1923         goto st55;
1924 st55:
1925         if ( ++p == pe )
1926                 goto _test_eof55;
1927 case 55:
1928 #line 1929 "rlscan.cpp"
1929         if ( (*p) == 10 )
1930                 goto tr20;
1931         goto st10;
1932 st10:
1933         if ( ++p == pe )
1934                 goto _test_eof10;
1935 case 10:
1936         if ( (*p) == 10 )
1937                 goto tr20;
1938         goto st10;
1939 tr101:
1940 #line 1 "rlscan.rl"
1941         {te = p+1;}
1942         goto st56;
1943 st56:
1944         if ( ++p == pe )
1945                 goto _test_eof56;
1946 case 56:
1947 #line 1948 "rlscan.cpp"
1948         switch( (*p) ) {
1949                 case 10: goto tr22;
1950                 case 39: goto tr17;
1951                 case 92: goto st12;
1952         }
1953         goto st11;
1954 tr22:
1955 #line 630 "rlscan.rl"
1956         {
1957                 lastnl = p;
1958                 column = 0;
1959                 line++;
1960         }
1961         goto st11;
1962 st11:
1963         if ( ++p == pe )
1964                 goto _test_eof11;
1965 case 11:
1966 #line 1967 "rlscan.cpp"
1967         switch( (*p) ) {
1968                 case 10: goto tr22;
1969                 case 39: goto tr17;
1970                 case 92: goto st12;
1971         }
1972         goto st11;
1973 st12:
1974         if ( ++p == pe )
1975                 goto _test_eof12;
1976 case 12:
1977         if ( (*p) == 10 )
1978                 goto tr22;
1979         goto st11;
1980 tr104:
1981 #line 1 "rlscan.rl"
1982         {te = p+1;}
1983         goto st57;
1984 st57:
1985         if ( ++p == pe )
1986                 goto _test_eof57;
1987 case 57:
1988 #line 1989 "rlscan.cpp"
1989         switch( (*p) ) {
1990                 case 10: goto tr25;
1991                 case 47: goto tr17;
1992                 case 92: goto st14;
1993         }
1994         goto st13;
1995 tr25:
1996 #line 630 "rlscan.rl"
1997         {
1998                 lastnl = p;
1999                 column = 0;
2000                 line++;
2001         }
2002         goto st13;
2003 st13:
2004         if ( ++p == pe )
2005                 goto _test_eof13;
2006 case 13:
2007 #line 2008 "rlscan.cpp"
2008         switch( (*p) ) {
2009                 case 10: goto tr25;
2010                 case 47: goto tr17;
2011                 case 92: goto st14;
2012         }
2013         goto st13;
2014 st14:
2015         if ( ++p == pe )
2016                 goto _test_eof14;
2017 case 14:
2018         if ( (*p) == 10 )
2019                 goto tr25;
2020         goto st13;
2021 tr105:
2022 #line 1 "rlscan.rl"
2023         {te = p+1;}
2024         goto st58;
2025 st58:
2026         if ( ++p == pe )
2027                 goto _test_eof58;
2028 case 58:
2029 #line 2030 "rlscan.cpp"
2030         if ( (*p) == 120 )
2031                 goto st15;
2032         if ( 48 <= (*p) && (*p) <= 57 )
2033                 goto st59;
2034         goto tr115;
2035 st59:
2036         if ( ++p == pe )
2037                 goto _test_eof59;
2038 case 59:
2039         if ( 48 <= (*p) && (*p) <= 57 )
2040                 goto st59;
2041         goto tr115;
2042 st15:
2043         if ( ++p == pe )
2044                 goto _test_eof15;
2045 case 15:
2046         if ( (*p) < 65 ) {
2047                 if ( 48 <= (*p) && (*p) <= 57 )
2048                         goto st60;
2049         } else if ( (*p) > 70 ) {
2050                 if ( 97 <= (*p) && (*p) <= 102 )
2051                         goto st60;
2052         } else
2053                 goto st60;
2054         goto tr27;
2055 st60:
2056         if ( ++p == pe )
2057                 goto _test_eof60;
2058 case 60:
2059         if ( (*p) < 65 ) {
2060                 if ( 48 <= (*p) && (*p) <= 57 )
2061                         goto st60;
2062         } else if ( (*p) > 70 ) {
2063                 if ( 97 <= (*p) && (*p) <= 102 )
2064                         goto st60;
2065         } else
2066                 goto st60;
2067         goto tr117;
2068 st61:
2069         if ( ++p == pe )
2070                 goto _test_eof61;
2071 case 61:
2072         if ( (*p) == 58 )
2073                 goto tr118;
2074         goto tr114;
2075 tr109:
2076 #line 1 "rlscan.rl"
2077         {te = p+1;}
2078 #line 699 "rlscan.rl"
2079         {act = 13;}
2080         goto st62;
2081 tr133:
2082 #line 1 "rlscan.rl"
2083         {te = p+1;}
2084 #line 694 "rlscan.rl"
2085         {act = 12;}
2086         goto st62;
2087 tr138:
2088 #line 1 "rlscan.rl"
2089         {te = p+1;}
2090 #line 686 "rlscan.rl"
2091         {act = 10;}
2092         goto st62;
2093 tr140:
2094 #line 1 "rlscan.rl"
2095         {te = p+1;}
2096 #line 665 "rlscan.rl"
2097         {act = 3;}
2098         goto st62;
2099 tr145:
2100 #line 1 "rlscan.rl"
2101         {te = p+1;}
2102 #line 667 "rlscan.rl"
2103         {act = 5;}
2104         goto st62;
2105 tr147:
2106 #line 1 "rlscan.rl"
2107         {te = p+1;}
2108 #line 677 "rlscan.rl"
2109         {act = 7;}
2110         goto st62;
2111 tr150:
2112 #line 1 "rlscan.rl"
2113         {te = p+1;}
2114 #line 678 "rlscan.rl"
2115         {act = 8;}
2116         goto st62;
2117 tr153:
2118 #line 1 "rlscan.rl"
2119         {te = p+1;}
2120 #line 673 "rlscan.rl"
2121         {act = 6;}
2122         goto st62;
2123 tr156:
2124 #line 1 "rlscan.rl"
2125         {te = p+1;}
2126 #line 682 "rlscan.rl"
2127         {act = 9;}
2128         goto st62;
2129 tr157:
2130 #line 1 "rlscan.rl"
2131         {te = p+1;}
2132 #line 663 "rlscan.rl"
2133         {act = 1;}
2134         goto st62;
2135 tr159:
2136 #line 1 "rlscan.rl"
2137         {te = p+1;}
2138 #line 690 "rlscan.rl"
2139         {act = 11;}
2140         goto st62;
2141 tr163:
2142 #line 1 "rlscan.rl"
2143         {te = p+1;}
2144 #line 666 "rlscan.rl"
2145         {act = 4;}
2146         goto st62;
2147 st62:
2148         if ( ++p == pe )
2149                 goto _test_eof62;
2150 case 62:
2151 #line 2152 "rlscan.cpp"
2152         if ( (*p) == 95 )
2153                 goto tr109;
2154         if ( (*p) < 65 ) {
2155                 if ( 48 <= (*p) && (*p) <= 57 )
2156                         goto tr109;
2157         } else if ( (*p) > 90 ) {
2158                 if ( 97 <= (*p) && (*p) <= 122 )
2159                         goto tr109;
2160         } else
2161                 goto tr109;
2162         goto tr119;
2163 st63:
2164         if ( ++p == pe )
2165                 goto _test_eof63;
2166 case 63:
2167         switch( (*p) ) {
2168                 case 95: goto tr109;
2169                 case 98: goto st64;
2170                 case 99: goto st68;
2171                 case 101: goto st73;
2172                 case 103: goto st79;
2173                 case 104: goto st82;
2174                 case 110: goto st85;
2175                 case 112: goto st88;
2176                 case 114: goto st89;
2177                 case 116: goto st91;
2178         }
2179         if ( (*p) < 65 ) {
2180                 if ( 48 <= (*p) && (*p) <= 57 )
2181                         goto tr109;
2182         } else if ( (*p) > 90 ) {
2183                 if ( 97 <= (*p) && (*p) <= 122 )
2184                         goto tr109;
2185         } else
2186                 goto tr109;
2187         goto tr120;
2188 st64:
2189         if ( ++p == pe )
2190                 goto _test_eof64;
2191 case 64:
2192         switch( (*p) ) {
2193                 case 95: goto tr109;
2194                 case 114: goto st65;
2195         }
2196         if ( (*p) < 65 ) {
2197                 if ( 48 <= (*p) && (*p) <= 57 )
2198                         goto tr109;
2199         } else if ( (*p) > 90 ) {
2200                 if ( 97 <= (*p) && (*p) <= 122 )
2201                         goto tr109;
2202         } else
2203                 goto tr109;
2204         goto tr120;
2205 st65:
2206         if ( ++p == pe )
2207                 goto _test_eof65;
2208 case 65:
2209         switch( (*p) ) {
2210                 case 95: goto tr109;
2211                 case 101: goto st66;
2212         }
2213         if ( (*p) < 65 ) {
2214                 if ( 48 <= (*p) && (*p) <= 57 )
2215                         goto tr109;
2216         } else if ( (*p) > 90 ) {
2217                 if ( 97 <= (*p) && (*p) <= 122 )
2218                         goto tr109;
2219         } else
2220                 goto tr109;
2221         goto tr120;
2222 st66:
2223         if ( ++p == pe )
2224                 goto _test_eof66;
2225 case 66:
2226         switch( (*p) ) {
2227                 case 95: goto tr109;
2228                 case 97: goto st67;
2229         }
2230         if ( (*p) < 65 ) {
2231                 if ( 48 <= (*p) && (*p) <= 57 )
2232                         goto tr109;
2233         } else if ( (*p) > 90 ) {
2234                 if ( 98 <= (*p) && (*p) <= 122 )
2235                         goto tr109;
2236         } else
2237                 goto tr109;
2238         goto tr120;
2239 st67:
2240         if ( ++p == pe )
2241                 goto _test_eof67;
2242 case 67:
2243         switch( (*p) ) {
2244                 case 95: goto tr109;
2245                 case 107: goto tr133;
2246         }
2247         if ( (*p) < 65 ) {
2248                 if ( 48 <= (*p) && (*p) <= 57 )
2249                         goto tr109;
2250         } else if ( (*p) > 90 ) {
2251                 if ( 97 <= (*p) && (*p) <= 122 )
2252                         goto tr109;
2253         } else
2254                 goto tr109;
2255         goto tr120;
2256 st68:
2257         if ( ++p == pe )
2258                 goto _test_eof68;
2259 case 68:
2260         switch( (*p) ) {
2261                 case 95: goto tr109;
2262                 case 97: goto st69;
2263                 case 117: goto st71;
2264         }
2265         if ( (*p) < 65 ) {
2266                 if ( 48 <= (*p) && (*p) <= 57 )
2267                         goto tr109;
2268         } else if ( (*p) > 90 ) {
2269                 if ( 98 <= (*p) && (*p) <= 122 )
2270                         goto tr109;
2271         } else
2272                 goto tr109;
2273         goto tr134;
2274 st69:
2275         if ( ++p == pe )
2276                 goto _test_eof69;
2277 case 69:
2278         switch( (*p) ) {
2279                 case 95: goto tr109;
2280                 case 108: goto st70;
2281         }
2282         if ( (*p) < 65 ) {
2283                 if ( 48 <= (*p) && (*p) <= 57 )
2284                         goto tr109;
2285         } else if ( (*p) > 90 ) {
2286                 if ( 97 <= (*p) && (*p) <= 122 )
2287                         goto tr109;
2288         } else
2289                 goto tr109;
2290         goto tr120;
2291 st70:
2292         if ( ++p == pe )
2293                 goto _test_eof70;
2294 case 70:
2295         switch( (*p) ) {
2296                 case 95: goto tr109;
2297                 case 108: goto tr138;
2298         }
2299         if ( (*p) < 65 ) {
2300                 if ( 48 <= (*p) && (*p) <= 57 )
2301                         goto tr109;
2302         } else if ( (*p) > 90 ) {
2303                 if ( 97 <= (*p) && (*p) <= 122 )
2304                         goto tr109;
2305         } else
2306                 goto tr109;
2307         goto tr120;
2308 st71:
2309         if ( ++p == pe )
2310                 goto _test_eof71;
2311 case 71:
2312         switch( (*p) ) {
2313                 case 95: goto tr109;
2314                 case 114: goto st72;
2315         }
2316         if ( (*p) < 65 ) {
2317                 if ( 48 <= (*p) && (*p) <= 57 )
2318                         goto tr109;
2319         } else if ( (*p) > 90 ) {
2320                 if ( 97 <= (*p) && (*p) <= 122 )
2321                         goto tr109;
2322         } else
2323                 goto tr109;
2324         goto tr120;
2325 st72:
2326         if ( ++p == pe )
2327                 goto _test_eof72;
2328 case 72:
2329         switch( (*p) ) {
2330                 case 95: goto tr109;
2331                 case 115: goto tr140;
2332         }
2333         if ( (*p) < 65 ) {
2334                 if ( 48 <= (*p) && (*p) <= 57 )
2335                         goto tr109;
2336         } else if ( (*p) > 90 ) {
2337                 if ( 97 <= (*p) && (*p) <= 122 )
2338                         goto tr109;
2339         } else
2340                 goto tr109;
2341         goto tr120;
2342 st73:
2343         if ( ++p == pe )
2344                 goto _test_eof73;
2345 case 73:
2346         switch( (*p) ) {
2347                 case 95: goto tr109;
2348                 case 110: goto st74;
2349                 case 120: goto st77;
2350         }
2351         if ( (*p) < 65 ) {
2352                 if ( 48 <= (*p) && (*p) <= 57 )
2353                         goto tr109;
2354         } else if ( (*p) > 90 ) {
2355                 if ( 97 <= (*p) && (*p) <= 122 )
2356                         goto tr109;
2357         } else
2358                 goto tr109;
2359         goto tr120;
2360 st74:
2361         if ( ++p == pe )
2362                 goto _test_eof74;
2363 case 74:
2364         switch( (*p) ) {
2365                 case 95: goto tr109;
2366                 case 116: goto st75;
2367         }
2368         if ( (*p) < 65 ) {
2369                 if ( 48 <= (*p) && (*p) <= 57 )
2370                         goto tr109;
2371         } else if ( (*p) > 90 ) {
2372                 if ( 97 <= (*p) && (*p) <= 122 )
2373                         goto tr109;
2374         } else
2375                 goto tr109;
2376         goto tr120;
2377 st75:
2378         if ( ++p == pe )
2379                 goto _test_eof75;
2380 case 75:
2381         switch( (*p) ) {
2382                 case 95: goto tr109;
2383                 case 114: goto st76;
2384         }
2385         if ( (*p) < 65 ) {
2386                 if ( 48 <= (*p) && (*p) <= 57 )
2387                         goto tr109;
2388         } else if ( (*p) > 90 ) {
2389                 if ( 97 <= (*p) && (*p) <= 122 )
2390                         goto tr109;
2391         } else
2392                 goto tr109;
2393         goto tr120;
2394 st76:
2395         if ( ++p == pe )
2396                 goto _test_eof76;
2397 case 76:
2398         switch( (*p) ) {
2399                 case 95: goto tr109;
2400                 case 121: goto tr145;
2401         }
2402         if ( (*p) < 65 ) {
2403                 if ( 48 <= (*p) && (*p) <= 57 )
2404                         goto tr109;
2405         } else if ( (*p) > 90 ) {
2406                 if ( 97 <= (*p) && (*p) <= 122 )
2407                         goto tr109;
2408         } else
2409                 goto tr109;
2410         goto tr120;
2411 st77:
2412         if ( ++p == pe )
2413                 goto _test_eof77;
2414 case 77:
2415         switch( (*p) ) {
2416                 case 95: goto tr109;
2417                 case 101: goto st78;
2418         }
2419         if ( (*p) < 65 ) {
2420                 if ( 48 <= (*p) && (*p) <= 57 )
2421                         goto tr109;
2422         } else if ( (*p) > 90 ) {
2423                 if ( 97 <= (*p) && (*p) <= 122 )
2424                         goto tr109;
2425         } else
2426                 goto tr109;
2427         goto tr120;
2428 st78:
2429         if ( ++p == pe )
2430                 goto _test_eof78;
2431 case 78:
2432         switch( (*p) ) {
2433                 case 95: goto tr109;
2434                 case 99: goto tr147;
2435         }
2436         if ( (*p) < 65 ) {
2437                 if ( 48 <= (*p) && (*p) <= 57 )
2438                         goto tr109;
2439         } else if ( (*p) > 90 ) {
2440                 if ( 97 <= (*p) && (*p) <= 122 )
2441                         goto tr109;
2442         } else
2443                 goto tr109;
2444         goto tr120;
2445 st79:
2446         if ( ++p == pe )
2447                 goto _test_eof79;
2448 case 79:
2449         switch( (*p) ) {
2450                 case 95: goto tr109;
2451                 case 111: goto st80;
2452         }
2453         if ( (*p) < 65 ) {
2454                 if ( 48 <= (*p) && (*p) <= 57 )
2455                         goto tr109;
2456         } else if ( (*p) > 90 ) {
2457                 if ( 97 <= (*p) && (*p) <= 122 )
2458                         goto tr109;
2459         } else
2460                 goto tr109;
2461         goto tr120;
2462 st80:
2463         if ( ++p == pe )
2464                 goto _test_eof80;
2465 case 80:
2466         switch( (*p) ) {
2467                 case 95: goto tr109;
2468                 case 116: goto st81;
2469         }
2470         if ( (*p) < 65 ) {
2471                 if ( 48 <= (*p) && (*p) <= 57 )
2472                         goto tr109;
2473         } else if ( (*p) > 90 ) {
2474                 if ( 97 <= (*p) && (*p) <= 122 )
2475                         goto tr109;
2476         } else
2477                 goto tr109;
2478         goto tr120;
2479 st81:
2480         if ( ++p == pe )
2481                 goto _test_eof81;
2482 case 81:
2483         switch( (*p) ) {
2484                 case 95: goto tr109;
2485                 case 111: goto tr150;
2486         }
2487         if ( (*p) < 65 ) {
2488                 if ( 48 <= (*p) && (*p) <= 57 )
2489                         goto tr109;
2490         } else if ( (*p) > 90 ) {
2491                 if ( 97 <= (*p) && (*p) <= 122 )
2492                         goto tr109;
2493         } else
2494                 goto tr109;
2495         goto tr120;
2496 st82:
2497         if ( ++p == pe )
2498                 goto _test_eof82;
2499 case 82:
2500         switch( (*p) ) {
2501                 case 95: goto tr109;
2502                 case 111: goto st83;
2503         }
2504         if ( (*p) < 65 ) {
2505                 if ( 48 <= (*p) && (*p) <= 57 )
2506                         goto tr109;
2507         } else if ( (*p) > 90 ) {
2508                 if ( 97 <= (*p) && (*p) <= 122 )
2509                         goto tr109;
2510         } else
2511                 goto tr109;
2512         goto tr120;
2513 st83:
2514         if ( ++p == pe )
2515                 goto _test_eof83;
2516 case 83:
2517         switch( (*p) ) {
2518                 case 95: goto tr109;
2519                 case 108: goto st84;
2520         }
2521         if ( (*p) < 65 ) {
2522                 if ( 48 <= (*p) && (*p) <= 57 )
2523                         goto tr109;
2524         } else if ( (*p) > 90 ) {
2525                 if ( 97 <= (*p) && (*p) <= 122 )
2526                         goto tr109;
2527         } else
2528                 goto tr109;
2529         goto tr120;
2530 st84:
2531         if ( ++p == pe )
2532                 goto _test_eof84;
2533 case 84:
2534         switch( (*p) ) {
2535                 case 95: goto tr109;
2536                 case 100: goto tr153;
2537         }
2538         if ( (*p) < 65 ) {
2539                 if ( 48 <= (*p) && (*p) <= 57 )
2540                         goto tr109;
2541         } else if ( (*p) > 90 ) {
2542                 if ( 97 <= (*p) && (*p) <= 122 )
2543                         goto tr109;
2544         } else
2545                 goto tr109;
2546         goto tr120;
2547 st85:
2548         if ( ++p == pe )
2549                 goto _test_eof85;
2550 case 85:
2551         switch( (*p) ) {
2552                 case 95: goto tr109;
2553                 case 101: goto st86;
2554         }
2555         if ( (*p) < 65 ) {
2556                 if ( 48 <= (*p) && (*p) <= 57 )
2557                         goto tr109;
2558         } else if ( (*p) > 90 ) {
2559                 if ( 97 <= (*p) && (*p) <= 122 )
2560                         goto tr109;
2561         } else
2562                 goto tr109;
2563         goto tr120;
2564 st86:
2565         if ( ++p == pe )
2566                 goto _test_eof86;
2567 case 86:
2568         switch( (*p) ) {
2569                 case 95: goto tr109;
2570                 case 120: goto st87;
2571         }
2572         if ( (*p) < 65 ) {
2573                 if ( 48 <= (*p) && (*p) <= 57 )
2574                         goto tr109;
2575         } else if ( (*p) > 90 ) {
2576                 if ( 97 <= (*p) && (*p) <= 122 )
2577                         goto tr109;
2578         } else
2579                 goto tr109;
2580         goto tr120;
2581 st87:
2582         if ( ++p == pe )
2583                 goto _test_eof87;
2584 case 87:
2585         switch( (*p) ) {
2586                 case 95: goto tr109;
2587                 case 116: goto tr156;
2588         }
2589         if ( (*p) < 65 ) {
2590                 if ( 48 <= (*p) && (*p) <= 57 )
2591                         goto tr109;
2592         } else if ( (*p) > 90 ) {
2593                 if ( 97 <= (*p) && (*p) <= 122 )
2594                         goto tr109;
2595         } else
2596                 goto tr109;
2597         goto tr120;
2598 st88:
2599         if ( ++p == pe )
2600                 goto _test_eof88;
2601 case 88:
2602         switch( (*p) ) {
2603                 case 95: goto tr109;
2604                 case 99: goto tr157;
2605         }
2606         if ( (*p) < 65 ) {
2607                 if ( 48 <= (*p) && (*p) <= 57 )
2608                         goto tr109;
2609         } else if ( (*p) > 90 ) {
2610                 if ( 97 <= (*p) && (*p) <= 122 )
2611                         goto tr109;
2612         } else
2613                 goto tr109;
2614         goto tr120;
2615 st89:
2616         if ( ++p == pe )
2617                 goto _test_eof89;
2618 case 89:
2619         switch( (*p) ) {
2620                 case 95: goto tr109;
2621                 case 101: goto st90;
2622         }
2623         if ( (*p) < 65 ) {
2624                 if ( 48 <= (*p) && (*p) <= 57 )
2625                         goto tr109;
2626         } else if ( (*p) > 90 ) {
2627                 if ( 97 <= (*p) && (*p) <= 122 )
2628                         goto tr109;
2629         } else
2630                 goto tr109;
2631         goto tr120;
2632 st90:
2633         if ( ++p == pe )
2634                 goto _test_eof90;
2635 case 90:
2636         switch( (*p) ) {
2637                 case 95: goto tr109;
2638                 case 116: goto tr159;
2639         }
2640         if ( (*p) < 65 ) {
2641                 if ( 48 <= (*p) && (*p) <= 57 )
2642                         goto tr109;
2643         } else if ( (*p) > 90 ) {
2644                 if ( 97 <= (*p) && (*p) <= 122 )
2645                         goto tr109;
2646         } else
2647                 goto tr109;
2648         goto tr120;
2649 st91:
2650         if ( ++p == pe )
2651                 goto _test_eof91;
2652 case 91:
2653         switch( (*p) ) {
2654                 case 95: goto tr109;
2655                 case 97: goto st92;
2656         }
2657         if ( (*p) < 65 ) {
2658                 if ( 48 <= (*p) && (*p) <= 57 )
2659                         goto tr109;
2660         } else if ( (*p) > 90 ) {
2661                 if ( 98 <= (*p) && (*p) <= 122 )
2662                         goto tr109;
2663         } else
2664                 goto tr109;
2665         goto tr120;
2666 st92:
2667         if ( ++p == pe )
2668                 goto _test_eof92;
2669 case 92:
2670         switch( (*p) ) {
2671                 case 95: goto tr109;
2672                 case 114: goto st93;
2673         }
2674         if ( (*p) < 65 ) {
2675                 if ( 48 <= (*p) && (*p) <= 57 )
2676                         goto tr109;
2677         } else if ( (*p) > 90 ) {
2678                 if ( 97 <= (*p) && (*p) <= 122 )
2679                         goto tr109;
2680         } else
2681                 goto tr109;
2682         goto tr120;
2683 st93:
2684         if ( ++p == pe )
2685                 goto _test_eof93;
2686 case 93:
2687         switch( (*p) ) {
2688                 case 95: goto tr109;
2689                 case 103: goto st94;
2690         }
2691         if ( (*p) < 65 ) {
2692                 if ( 48 <= (*p) && (*p) <= 57 )
2693                         goto tr109;
2694         } else if ( (*p) > 90 ) {
2695                 if ( 97 <= (*p) && (*p) <= 122 )
2696                         goto tr109;
2697         } else
2698                 goto tr109;
2699         goto tr120;
2700 st94:
2701         if ( ++p == pe )
2702                 goto _test_eof94;
2703 case 94:
2704         switch( (*p) ) {
2705                 case 95: goto tr109;
2706                 case 115: goto tr163;
2707         }
2708         if ( (*p) < 65 ) {
2709                 if ( 48 <= (*p) && (*p) <= 57 )
2710                         goto tr109;
2711         } else if ( (*p) > 90 ) {
2712                 if ( 97 <= (*p) && (*p) <= 122 )
2713                         goto tr109;
2714         } else
2715                 goto tr109;
2716         goto tr120;
2717 tr29:
2718 #line 862 "rlscan.rl"
2719         {{p = ((te))-1;}{ token( IL_Symbol, ts, te ); }}
2720         goto st95;
2721 tr32:
2722 #line 808 "rlscan.rl"
2723         {te = p+1;{ token( IL_Literal, ts, te ); }}
2724         goto st95;
2725 tr40:
2726 #line 815 "rlscan.rl"
2727         {te = p+1;{ token( IL_Comment, ts, te ); }}
2728         goto st95;
2729 tr42:
2730 #line 630 "rlscan.rl"
2731         {
2732                 lastnl = p;
2733                 column = 0;
2734                 line++;
2735         }
2736 #line 815 "rlscan.rl"
2737         {te = p+1;{ token( IL_Comment, ts, te ); }}
2738         goto st95;
2739 tr43:
2740 #line 804 "rlscan.rl"
2741         {{p = ((te))-1;}{ token( TK_UInt, ts, te ); }}
2742         goto st95;
2743 tr164:
2744 #line 862 "rlscan.rl"
2745         {te = p+1;{ token( IL_Symbol, ts, te ); }}
2746         goto st95;
2747 tr165:
2748 #line 857 "rlscan.rl"
2749         {te = p+1;{
2750                         scan_error() << "unterminated code block" << endl;
2751                 }}
2752         goto st95;
2753 tr170:
2754 #line 837 "rlscan.rl"
2755         {te = p+1;{ token( *ts, ts, te ); }}
2756         goto st95;
2757 tr171:
2758 #line 832 "rlscan.rl"
2759         {te = p+1;{
2760                         whitespaceOn = true;
2761                         token( *ts, ts, te );
2762                 }}
2763         goto st95;
2764 tr176:
2765 #line 825 "rlscan.rl"
2766         {te = p+1;{
2767                         whitespaceOn = true;
2768                         token( *ts, ts, te );
2769                         if ( inlineBlockType == SemiTerminated )
2770                                 {cs = stack[--top];goto _again;}
2771                 }}
2772         goto st95;
2773 tr179:
2774 #line 839 "rlscan.rl"
2775         {te = p+1;{
2776                         token( IL_Symbol, ts, te );
2777                         curly_count += 1;
2778                 }}
2779         goto st95;
2780 tr180:
2781 #line 844 "rlscan.rl"
2782         {te = p+1;{
2783                         if ( --curly_count == 0 && inlineBlockType == CurlyDelimited ) {
2784                                 /* Inline code block ends. */
2785                                 token( '}' );
2786                                 {cs = stack[--top];goto _again;}
2787                         }
2788                         else {
2789                                 /* Either a semi terminated inline block or only the closing
2790                                  * brace of some inner scope, not the block's closing brace. */
2791                                 token( IL_Symbol, ts, te );
2792                         }
2793                 }}
2794         goto st95;
2795 tr181:
2796 #line 810 "rlscan.rl"
2797         {te = p;p--;{
2798                         if ( whitespaceOn )
2799                                 token( IL_WhiteSpace, ts, te );
2800                 }}
2801         goto st95;
2802 tr182:
2803 #line 862 "rlscan.rl"
2804         {te = p;p--;{ token( IL_Symbol, ts, te ); }}
2805         goto st95;
2806 tr183:
2807 #line 804 "rlscan.rl"
2808         {te = p;p--;{ token( TK_UInt, ts, te ); }}
2809         goto st95;
2810 tr185:
2811 #line 805 "rlscan.rl"
2812         {te = p;p--;{ token( TK_Hex, ts, te ); }}
2813         goto st95;
2814 tr186:
2815 #line 817 "rlscan.rl"
2816         {te = p+1;{ token( TK_NameSep, ts, te ); }}
2817         goto st95;
2818 tr187:
2819 #line 1 "rlscan.rl"
2820         {       switch( act ) {
2821         case 27:
2822         {{p = ((te))-1;} token( KW_PChar ); }
2823         break;
2824         case 29:
2825         {{p = ((te))-1;} token( KW_CurState ); }
2826         break;
2827         case 30:
2828         {{p = ((te))-1;} token( KW_TargState ); }
2829         break;
2830         case 31:
2831         {{p = ((te))-1;}
2832                         whitespaceOn = false;
2833                         token( KW_Entry );
2834                 }
2835         break;
2836         case 32:
2837         {{p = ((te))-1;}
2838                         whitespaceOn = false;
2839                         token( KW_Hold );
2840                 }
2841         break;
2842         case 33:
2843         {{p = ((te))-1;} token( KW_Exec, 0, 0 ); }
2844         break;
2845         case 34:
2846         {{p = ((te))-1;}
2847                         whitespaceOn = false;
2848                         token( KW_Goto );
2849                 }
2850         break;
2851         case 35:
2852         {{p = ((te))-1;}
2853                         whitespaceOn = false;
2854                         token( KW_Next );
2855                 }
2856         break;
2857         case 36:
2858         {{p = ((te))-1;}
2859                         whitespaceOn = false;
2860                         token( KW_Call );
2861                 }
2862         break;
2863         case 37:
2864         {{p = ((te))-1;}
2865                         whitespaceOn = false;
2866                         token( KW_Ret );
2867                 }
2868         break;
2869         case 38:
2870         {{p = ((te))-1;}
2871                         whitespaceOn = false;
2872                         token( KW_Break );
2873                 }
2874         break;
2875         case 39:
2876         {{p = ((te))-1;} token( TK_Word, ts, te ); }
2877         break;
2878         }
2879         }
2880         goto st95;
2881 tr188:
2882 #line 802 "rlscan.rl"
2883         {te = p;p--;{ token( TK_Word, ts, te ); }}
2884         goto st95;
2885 tr202:
2886 #line 767 "rlscan.rl"
2887         {te = p;p--;{ token( KW_Char ); }}
2888         goto st95;
2889 st95:
2890 #line 1 "rlscan.rl"
2891         {ts = 0;}
2892         if ( ++p == pe )
2893                 goto _test_eof95;
2894 case 95:
2895 #line 1 "rlscan.rl"
2896         {ts = p;}
2897 #line 2898 "rlscan.cpp"
2898         switch( (*p) ) {
2899                 case 0: goto tr165;
2900                 case 9: goto st96;
2901                 case 10: goto tr167;
2902                 case 32: goto st96;
2903                 case 34: goto tr168;
2904                 case 39: goto tr169;
2905                 case 40: goto tr170;
2906                 case 44: goto tr170;
2907                 case 47: goto tr172;
2908                 case 48: goto tr173;
2909                 case 58: goto st103;
2910                 case 59: goto tr176;
2911                 case 95: goto tr177;
2912                 case 102: goto st105;
2913                 case 123: goto tr179;
2914                 case 125: goto tr180;
2915         }
2916         if ( (*p) < 49 ) {
2917                 if ( 41 <= (*p) && (*p) <= 42 )
2918                         goto tr171;
2919         } else if ( (*p) > 57 ) {
2920                 if ( (*p) > 90 ) {
2921                         if ( 97 <= (*p) && (*p) <= 122 )
2922                                 goto tr177;
2923                 } else if ( (*p) >= 65 )
2924                         goto tr177;
2925         } else
2926                 goto st101;
2927         goto tr164;
2928 tr167:
2929 #line 630 "rlscan.rl"
2930         {
2931                 lastnl = p;
2932                 column = 0;
2933                 line++;
2934         }
2935         goto st96;
2936 st96:
2937         if ( ++p == pe )
2938                 goto _test_eof96;
2939 case 96:
2940 #line 2941 "rlscan.cpp"
2941         switch( (*p) ) {
2942                 case 9: goto st96;
2943                 case 10: goto tr167;
2944                 case 32: goto st96;
2945         }
2946         goto tr181;
2947 tr168:
2948 #line 1 "rlscan.rl"
2949         {te = p+1;}
2950         goto st97;
2951 st97:
2952         if ( ++p == pe )
2953                 goto _test_eof97;
2954 case 97:
2955 #line 2956 "rlscan.cpp"
2956         switch( (*p) ) {
2957                 case 10: goto tr31;
2958                 case 34: goto tr32;
2959                 case 92: goto st17;
2960         }
2961         goto st16;
2962 tr31:
2963 #line 630 "rlscan.rl"
2964         {
2965                 lastnl = p;
2966                 column = 0;
2967                 line++;
2968         }
2969         goto st16;
2970 st16:
2971         if ( ++p == pe )
2972                 goto _test_eof16;
2973 case 16:
2974 #line 2975 "rlscan.cpp"
2975         switch( (*p) ) {
2976                 case 10: goto tr31;
2977                 case 34: goto tr32;
2978                 case 92: goto st17;
2979         }
2980         goto st16;
2981 st17:
2982         if ( ++p == pe )
2983                 goto _test_eof17;
2984 case 17:
2985         if ( (*p) == 10 )
2986                 goto tr31;
2987         goto st16;
2988 tr169:
2989 #line 1 "rlscan.rl"
2990         {te = p+1;}
2991         goto st98;
2992 st98:
2993         if ( ++p == pe )
2994                 goto _test_eof98;
2995 case 98:
2996 #line 2997 "rlscan.cpp"
2997         switch( (*p) ) {
2998                 case 10: goto tr35;
2999                 case 39: goto tr32;
3000                 case 92: goto st19;
3001         }
3002         goto st18;
3003 tr35:
3004 #line 630 "rlscan.rl"
3005         {
3006                 lastnl = p;
3007                 column = 0;
3008                 line++;
3009         }
3010         goto st18;
3011 st18:
3012         if ( ++p == pe )
3013                 goto _test_eof18;
3014 case 18:
3015 #line 3016 "rlscan.cpp"
3016         switch( (*p) ) {
3017                 case 10: goto tr35;
3018                 case 39: goto tr32;
3019                 case 92: goto st19;
3020         }
3021         goto st18;
3022 st19:
3023         if ( ++p == pe )
3024                 goto _test_eof19;
3025 case 19:
3026         if ( (*p) == 10 )
3027                 goto tr35;
3028         goto st18;
3029 tr172:
3030 #line 1 "rlscan.rl"
3031         {te = p+1;}
3032         goto st99;
3033 st99:
3034         if ( ++p == pe )
3035                 goto _test_eof99;
3036 case 99:
3037 #line 3038 "rlscan.cpp"
3038         switch( (*p) ) {
3039                 case 42: goto st20;
3040                 case 47: goto st22;
3041         }
3042         goto tr182;
3043 tr38:
3044 #line 630 "rlscan.rl"
3045         {
3046                 lastnl = p;
3047                 column = 0;
3048                 line++;
3049         }
3050         goto st20;
3051 st20:
3052         if ( ++p == pe )
3053                 goto _test_eof20;
3054 case 20:
3055 #line 3056 "rlscan.cpp"
3056         switch( (*p) ) {
3057                 case 10: goto tr38;
3058                 case 42: goto st21;
3059         }
3060         goto st20;
3061 st21:
3062         if ( ++p == pe )
3063                 goto _test_eof21;
3064 case 21:
3065         switch( (*p) ) {
3066                 case 10: goto tr38;
3067                 case 42: goto st21;
3068                 case 47: goto tr40;
3069         }
3070         goto st20;
3071 st22:
3072         if ( ++p == pe )
3073                 goto _test_eof22;
3074 case 22:
3075         if ( (*p) == 10 )
3076                 goto tr42;
3077         goto st22;
3078 tr173:
3079 #line 1 "rlscan.rl"
3080         {te = p+1;}
3081         goto st100;
3082 st100:
3083         if ( ++p == pe )
3084                 goto _test_eof100;
3085 case 100:
3086 #line 3087 "rlscan.cpp"
3087         if ( (*p) == 120 )
3088                 goto st23;
3089         if ( 48 <= (*p) && (*p) <= 57 )
3090                 goto st101;
3091         goto tr183;
3092 st101:
3093         if ( ++p == pe )
3094                 goto _test_eof101;
3095 case 101:
3096         if ( 48 <= (*p) && (*p) <= 57 )
3097                 goto st101;
3098         goto tr183;
3099 st23:
3100         if ( ++p == pe )
3101                 goto _test_eof23;
3102 case 23:
3103         if ( (*p) < 65 ) {
3104                 if ( 48 <= (*p) && (*p) <= 57 )
3105                         goto st102;
3106         } else if ( (*p) > 70 ) {
3107                 if ( 97 <= (*p) && (*p) <= 102 )
3108                         goto st102;
3109         } else
3110                 goto st102;
3111         goto tr43;
3112 st102:
3113         if ( ++p == pe )
3114                 goto _test_eof102;
3115 case 102:
3116         if ( (*p) < 65 ) {
3117                 if ( 48 <= (*p) && (*p) <= 57 )
3118                         goto st102;
3119         } else if ( (*p) > 70 ) {
3120                 if ( 97 <= (*p) && (*p) <= 102 )
3121                         goto st102;
3122         } else
3123                 goto st102;
3124         goto tr185;
3125 st103:
3126         if ( ++p == pe )
3127                 goto _test_eof103;
3128 case 103:
3129         if ( (*p) == 58 )
3130                 goto tr186;
3131         goto tr182;
3132 tr177:
3133 #line 1 "rlscan.rl"
3134         {te = p+1;}
3135 #line 802 "rlscan.rl"
3136         {act = 39;}
3137         goto st104;
3138 tr201:
3139 #line 1 "rlscan.rl"
3140         {te = p+1;}
3141 #line 797 "rlscan.rl"
3142         {act = 38;}
3143         goto st104;
3144 tr206:
3145 #line 1 "rlscan.rl"
3146         {te = p+1;}
3147 #line 789 "rlscan.rl"
3148         {act = 36;}
3149         goto st104;
3150 tr208:
3151 #line 1 "rlscan.rl"
3152         {te = p+1;}
3153 #line 768 "rlscan.rl"
3154         {act = 29;}
3155         goto st104;
3156 tr213:
3157 #line 1 "rlscan.rl"
3158         {te = p+1;}
3159 #line 770 "rlscan.rl"
3160         {act = 31;}
3161         goto st104;
3162 tr215:
3163 #line 1 "rlscan.rl"
3164         {te = p+1;}
3165 #line 780 "rlscan.rl"
3166         {act = 33;}
3167         goto st104;
3168 tr218:
3169 #line 1 "rlscan.rl"
3170         {te = p+1;}
3171 #line 781 "rlscan.rl"
3172         {act = 34;}
3173         goto st104;
3174 tr221:
3175 #line 1 "rlscan.rl"
3176         {te = p+1;}
3177 #line 776 "rlscan.rl"
3178         {act = 32;}
3179         goto st104;
3180 tr224:
3181 #line 1 "rlscan.rl"
3182         {te = p+1;}
3183 #line 785 "rlscan.rl"
3184         {act = 35;}
3185         goto st104;
3186 tr225:
3187 #line 1 "rlscan.rl"
3188         {te = p+1;}
3189 #line 766 "rlscan.rl"
3190         {act = 27;}
3191         goto st104;
3192 tr227:
3193 #line 1 "rlscan.rl"
3194         {te = p+1;}
3195 #line 793 "rlscan.rl"
3196         {act = 37;}
3197         goto st104;
3198 tr231:
3199 #line 1 "rlscan.rl"
3200         {te = p+1;}
3201 #line 769 "rlscan.rl"
3202         {act = 30;}
3203         goto st104;
3204 st104:
3205         if ( ++p == pe )
3206                 goto _test_eof104;
3207 case 104:
3208 #line 3209 "rlscan.cpp"
3209         if ( (*p) == 95 )
3210                 goto tr177;
3211         if ( (*p) < 65 ) {
3212                 if ( 48 <= (*p) && (*p) <= 57 )
3213                         goto tr177;
3214         } else if ( (*p) > 90 ) {
3215                 if ( 97 <= (*p) && (*p) <= 122 )
3216                         goto tr177;
3217         } else
3218                 goto tr177;
3219         goto tr187;
3220 st105:
3221         if ( ++p == pe )
3222                 goto _test_eof105;
3223 case 105:
3224         switch( (*p) ) {
3225                 case 95: goto tr177;
3226                 case 98: goto st106;
3227                 case 99: goto st110;
3228                 case 101: goto st115;
3229                 case 103: goto st121;
3230                 case 104: goto st124;
3231                 case 110: goto st127;
3232                 case 112: goto st130;
3233                 case 114: goto st131;
3234                 case 116: goto st133;
3235         }
3236         if ( (*p) < 65 ) {
3237                 if ( 48 <= (*p) && (*p) <= 57 )
3238                         goto tr177;
3239         } else if ( (*p) > 90 ) {
3240                 if ( 97 <= (*p) && (*p) <= 122 )
3241                         goto tr177;
3242         } else
3243                 goto tr177;
3244         goto tr188;
3245 st106:
3246         if ( ++p == pe )
3247                 goto _test_eof106;
3248 case 106:
3249         switch( (*p) ) {
3250                 case 95: goto tr177;
3251                 case 114: goto st107;
3252         }
3253         if ( (*p) < 65 ) {
3254                 if ( 48 <= (*p) && (*p) <= 57 )
3255                         goto tr177;
3256         } else if ( (*p) > 90 ) {
3257                 if ( 97 <= (*p) && (*p) <= 122 )
3258                         goto tr177;
3259         } else
3260                 goto tr177;
3261         goto tr188;
3262 st107:
3263         if ( ++p == pe )
3264                 goto _test_eof107;
3265 case 107:
3266         switch( (*p) ) {
3267                 case 95: goto tr177;
3268                 case 101: goto st108;
3269         }
3270         if ( (*p) < 65 ) {
3271                 if ( 48 <= (*p) && (*p) <= 57 )
3272                         goto tr177;
3273         } else if ( (*p) > 90 ) {
3274                 if ( 97 <= (*p) && (*p) <= 122 )
3275                         goto tr177;
3276         } else
3277                 goto tr177;
3278         goto tr188;
3279 st108:
3280         if ( ++p == pe )
3281                 goto _test_eof108;
3282 case 108:
3283         switch( (*p) ) {
3284                 case 95: goto tr177;
3285                 case 97: goto st109;
3286         }
3287         if ( (*p) < 65 ) {
3288                 if ( 48 <= (*p) && (*p) <= 57 )
3289                         goto tr177;
3290         } else if ( (*p) > 90 ) {
3291                 if ( 98 <= (*p) && (*p) <= 122 )
3292                         goto tr177;
3293         } else
3294                 goto tr177;
3295         goto tr188;
3296 st109:
3297         if ( ++p == pe )
3298                 goto _test_eof109;
3299 case 109:
3300         switch( (*p) ) {
3301                 case 95: goto tr177;
3302                 case 107: goto tr201;
3303         }
3304         if ( (*p) < 65 ) {
3305                 if ( 48 <= (*p) && (*p) <= 57 )
3306                         goto tr177;
3307         } else if ( (*p) > 90 ) {
3308                 if ( 97 <= (*p) && (*p) <= 122 )
3309                         goto tr177;
3310         } else
3311                 goto tr177;
3312         goto tr188;
3313 st110:
3314         if ( ++p == pe )
3315                 goto _test_eof110;
3316 case 110:
3317         switch( (*p) ) {
3318                 case 95: goto tr177;
3319                 case 97: goto st111;
3320                 case 117: goto st113;
3321         }
3322         if ( (*p) < 65 ) {
3323                 if ( 48 <= (*p) && (*p) <= 57 )
3324                         goto tr177;
3325         } else if ( (*p) > 90 ) {
3326                 if ( 98 <= (*p) && (*p) <= 122 )
3327                         goto tr177;
3328         } else
3329                 goto tr177;
3330         goto tr202;
3331 st111:
3332         if ( ++p == pe )
3333                 goto _test_eof111;
3334 case 111:
3335         switch( (*p) ) {
3336                 case 95: goto tr177;
3337                 case 108: goto st112;
3338         }
3339         if ( (*p) < 65 ) {
3340                 if ( 48 <= (*p) && (*p) <= 57 )
3341                         goto tr177;
3342         } else if ( (*p) > 90 ) {
3343                 if ( 97 <= (*p) && (*p) <= 122 )
3344                         goto tr177;
3345         } else
3346                 goto tr177;
3347         goto tr188;
3348 st112:
3349         if ( ++p == pe )
3350                 goto _test_eof112;
3351 case 112:
3352         switch( (*p) ) {
3353                 case 95: goto tr177;
3354                 case 108: goto tr206;
3355         }
3356         if ( (*p) < 65 ) {
3357                 if ( 48 <= (*p) && (*p) <= 57 )
3358                         goto tr177;
3359         } else if ( (*p) > 90 ) {
3360                 if ( 97 <= (*p) && (*p) <= 122 )
3361                         goto tr177;
3362         } else
3363                 goto tr177;
3364         goto tr188;
3365 st113:
3366         if ( ++p == pe )
3367                 goto _test_eof113;
3368 case 113:
3369         switch( (*p) ) {
3370                 case 95: goto tr177;
3371                 case 114: goto st114;
3372         }
3373         if ( (*p) < 65 ) {
3374                 if ( 48 <= (*p) && (*p) <= 57 )
3375                         goto tr177;
3376         } else if ( (*p) > 90 ) {
3377                 if ( 97 <= (*p) && (*p) <= 122 )
3378                         goto tr177;
3379         } else
3380                 goto tr177;
3381         goto tr188;
3382 st114:
3383         if ( ++p == pe )
3384                 goto _test_eof114;
3385 case 114:
3386         switch( (*p) ) {
3387                 case 95: goto tr177;
3388                 case 115: goto tr208;
3389         }
3390         if ( (*p) < 65 ) {
3391                 if ( 48 <= (*p) && (*p) <= 57 )
3392                         goto tr177;
3393         } else if ( (*p) > 90 ) {
3394                 if ( 97 <= (*p) && (*p) <= 122 )
3395                         goto tr177;
3396         } else
3397                 goto tr177;
3398         goto tr188;
3399 st115:
3400         if ( ++p == pe )
3401                 goto _test_eof115;
3402 case 115:
3403         switch( (*p) ) {
3404                 case 95: goto tr177;
3405                 case 110: goto st116;
3406                 case 120: goto st119;
3407         }
3408         if ( (*p) < 65 ) {
3409                 if ( 48 <= (*p) && (*p) <= 57 )
3410                         goto tr177;
3411         } else if ( (*p) > 90 ) {
3412                 if ( 97 <= (*p) && (*p) <= 122 )
3413                         goto tr177;
3414         } else
3415                 goto tr177;
3416         goto tr188;
3417 st116:
3418         if ( ++p == pe )
3419                 goto _test_eof116;
3420 case 116:
3421         switch( (*p) ) {
3422                 case 95: goto tr177;
3423                 case 116: goto st117;
3424         }
3425         if ( (*p) < 65 ) {
3426                 if ( 48 <= (*p) && (*p) <= 57 )
3427                         goto tr177;
3428         } else if ( (*p) > 90 ) {
3429                 if ( 97 <= (*p) && (*p) <= 122 )
3430                         goto tr177;
3431         } else
3432                 goto tr177;
3433         goto tr188;
3434 st117:
3435         if ( ++p == pe )
3436                 goto _test_eof117;
3437 case 117:
3438         switch( (*p) ) {
3439                 case 95: goto tr177;
3440                 case 114: goto st118;
3441         }
3442         if ( (*p) < 65 ) {
3443                 if ( 48 <= (*p) && (*p) <= 57 )
3444                         goto tr177;
3445         } else if ( (*p) > 90 ) {
3446                 if ( 97 <= (*p) && (*p) <= 122 )
3447                         goto tr177;
3448         } else
3449                 goto tr177;
3450         goto tr188;
3451 st118:
3452         if ( ++p == pe )
3453                 goto _test_eof118;
3454 case 118:
3455         switch( (*p) ) {
3456                 case 95: goto tr177;
3457                 case 121: goto tr213;
3458         }
3459         if ( (*p) < 65 ) {
3460                 if ( 48 <= (*p) && (*p) <= 57 )
3461                         goto tr177;
3462         } else if ( (*p) > 90 ) {
3463                 if ( 97 <= (*p) && (*p) <= 122 )
3464                         goto tr177;
3465         } else
3466                 goto tr177;
3467         goto tr188;
3468 st119:
3469         if ( ++p == pe )
3470                 goto _test_eof119;
3471 case 119:
3472         switch( (*p) ) {
3473                 case 95: goto tr177;
3474                 case 101: goto st120;
3475         }
3476         if ( (*p) < 65 ) {
3477                 if ( 48 <= (*p) && (*p) <= 57 )
3478                         goto tr177;
3479         } else if ( (*p) > 90 ) {
3480                 if ( 97 <= (*p) && (*p) <= 122 )
3481                         goto tr177;
3482         } else
3483                 goto tr177;
3484         goto tr188;
3485 st120:
3486         if ( ++p == pe )
3487                 goto _test_eof120;
3488 case 120:
3489         switch( (*p) ) {
3490                 case 95: goto tr177;
3491                 case 99: goto tr215;
3492         }
3493         if ( (*p) < 65 ) {
3494                 if ( 48 <= (*p) && (*p) <= 57 )
3495                         goto tr177;
3496         } else if ( (*p) > 90 ) {
3497                 if ( 97 <= (*p) && (*p) <= 122 )
3498                         goto tr177;
3499         } else
3500                 goto tr177;
3501         goto tr188;
3502 st121:
3503         if ( ++p == pe )
3504                 goto _test_eof121;
3505 case 121:
3506         switch( (*p) ) {
3507                 case 95: goto tr177;
3508                 case 111: goto st122;
3509         }
3510         if ( (*p) < 65 ) {
3511                 if ( 48 <= (*p) && (*p) <= 57 )
3512                         goto tr177;
3513         } else if ( (*p) > 90 ) {
3514                 if ( 97 <= (*p) && (*p) <= 122 )
3515                         goto tr177;
3516         } else
3517                 goto tr177;
3518         goto tr188;
3519 st122:
3520         if ( ++p == pe )
3521                 goto _test_eof122;
3522 case 122:
3523         switch( (*p) ) {
3524                 case 95: goto tr177;
3525                 case 116: goto st123;
3526         }
3527         if ( (*p) < 65 ) {
3528                 if ( 48 <= (*p) && (*p) <= 57 )
3529                         goto tr177;
3530         } else if ( (*p) > 90 ) {
3531                 if ( 97 <= (*p) && (*p) <= 122 )
3532                         goto tr177;
3533         } else
3534                 goto tr177;
3535         goto tr188;
3536 st123:
3537         if ( ++p == pe )
3538                 goto _test_eof123;
3539 case 123:
3540         switch( (*p) ) {
3541                 case 95: goto tr177;
3542                 case 111: goto tr218;
3543         }
3544         if ( (*p) < 65 ) {
3545                 if ( 48 <= (*p) && (*p) <= 57 )
3546                         goto tr177;
3547         } else if ( (*p) > 90 ) {
3548                 if ( 97 <= (*p) && (*p) <= 122 )
3549                         goto tr177;
3550         } else
3551                 goto tr177;
3552         goto tr188;
3553 st124:
3554         if ( ++p == pe )
3555                 goto _test_eof124;
3556 case 124:
3557         switch( (*p) ) {
3558                 case 95: goto tr177;
3559                 case 111: goto st125;
3560         }
3561         if ( (*p) < 65 ) {
3562                 if ( 48 <= (*p) && (*p) <= 57 )
3563                         goto tr177;
3564         } else if ( (*p) > 90 ) {
3565                 if ( 97 <= (*p) && (*p) <= 122 )
3566                         goto tr177;
3567         } else
3568                 goto tr177;
3569         goto tr188;
3570 st125:
3571         if ( ++p == pe )
3572                 goto _test_eof125;
3573 case 125:
3574         switch( (*p) ) {
3575                 case 95: goto tr177;
3576                 case 108: goto st126;
3577         }
3578         if ( (*p) < 65 ) {
3579                 if ( 48 <= (*p) && (*p) <= 57 )
3580                         goto tr177;
3581         } else if ( (*p) > 90 ) {
3582                 if ( 97 <= (*p) && (*p) <= 122 )
3583                         goto tr177;
3584         } else
3585                 goto tr177;
3586         goto tr188;
3587 st126:
3588         if ( ++p == pe )
3589                 goto _test_eof126;
3590 case 126:
3591         switch( (*p) ) {
3592                 case 95: goto tr177;
3593                 case 100: goto tr221;
3594         }
3595         if ( (*p) < 65 ) {
3596                 if ( 48 <= (*p) && (*p) <= 57 )
3597                         goto tr177;
3598         } else if ( (*p) > 90 ) {
3599                 if ( 97 <= (*p) && (*p) <= 122 )
3600                         goto tr177;
3601         } else
3602                 goto tr177;
3603         goto tr188;
3604 st127:
3605         if ( ++p == pe )
3606                 goto _test_eof127;
3607 case 127:
3608         switch( (*p) ) {
3609                 case 95: goto tr177;
3610                 case 101: goto st128;
3611         }
3612         if ( (*p) < 65 ) {
3613                 if ( 48 <= (*p) && (*p) <= 57 )
3614                         goto tr177;
3615         } else if ( (*p) > 90 ) {
3616                 if ( 97 <= (*p) && (*p) <= 122 )
3617                         goto tr177;
3618         } else
3619                 goto tr177;
3620         goto tr188;
3621 st128:
3622         if ( ++p == pe )
3623                 goto _test_eof128;
3624 case 128:
3625         switch( (*p) ) {
3626                 case 95: goto tr177;
3627                 case 120: goto st129;
3628         }
3629         if ( (*p) < 65 ) {
3630                 if ( 48 <= (*p) && (*p) <= 57 )
3631                         goto tr177;
3632         } else if ( (*p) > 90 ) {
3633                 if ( 97 <= (*p) && (*p) <= 122 )
3634                         goto tr177;
3635         } else
3636                 goto tr177;
3637         goto tr188;
3638 st129:
3639         if ( ++p == pe )
3640                 goto _test_eof129;
3641 case 129:
3642         switch( (*p) ) {
3643                 case 95: goto tr177;
3644                 case 116: goto tr224;
3645         }
3646         if ( (*p) < 65 ) {
3647                 if ( 48 <= (*p) && (*p) <= 57 )
3648                         goto tr177;
3649         } else if ( (*p) > 90 ) {
3650                 if ( 97 <= (*p) && (*p) <= 122 )
3651                         goto tr177;
3652         } else
3653                 goto tr177;
3654         goto tr188;
3655 st130:
3656         if ( ++p == pe )
3657                 goto _test_eof130;
3658 case 130:
3659         switch( (*p) ) {
3660                 case 95: goto tr177;
3661                 case 99: goto tr225;
3662         }
3663         if ( (*p) < 65 ) {
3664                 if ( 48 <= (*p) && (*p) <= 57 )
3665                         goto tr177;
3666         } else if ( (*p) > 90 ) {
3667                 if ( 97 <= (*p) && (*p) <= 122 )
3668                         goto tr177;
3669         } else
3670                 goto tr177;
3671         goto tr188;
3672 st131:
3673         if ( ++p == pe )
3674                 goto _test_eof131;
3675 case 131:
3676         switch( (*p) ) {
3677                 case 95: goto tr177;
3678                 case 101: goto st132;
3679         }
3680         if ( (*p) < 65 ) {
3681                 if ( 48 <= (*p) && (*p) <= 57 )
3682                         goto tr177;
3683         } else if ( (*p) > 90 ) {
3684                 if ( 97 <= (*p) && (*p) <= 122 )
3685                         goto tr177;
3686         } else
3687                 goto tr177;
3688         goto tr188;
3689 st132:
3690         if ( ++p == pe )
3691                 goto _test_eof132;
3692 case 132:
3693         switch( (*p) ) {
3694                 case 95: goto tr177;
3695                 case 116: goto tr227;
3696         }
3697         if ( (*p) < 65 ) {
3698                 if ( 48 <= (*p) && (*p) <= 57 )
3699                         goto tr177;
3700         } else if ( (*p) > 90 ) {
3701                 if ( 97 <= (*p) && (*p) <= 122 )
3702                         goto tr177;
3703         } else
3704                 goto tr177;
3705         goto tr188;
3706 st133:
3707         if ( ++p == pe )
3708                 goto _test_eof133;
3709 case 133:
3710         switch( (*p) ) {
3711                 case 95: goto tr177;
3712                 case 97: goto st134;
3713         }
3714         if ( (*p) < 65 ) {
3715                 if ( 48 <= (*p) && (*p) <= 57 )
3716                         goto tr177;
3717         } else if ( (*p) > 90 ) {
3718                 if ( 98 <= (*p) && (*p) <= 122 )
3719                         goto tr177;
3720         } else
3721                 goto tr177;
3722         goto tr188;
3723 st134:
3724         if ( ++p == pe )
3725                 goto _test_eof134;
3726 case 134:
3727         switch( (*p) ) {
3728                 case 95: goto tr177;
3729                 case 114: goto st135;
3730         }
3731         if ( (*p) < 65 ) {
3732                 if ( 48 <= (*p) && (*p) <= 57 )
3733                         goto tr177;
3734         } else if ( (*p) > 90 ) {
3735                 if ( 97 <= (*p) && (*p) <= 122 )
3736                         goto tr177;
3737         } else
3738                 goto tr177;
3739         goto tr188;
3740 st135:
3741         if ( ++p == pe )
3742                 goto _test_eof135;
3743 case 135:
3744         switch( (*p) ) {
3745                 case 95: goto tr177;
3746                 case 103: goto st136;
3747         }
3748         if ( (*p) < 65 ) {
3749                 if ( 48 <= (*p) && (*p) <= 57 )
3750                         goto tr177;
3751         } else if ( (*p) > 90 ) {
3752                 if ( 97 <= (*p) && (*p) <= 122 )
3753                         goto tr177;
3754         } else
3755                 goto tr177;
3756         goto tr188;
3757 st136:
3758         if ( ++p == pe )
3759                 goto _test_eof136;
3760 case 136:
3761         switch( (*p) ) {
3762                 case 95: goto tr177;
3763                 case 115: goto tr231;
3764         }
3765         if ( (*p) < 65 ) {
3766                 if ( 48 <= (*p) && (*p) <= 57 )
3767                         goto tr177;
3768         } else if ( (*p) > 90 ) {
3769                 if ( 97 <= (*p) && (*p) <= 122 )
3770                         goto tr177;
3771         } else
3772                 goto tr177;
3773         goto tr188;
3774 tr232:
3775 #line 889 "rlscan.rl"
3776         {te = p+1;{ token( RE_Char, ts, te ); }}
3777         goto st137;
3778 tr233:
3779 #line 884 "rlscan.rl"
3780         {te = p+1;{
3781                         scan_error() << "unterminated OR literal" << endl;
3782                 }}
3783         goto st137;
3784 tr234:
3785 #line 879 "rlscan.rl"
3786         {te = p+1;{ token( RE_Dash, 0, 0 ); }}
3787         goto st137;
3788 tr236:
3789 #line 882 "rlscan.rl"
3790         {te = p+1;{ token( RE_SqClose ); {cs = stack[--top];goto _again;} }}
3791         goto st137;
3792 tr237:
3793 #line 889 "rlscan.rl"
3794         {te = p;p--;{ token( RE_Char, ts, te ); }}
3795         goto st137;
3796 tr238:
3797 #line 876 "rlscan.rl"
3798         {te = p+1;{ token( RE_Char, ts+1, te ); }}
3799         goto st137;
3800 tr239:
3801 #line 875 "rlscan.rl"
3802         {te = p+1;{ updateCol(); }}
3803         goto st137;
3804 tr240:
3805 #line 867 "rlscan.rl"
3806         {te = p+1;{ token( RE_Char, '\0' ); }}
3807         goto st137;
3808 tr241:
3809 #line 868 "rlscan.rl"
3810         {te = p+1;{ token( RE_Char, '\a' ); }}
3811         goto st137;
3812 tr242:
3813 #line 869 "rlscan.rl"
3814         {te = p+1;{ token( RE_Char, '\b' ); }}
3815         goto st137;
3816 tr243:
3817 #line 873 "rlscan.rl"
3818         {te = p+1;{ token( RE_Char, '\f' ); }}
3819         goto st137;
3820 tr244:
3821 #line 871 "rlscan.rl"
3822         {te = p+1;{ token( RE_Char, '\n' ); }}
3823         goto st137;
3824 tr245:
3825 #line 874 "rlscan.rl"
3826         {te = p+1;{ token( RE_Char, '\r' ); }}
3827         goto st137;
3828 tr246:
3829 #line 870 "rlscan.rl"
3830         {te = p+1;{ token( RE_Char, '\t' ); }}
3831         goto st137;
3832 tr247:
3833 #line 872 "rlscan.rl"
3834         {te = p+1;{ token( RE_Char, '\v' ); }}
3835         goto st137;
3836 st137:
3837 #line 1 "rlscan.rl"
3838         {ts = 0;}
3839         if ( ++p == pe )
3840                 goto _test_eof137;
3841 case 137:
3842 #line 1 "rlscan.rl"
3843         {ts = p;}
3844 #line 3845 "rlscan.cpp"
3845         switch( (*p) ) {
3846                 case 0: goto tr233;
3847                 case 45: goto tr234;
3848                 case 92: goto st138;
3849                 case 93: goto tr236;
3850         }
3851         goto tr232;
3852 st138:
3853         if ( ++p == pe )
3854                 goto _test_eof138;
3855 case 138:
3856         switch( (*p) ) {
3857                 case 10: goto tr239;
3858                 case 48: goto tr240;
3859                 case 97: goto tr241;
3860                 case 98: goto tr242;
3861                 case 102: goto tr243;
3862                 case 110: goto tr244;
3863                 case 114: goto tr245;
3864                 case 116: goto tr246;
3865                 case 118: goto tr247;
3866         }
3867         goto tr238;
3868 tr248:
3869 #line 924 "rlscan.rl"
3870         {te = p+1;{ token( RE_Char, ts, te ); }}
3871         goto st139;
3872 tr249:
3873 #line 919 "rlscan.rl"
3874         {te = p+1;{
3875                         scan_error() << "unterminated regular expression" << endl;
3876                 }}
3877         goto st139;
3878 tr250:
3879 #line 914 "rlscan.rl"
3880         {te = p+1;{ token( RE_Star ); }}
3881         goto st139;
3882 tr251:
3883 #line 913 "rlscan.rl"
3884         {te = p+1;{ token( RE_Dot ); }}
3885         goto st139;
3886 tr255:
3887 #line 907 "rlscan.rl"
3888         {te = p;p--;{
3889                         token( RE_Slash, ts, te );
3890                         {goto st146;}
3891                 }}
3892         goto st139;
3893 tr256:
3894 #line 907 "rlscan.rl"
3895         {te = p+1;{
3896                         token( RE_Slash, ts, te );
3897                         {goto st146;}
3898                 }}
3899         goto st139;
3900 tr257:
3901 #line 916 "rlscan.rl"
3902         {te = p;p--;{ token( RE_SqOpen ); {stack[top++] = 139; goto st137;} }}
3903         goto st139;
3904 tr258:
3905 #line 917 "rlscan.rl"
3906         {te = p+1;{ token( RE_SqOpenNeg ); {stack[top++] = 139; goto st137;} }}
3907         goto st139;
3908 tr259:
3909 #line 924 "rlscan.rl"
3910         {te = p;p--;{ token( RE_Char, ts, te ); }}
3911         goto st139;
3912 tr260:
3913 #line 904 "rlscan.rl"
3914         {te = p+1;{ token( RE_Char, ts+1, te ); }}
3915         goto st139;
3916 tr261:
3917 #line 903 "rlscan.rl"
3918         {te = p+1;{ updateCol(); }}
3919         goto st139;
3920 tr262:
3921 #line 895 "rlscan.rl"
3922         {te = p+1;{ token( RE_Char, '\0' ); }}
3923         goto st139;
3924 tr263:
3925 #line 896 "rlscan.rl"
3926         {te = p+1;{ token( RE_Char, '\a' ); }}
3927         goto st139;
3928 tr264:
3929 #line 897 "rlscan.rl"
3930         {te = p+1;{ token( RE_Char, '\b' ); }}
3931         goto st139;
3932 tr265:
3933 #line 901 "rlscan.rl"
3934         {te = p+1;{ token( RE_Char, '\f' ); }}
3935         goto st139;
3936 tr266:
3937 #line 899 "rlscan.rl"
3938         {te = p+1;{ token( RE_Char, '\n' ); }}
3939         goto st139;
3940 tr267:
3941 #line 902 "rlscan.rl"
3942         {te = p+1;{ token( RE_Char, '\r' ); }}
3943         goto st139;
3944 tr268:
3945 #line 898 "rlscan.rl"
3946         {te = p+1;{ token( RE_Char, '\t' ); }}
3947         goto st139;
3948 tr269:
3949 #line 900 "rlscan.rl"
3950         {te = p+1;{ token( RE_Char, '\v' ); }}
3951         goto st139;
3952 st139:
3953 #line 1 "rlscan.rl"
3954         {ts = 0;}
3955         if ( ++p == pe )
3956                 goto _test_eof139;
3957 case 139:
3958 #line 1 "rlscan.rl"
3959         {ts = p;}
3960 #line 3961 "rlscan.cpp"
3961         switch( (*p) ) {
3962                 case 0: goto tr249;
3963                 case 42: goto tr250;
3964                 case 46: goto tr251;
3965                 case 47: goto st140;
3966                 case 91: goto st141;
3967                 case 92: goto st142;
3968         }
3969         goto tr248;
3970 st140:
3971         if ( ++p == pe )
3972                 goto _test_eof140;
3973 case 140:
3974         if ( (*p) == 105 )
3975                 goto tr256;
3976         goto tr255;
3977 st141:
3978         if ( ++p == pe )
3979                 goto _test_eof141;
3980 case 141:
3981         if ( (*p) == 94 )
3982                 goto tr258;
3983         goto tr257;
3984 st142:
3985         if ( ++p == pe )
3986                 goto _test_eof142;
3987 case 142:
3988         switch( (*p) ) {
3989                 case 10: goto tr261;
3990                 case 48: goto tr262;
3991                 case 97: goto tr263;
3992                 case 98: goto tr264;
3993                 case 102: goto tr265;
3994                 case 110: goto tr266;
3995                 case 114: goto tr267;
3996                 case 116: goto tr268;
3997                 case 118: goto tr269;
3998         }
3999         goto tr260;
4000 tr270:
4001 #line 933 "rlscan.rl"
4002         {te = p+1;{
4003                         scan_error() << "unterminated write statement" << endl;
4004                 }}
4005         goto st143;
4006 tr273:
4007 #line 931 "rlscan.rl"
4008         {te = p+1;{ token( ';' ); {goto st146;} }}
4009         goto st143;
4010 tr275:
4011 #line 930 "rlscan.rl"
4012         {te = p;p--;{ updateCol(); }}
4013         goto st143;
4014 tr276:
4015 #line 929 "rlscan.rl"
4016         {te = p;p--;{ token( TK_Word, ts, te ); }}
4017         goto st143;
4018 st143:
4019 #line 1 "rlscan.rl"
4020         {ts = 0;}
4021         if ( ++p == pe )
4022                 goto _test_eof143;
4023 case 143:
4024 #line 1 "rlscan.rl"
4025         {ts = p;}
4026 #line 4027 "rlscan.cpp"
4027         switch( (*p) ) {
4028                 case 0: goto tr270;
4029                 case 32: goto st144;
4030                 case 59: goto tr273;
4031                 case 95: goto st145;
4032         }
4033         if ( (*p) < 65 ) {
4034                 if ( 9 <= (*p) && (*p) <= 10 )
4035                         goto st144;
4036         } else if ( (*p) > 90 ) {
4037                 if ( 97 <= (*p) && (*p) <= 122 )
4038                         goto st145;
4039         } else
4040                 goto st145;
4041         goto st0;
4042 st0:
4043 cs = 0;
4044         goto _out;
4045 st144:
4046         if ( ++p == pe )
4047                 goto _test_eof144;
4048 case 144:
4049         if ( (*p) == 32 )
4050                 goto st144;
4051         if ( 9 <= (*p) && (*p) <= 10 )
4052                 goto st144;
4053         goto tr275;
4054 st145:
4055         if ( ++p == pe )
4056                 goto _test_eof145;
4057 case 145:
4058         if ( (*p) == 95 )
4059                 goto st145;
4060         if ( (*p) < 65 ) {
4061                 if ( 48 <= (*p) && (*p) <= 57 )
4062                         goto st145;
4063         } else if ( (*p) > 90 ) {
4064                 if ( 97 <= (*p) && (*p) <= 122 )
4065                         goto st145;
4066         } else
4067                 goto st145;
4068         goto tr276;
4069 tr45:
4070 #line 1110 "rlscan.rl"
4071         {{p = ((te))-1;}{ token( *ts ); }}
4072         goto st146;
4073 tr51:
4074 #line 630 "rlscan.rl"
4075         {
4076                 lastnl = p;
4077                 column = 0;
4078                 line++;
4079         }
4080 #line 1007 "rlscan.rl"
4081         {te = p+1;{ updateCol(); }}
4082         goto st146;
4083 tr55:
4084 #line 994 "rlscan.rl"
4085         {{p = ((te))-1;}{ token( TK_UInt, ts, te ); }}
4086         goto st146;
4087 tr57:
4088 #line 1075 "rlscan.rl"
4089         {te = p+1;{
4090                         updateCol();
4091                         endSection();
4092                         {cs = stack[--top];goto _again;}
4093                 }}
4094         goto st146;
4095 tr277:
4096 #line 1110 "rlscan.rl"
4097         {te = p+1;{ token( *ts ); }}
4098         goto st146;
4099 tr278:
4100 #line 1106 "rlscan.rl"
4101         {te = p+1;{
4102                         scan_error() << "unterminated ragel section" << endl;
4103                 }}
4104         goto st146;
4105 tr280:
4106 #line 630 "rlscan.rl"
4107         {
4108                 lastnl = p;
4109                 column = 0;
4110                 line++;
4111         }
4112 #line 1084 "rlscan.rl"
4113         {te = p+1;{
4114                         updateCol();
4115                         if ( singleLineSpec ) {
4116                                 endSection();
4117                                 {cs = stack[--top];goto _again;}
4118                         }
4119                 }}
4120         goto st146;
4121 tr289:
4122 #line 1004 "rlscan.rl"
4123         {te = p+1;{ token( RE_Slash ); {goto st139;} }}
4124         goto st146;
4125 tr311:
4126 #line 1092 "rlscan.rl"
4127         {te = p+1;{
4128                         if ( lastToken == KW_Export || lastToken == KW_Entry )
4129                                 token( '{' );
4130                         else {
4131                                 token( '{' );
4132                                 curly_count = 1;
4133                                 inlineBlockType = CurlyDelimited;
4134                                 if ( hostLang->lang == HostLang::Ruby )
4135                                         {stack[top++] = 146; goto st52;}
4136                                 else
4137                                         {stack[top++] = 146; goto st95;}
4138                         }
4139                 }}
4140         goto st146;
4141 tr314:
4142 #line 1081 "rlscan.rl"
4143         {te = p;p--;{ updateCol(); }}
4144         goto st146;
4145 tr315:
4146 #line 1110 "rlscan.rl"
4147         {te = p;p--;{ token( *ts ); }}
4148         goto st146;
4149 tr316:
4150 #line 999 "rlscan.rl"
4151         {te = p;p--;{ token( TK_Literal, ts, te ); }}
4152         goto st146;
4153 tr317:
4154 #line 999 "rlscan.rl"
4155         {te = p+1;{ token( TK_Literal, ts, te ); }}
4156         goto st146;
4157 tr318:
4158 #line 1037 "rlscan.rl"
4159         {te = p+1;{ token( TK_AllGblError ); }}
4160         goto st146;
4161 tr319:
4162 #line 1021 "rlscan.rl"
4163         {te = p+1;{ token( TK_AllFromState ); }}
4164         goto st146;
4165 tr320:
4166 #line 1029 "rlscan.rl"
4167         {te = p+1;{ token( TK_AllEOF ); }}
4168         goto st146;
4169 tr321:
4170 #line 1056 "rlscan.rl"
4171         {te = p+1;{ token( TK_AllCond ); }}
4172         goto st146;
4173 tr322:
4174 #line 1045 "rlscan.rl"
4175         {te = p+1;{ token( TK_AllLocalError ); }}
4176         goto st146;
4177 tr323:
4178 #line 1013 "rlscan.rl"
4179         {te = p+1;{ token( TK_AllToState ); }}
4180         goto st146;
4181 tr324:
4182 #line 1038 "rlscan.rl"
4183         {te = p+1;{ token( TK_FinalGblError ); }}
4184         goto st146;
4185 tr325:
4186 #line 1022 "rlscan.rl"
4187         {te = p+1;{ token( TK_FinalFromState ); }}
4188         goto st146;
4189 tr326:
4190 #line 1030 "rlscan.rl"
4191         {te = p+1;{ token( TK_FinalEOF ); }}
4192         goto st146;
4193 tr327:
4194 #line 1057 "rlscan.rl"
4195         {te = p+1;{ token( TK_LeavingCond ); }}
4196         goto st146;
4197 tr328:
4198 #line 1046 "rlscan.rl"
4199         {te = p+1;{ token( TK_FinalLocalError ); }}
4200         goto st146;
4201 tr329:
4202 #line 1014 "rlscan.rl"
4203         {te = p+1;{ token( TK_FinalToState ); }}
4204         goto st146;
4205 tr330:
4206 #line 1060 "rlscan.rl"
4207         {te = p+1;{ token( TK_StarStar ); }}
4208         goto st146;
4209 tr331:
4210 #line 1061 "rlscan.rl"
4211         {te = p+1;{ token( TK_DashDash ); }}
4212         goto st146;
4213 tr332:
4214 #line 1062 "rlscan.rl"
4215         {te = p+1;{ token( TK_Arrow ); }}
4216         goto st146;
4217 tr333:
4218 #line 1059 "rlscan.rl"
4219         {te = p+1;{ token( TK_DotDot ); }}
4220         goto st146;
4221 tr334:
4222 #line 994 "rlscan.rl"
4223         {te = p;p--;{ token( TK_UInt, ts, te ); }}
4224         goto st146;
4225 tr336:
4226 #line 995 "rlscan.rl"
4227         {te = p;p--;{ token( TK_Hex, ts, te ); }}
4228         goto st146;
4229 tr337:
4230 #line 1073 "rlscan.rl"
4231         {te = p+1;{ token( TK_NameSep, ts, te ); }}
4232         goto st146;
4233 tr338:
4234 #line 1009 "rlscan.rl"
4235         {te = p+1;{ token( TK_ColonEquals ); }}
4236         goto st146;
4237 tr340:
4238 #line 1065 "rlscan.rl"
4239         {te = p;p--;{ token( TK_ColonGt ); }}
4240         goto st146;
4241 tr341:
4242 #line 1066 "rlscan.rl"
4243         {te = p+1;{ token( TK_ColonGtGt ); }}
4244         goto st146;
4245 tr342:
4246 #line 1039 "rlscan.rl"
4247         {te = p+1;{ token( TK_NotStartGblError ); }}
4248         goto st146;
4249 tr343:
4250 #line 1023 "rlscan.rl"
4251         {te = p+1;{ token( TK_NotStartFromState ); }}
4252         goto st146;
4253 tr344:
4254 #line 1031 "rlscan.rl"
4255         {te = p+1;{ token( TK_NotStartEOF ); }}
4256         goto st146;
4257 tr345:
4258 #line 1067 "rlscan.rl"
4259         {te = p+1;{ token( TK_LtColon ); }}
4260         goto st146;
4261 tr347:
4262 #line 1047 "rlscan.rl"
4263         {te = p+1;{ token( TK_NotStartLocalError ); }}
4264         goto st146;
4265 tr348:
4266 #line 1015 "rlscan.rl"
4267         {te = p+1;{ token( TK_NotStartToState ); }}
4268         goto st146;
4269 tr349:
4270 #line 1052 "rlscan.rl"
4271         {te = p;p--;{ token( TK_Middle ); }}
4272         goto st146;
4273 tr350:
4274 #line 1041 "rlscan.rl"
4275         {te = p+1;{ token( TK_MiddleGblError ); }}
4276         goto st146;
4277 tr351:
4278 #line 1025 "rlscan.rl"
4279         {te = p+1;{ token( TK_MiddleFromState ); }}
4280         goto st146;
4281 tr352:
4282 #line 1033 "rlscan.rl"
4283         {te = p+1;{ token( TK_MiddleEOF ); }}
4284         goto st146;
4285 tr353:
4286 #line 1049 "rlscan.rl"
4287         {te = p+1;{ token( TK_MiddleLocalError ); }}
4288         goto st146;
4289 tr354:
4290 #line 1017 "rlscan.rl"
4291         {te = p+1;{ token( TK_MiddleToState ); }}
4292         goto st146;
4293 tr355:
4294 #line 1063 "rlscan.rl"
4295         {te = p+1;{ token( TK_DoubleArrow ); }}
4296         goto st146;
4297 tr356:
4298 #line 1036 "rlscan.rl"
4299         {te = p+1;{ token( TK_StartGblError ); }}
4300         goto st146;
4301 tr357:
4302 #line 1020 "rlscan.rl"
4303         {te = p+1;{ token( TK_StartFromState ); }}
4304         goto st146;
4305 tr358:
4306 #line 1028 "rlscan.rl"
4307         {te = p+1;{ token( TK_StartEOF ); }}
4308         goto st146;
4309 tr359:
4310 #line 1055 "rlscan.rl"
4311         {te = p+1;{ token( TK_StartCond ); }}
4312         goto st146;
4313 tr360:
4314 #line 1044 "rlscan.rl"
4315         {te = p+1;{ token( TK_StartLocalError ); }}
4316         goto st146;
4317 tr361:
4318 #line 1012 "rlscan.rl"
4319         {te = p+1;{ token( TK_StartToState ); }}
4320         goto st146;
4321 tr362:
4322 #line 1040 "rlscan.rl"
4323         {te = p+1;{ token( TK_NotFinalGblError ); }}
4324         goto st146;
4325 tr363:
4326 #line 1024 "rlscan.rl"
4327         {te = p+1;{ token( TK_NotFinalFromState ); }}
4328         goto st146;
4329 tr364:
4330 #line 1032 "rlscan.rl"
4331         {te = p+1;{ token( TK_NotFinalEOF ); }}
4332         goto st146;
4333 tr365:
4334 #line 1048 "rlscan.rl"
4335         {te = p+1;{ token( TK_NotFinalLocalError ); }}
4336         goto st146;
4337 tr366:
4338 #line 1016 "rlscan.rl"
4339         {te = p+1;{ token( TK_NotFinalToState ); }}
4340         goto st146;
4341 tr367:
4342 #line 1 "rlscan.rl"
4343         {       switch( act ) {
4344         case 88:
4345         {{p = ((te))-1;} token( KW_Machine ); }
4346         break;
4347         case 89:
4348         {{p = ((te))-1;} token( KW_Include ); }
4349         break;
4350         case 90:
4351         {{p = ((te))-1;} token( KW_Import ); }
4352         break;
4353         case 91:
4354         {{p = ((te))-1;}
4355                         token( KW_Write );
4356                         {goto st143;}
4357                 }
4358         break;
4359         case 92:
4360         {{p = ((te))-1;} token( KW_Action ); }
4361         break;
4362         case 93:
4363         {{p = ((te))-1;} token( KW_AlphType ); }
4364         break;
4365         case 94:
4366         {{p = ((te))-1;} token( KW_PrePush ); }
4367         break;
4368         case 95:
4369         {{p = ((te))-1;} token( KW_PostPop ); }
4370         break;
4371         case 96:
4372         {{p = ((te))-1;}
4373                         token( KW_GetKey );
4374                         inlineBlockType = SemiTerminated;
4375                         if ( hostLang->lang == HostLang::Ruby )
4376                                 {stack[top++] = 146; goto st52;}
4377                         else
4378                                 {stack[top++] = 146; goto st95;}
4379                 }
4380         break;
4381         case 97:
4382         {{p = ((te))-1;}
4383                         token( KW_Access );
4384                         inlineBlockType = SemiTerminated;
4385                         if ( hostLang->lang == HostLang::Ruby )
4386                                 {stack[top++] = 146; goto st52;}
4387                         else
4388                                 {stack[top++] = 146; goto st95;}
4389                 }
4390         break;
4391         case 98:
4392         {{p = ((te))-1;}
4393                         token( KW_Variable );
4394                         inlineBlockType = SemiTerminated;
4395                         if ( hostLang->lang == HostLang::Ruby )
4396                                 {stack[top++] = 146; goto st52;}
4397                         else
4398                                 {stack[top++] = 146; goto st95;}
4399                 }
4400         break;
4401         case 99:
4402         {{p = ((te))-1;} token( KW_When ); }
4403         break;
4404         case 100:
4405         {{p = ((te))-1;} token( KW_InWhen ); }
4406         break;
4407         case 101:
4408         {{p = ((te))-1;} token( KW_OutWhen ); }
4409         break;
4410         case 102:
4411         {{p = ((te))-1;} token( KW_Eof ); }
4412         break;
4413         case 103:
4414         {{p = ((te))-1;} token( KW_Err ); }
4415         break;
4416         case 104:
4417         {{p = ((te))-1;} token( KW_Lerr ); }
4418         break;
4419         case 105:
4420         {{p = ((te))-1;} token( KW_To ); }
4421         break;
4422         case 106:
4423         {{p = ((te))-1;} token( KW_From ); }
4424         break;
4425         case 107:
4426         {{p = ((te))-1;} token( KW_Export ); }
4427         break;
4428         case 108:
4429         {{p = ((te))-1;} token( TK_Word, ts, te ); }
4430         break;
4431         }
4432         }
4433         goto st146;
4434 tr368:
4435 #line 1001 "rlscan.rl"
4436         {te = p;p--;{ token( RE_SqOpen ); {stack[top++] = 146; goto st137;} }}
4437         goto st146;
4438 tr369:
4439 #line 1002 "rlscan.rl"
4440         {te = p+1;{ token( RE_SqOpenNeg ); {stack[top++] = 146; goto st137;} }}
4441         goto st146;
4442 tr370:
4443 #line 991 "rlscan.rl"
4444         {te = p;p--;{ token( TK_Word, ts, te ); }}
4445         goto st146;
4446 tr461:
4447 #line 1070 "rlscan.rl"
4448         {te = p+1;{ token( TK_BarStar ); }}
4449         goto st146;
4450 st146:
4451 #line 1 "rlscan.rl"
4452         {ts = 0;}
4453         if ( ++p == pe )
4454                 goto _test_eof146;
4455 case 146:
4456 #line 1 "rlscan.rl"
4457         {ts = p;}
4458 #line 4459 "rlscan.cpp"
4459         switch( (*p) ) {
4460                 case 0: goto tr278;
4461                 case 9: goto st147;
4462                 case 10: goto tr280;
4463                 case 13: goto st147;
4464                 case 32: goto st147;
4465                 case 34: goto tr281;
4466                 case 35: goto tr282;
4467                 case 36: goto st151;
4468                 case 37: goto st152;
4469                 case 39: goto tr285;
4470                 case 42: goto st154;
4471                 case 45: goto st155;
4472                 case 46: goto st156;
4473                 case 47: goto tr289;
4474                 case 48: goto tr290;
4475                 case 58: goto st160;
4476                 case 60: goto st162;
4477                 case 61: goto st164;
4478                 case 62: goto st165;
4479                 case 64: goto st166;
4480                 case 91: goto st168;
4481                 case 95: goto tr297;
4482                 case 97: goto st169;
4483                 case 101: goto st183;
4484                 case 102: goto st190;
4485                 case 103: goto st193;
4486                 case 105: goto st198;
4487                 case 108: goto st211;
4488                 case 109: goto st214;
4489                 case 111: goto st220;
4490                 case 112: goto st226;
4491                 case 116: goto st237;
4492                 case 118: goto st238;
4493                 case 119: goto st245;
4494                 case 123: goto tr311;
4495                 case 124: goto st251;
4496                 case 125: goto tr313;
4497         }
4498         if ( (*p) < 65 ) {
4499                 if ( 49 <= (*p) && (*p) <= 57 )
4500                         goto st158;
4501         } else if ( (*p) > 90 ) {
4502                 if ( 98 <= (*p) && (*p) <= 122 )
4503                         goto tr297;
4504         } else
4505                 goto tr297;
4506         goto tr277;
4507 st147:
4508         if ( ++p == pe )
4509                 goto _test_eof147;
4510 case 147:
4511         switch( (*p) ) {
4512                 case 9: goto st147;
4513                 case 13: goto st147;
4514                 case 32: goto st147;
4515         }
4516         goto tr314;
4517 tr281:
4518 #line 1 "rlscan.rl"
4519         {te = p+1;}
4520         goto st148;
4521 st148:
4522         if ( ++p == pe )
4523                 goto _test_eof148;
4524 case 148:
4525 #line 4526 "rlscan.cpp"
4526         switch( (*p) ) {
4527                 case 10: goto tr47;
4528                 case 34: goto st149;
4529                 case 92: goto st25;
4530         }
4531         goto st24;
4532 tr47:
4533 #line 630 "rlscan.rl"
4534         {
4535                 lastnl = p;
4536                 column = 0;
4537                 line++;
4538         }
4539         goto st24;
4540 st24:
4541         if ( ++p == pe )
4542                 goto _test_eof24;
4543 case 24:
4544 #line 4545 "rlscan.cpp"
4545         switch( (*p) ) {
4546                 case 10: goto tr47;
4547                 case 34: goto st149;
4548                 case 92: goto st25;
4549         }
4550         goto st24;
4551 st149:
4552         if ( ++p == pe )
4553                 goto _test_eof149;
4554 case 149:
4555         if ( (*p) == 105 )
4556                 goto tr317;
4557         goto tr316;
4558 st25:
4559         if ( ++p == pe )
4560                 goto _test_eof25;
4561 case 25:
4562         if ( (*p) == 10 )
4563                 goto tr47;
4564         goto st24;
4565 tr282:
4566 #line 1 "rlscan.rl"
4567         {te = p+1;}
4568         goto st150;
4569 st150:
4570         if ( ++p == pe )
4571                 goto _test_eof150;
4572 case 150:
4573 #line 4574 "rlscan.cpp"
4574         if ( (*p) == 10 )
4575                 goto tr51;
4576         goto st26;
4577 st26:
4578         if ( ++p == pe )
4579                 goto _test_eof26;
4580 case 26:
4581         if ( (*p) == 10 )
4582                 goto tr51;
4583         goto st26;
4584 st151:
4585         if ( ++p == pe )
4586                 goto _test_eof151;
4587 case 151:
4588         switch( (*p) ) {
4589                 case 33: goto tr318;
4590                 case 42: goto tr319;
4591                 case 47: goto tr320;
4592                 case 63: goto tr321;
4593                 case 94: goto tr322;
4594                 case 126: goto tr323;
4595         }
4596         goto tr315;
4597 st152:
4598         if ( ++p == pe )
4599                 goto _test_eof152;
4600 case 152:
4601         switch( (*p) ) {
4602                 case 33: goto tr324;
4603                 case 42: goto tr325;
4604                 case 47: goto tr326;
4605                 case 63: goto tr327;
4606                 case 94: goto tr328;
4607                 case 126: goto tr329;
4608         }
4609         goto tr315;
4610 tr285:
4611 #line 1 "rlscan.rl"
4612         {te = p+1;}
4613         goto st153;
4614 st153:
4615         if ( ++p == pe )
4616                 goto _test_eof153;
4617 case 153:
4618 #line 4619 "rlscan.cpp"
4619         switch( (*p) ) {
4620                 case 10: goto tr53;
4621                 case 39: goto st149;
4622                 case 92: goto st28;
4623         }
4624         goto st27;
4625 tr53:
4626 #line 630 "rlscan.rl"
4627         {
4628                 lastnl = p;
4629                 column = 0;
4630                 line++;
4631         }
4632         goto st27;
4633 st27:
4634         if ( ++p == pe )
4635                 goto _test_eof27;
4636 case 27:
4637 #line 4638 "rlscan.cpp"
4638         switch( (*p) ) {
4639                 case 10: goto tr53;
4640                 case 39: goto st149;
4641                 case 92: goto st28;
4642         }
4643         goto st27;
4644 st28:
4645         if ( ++p == pe )
4646                 goto _test_eof28;
4647 case 28:
4648         if ( (*p) == 10 )
4649                 goto tr53;
4650         goto st27;
4651 st154:
4652         if ( ++p == pe )
4653                 goto _test_eof154;
4654 case 154:
4655         if ( (*p) == 42 )
4656                 goto tr330;
4657         goto tr315;
4658 st155:
4659         if ( ++p == pe )
4660                 goto _test_eof155;
4661 case 155:
4662         switch( (*p) ) {
4663                 case 45: goto tr331;
4664                 case 62: goto tr332;
4665         }
4666         goto tr315;
4667 st156:
4668         if ( ++p == pe )
4669                 goto _test_eof156;
4670 case 156:
4671         if ( (*p) == 46 )
4672                 goto tr333;
4673         goto tr315;
4674 tr290:
4675 #line 1 "rlscan.rl"
4676         {te = p+1;}
4677         goto st157;
4678 st157:
4679         if ( ++p == pe )
4680                 goto _test_eof157;
4681 case 157:
4682 #line 4683 "rlscan.cpp"
4683         if ( (*p) == 120 )
4684                 goto st29;
4685         if ( 48 <= (*p) && (*p) <= 57 )
4686                 goto st158;
4687         goto tr334;
4688 st158:
4689         if ( ++p == pe )
4690                 goto _test_eof158;
4691 case 158:
4692         if ( 48 <= (*p) && (*p) <= 57 )
4693                 goto st158;
4694         goto tr334;
4695 st29:
4696         if ( ++p == pe )
4697                 goto _test_eof29;
4698 case 29:
4699         if ( (*p) < 65 ) {
4700                 if ( 48 <= (*p) && (*p) <= 57 )
4701                         goto st159;
4702         } else if ( (*p) > 70 ) {
4703                 if ( 97 <= (*p) && (*p) <= 102 )
4704                         goto st159;
4705         } else
4706                 goto st159;
4707         goto tr55;
4708 st159:
4709         if ( ++p == pe )
4710                 goto _test_eof159;
4711 case 159:
4712         if ( (*p) < 65 ) {
4713                 if ( 48 <= (*p) && (*p) <= 57 )
4714                         goto st159;
4715         } else if ( (*p) > 70 ) {
4716                 if ( 97 <= (*p) && (*p) <= 102 )
4717                         goto st159;
4718         } else
4719                 goto st159;
4720         goto tr336;
4721 st160:
4722         if ( ++p == pe )
4723                 goto _test_eof160;
4724 case 160:
4725         switch( (*p) ) {
4726                 case 58: goto tr337;
4727                 case 61: goto tr338;
4728                 case 62: goto st161;
4729         }
4730         goto tr315;
4731 st161:
4732         if ( ++p == pe )
4733                 goto _test_eof161;
4734 case 161:
4735         if ( (*p) == 62 )
4736                 goto tr341;
4737         goto tr340;
4738 st162:
4739         if ( ++p == pe )
4740                 goto _test_eof162;
4741 case 162:
4742         switch( (*p) ) {
4743                 case 33: goto tr342;
4744                 case 42: goto tr343;
4745                 case 47: goto tr344;
4746                 case 58: goto tr345;
4747                 case 62: goto st163;
4748                 case 94: goto tr347;
4749                 case 126: goto tr348;
4750         }
4751         goto tr315;
4752 st163:
4753         if ( ++p == pe )
4754                 goto _test_eof163;
4755 case 163:
4756         switch( (*p) ) {
4757                 case 33: goto tr350;
4758                 case 42: goto tr351;
4759                 case 47: goto tr352;
4760                 case 94: goto tr353;
4761                 case 126: goto tr354;
4762         }
4763         goto tr349;
4764 st164:
4765         if ( ++p == pe )
4766                 goto _test_eof164;
4767 case 164:
4768         if ( (*p) == 62 )
4769                 goto tr355;
4770         goto tr315;
4771 st165:
4772         if ( ++p == pe )
4773                 goto _test_eof165;
4774 case 165:
4775         switch( (*p) ) {
4776                 case 33: goto tr356;
4777                 case 42: goto tr357;
4778                 case 47: goto tr358;
4779                 case 63: goto tr359;
4780                 case 94: goto tr360;
4781                 case 126: goto tr361;
4782         }
4783         goto tr315;
4784 st166:
4785         if ( ++p == pe )
4786                 goto _test_eof166;
4787 case 166:
4788         switch( (*p) ) {
4789                 case 33: goto tr362;
4790                 case 42: goto tr363;
4791                 case 47: goto tr364;
4792                 case 94: goto tr365;
4793                 case 126: goto tr366;
4794         }
4795         goto tr315;
4796 tr297:
4797 #line 1 "rlscan.rl"
4798         {te = p+1;}
4799 #line 991 "rlscan.rl"
4800         {act = 108;}
4801         goto st167;
4802 tr377:
4803 #line 1 "rlscan.rl"
4804         {te = p+1;}
4805 #line 964 "rlscan.rl"
4806         {act = 97;}
4807         goto st167;
4808 tr380:
4809 #line 1 "rlscan.rl"
4810         {te = p+1;}
4811 #line 948 "rlscan.rl"
4812         {act = 92;}
4813         goto st167;
4814 tr386:
4815 #line 1 "rlscan.rl"
4816         {te = p+1;}
4817 #line 949 "rlscan.rl"
4818         {act = 93;}
4819         goto st167;
4820 tr390:
4821 #line 1 "rlscan.rl"
4822         {te = p+1;}
4823 #line 983 "rlscan.rl"
4824         {act = 102;}
4825         goto st167;
4826 tr391:
4827 #line 1 "rlscan.rl"
4828         {te = p+1;}
4829 #line 984 "rlscan.rl"
4830         {act = 103;}
4831         goto st167;
4832 tr395:
4833 #line 1 "rlscan.rl"
4834         {te = p+1;}
4835 #line 988 "rlscan.rl"
4836         {act = 107;}
4837         goto st167;
4838 tr398:
4839 #line 1 "rlscan.rl"
4840         {te = p+1;}
4841 #line 987 "rlscan.rl"
4842         {act = 106;}
4843         goto st167;
4844 tr403:
4845 #line 1 "rlscan.rl"
4846         {te = p+1;}
4847 #line 956 "rlscan.rl"
4848         {act = 96;}
4849         goto st167;
4850 tr409:
4851 #line 1 "rlscan.rl"
4852         {te = p+1;}
4853 #line 943 "rlscan.rl"
4854         {act = 90;}
4855         goto st167;
4856 tr415:
4857 #line 1 "rlscan.rl"
4858         {te = p+1;}
4859 #line 942 "rlscan.rl"
4860         {act = 89;}
4861         goto st167;
4862 tr418:
4863 #line 1 "rlscan.rl"
4864         {te = p+1;}
4865 #line 981 "rlscan.rl"
4866         {act = 100;}
4867         goto st167;
4868 tr421:
4869 #line 1 "rlscan.rl"
4870         {te = p+1;}
4871 #line 985 "rlscan.rl"
4872         {act = 104;}
4873         goto st167;
4874 tr427:
4875 #line 1 "rlscan.rl"
4876         {te = p+1;}
4877 #line 941 "rlscan.rl"
4878         {act = 88;}
4879         goto st167;
4880 tr433:
4881 #line 1 "rlscan.rl"
4882         {te = p+1;}
4883 #line 982 "rlscan.rl"
4884         {act = 101;}
4885         goto st167;
4886 tr440:
4887 #line 1 "rlscan.rl"
4888         {te = p+1;}
4889 #line 951 "rlscan.rl"
4890         {act = 95;}
4891         goto st167;
4892 tr445:
4893 #line 1 "rlscan.rl"
4894         {te = p+1;}
4895 #line 950 "rlscan.rl"
4896         {act = 94;}
4897         goto st167;
4898 tr446:
4899 #line 1 "rlscan.rl"
4900         {te = p+1;}
4901 #line 986 "rlscan.rl"
4902         {act = 105;}
4903         goto st167;
4904 tr453:
4905 #line 1 "rlscan.rl"
4906         {te = p+1;}
4907 #line 972 "rlscan.rl"
4908         {act = 98;}
4909         goto st167;
4910 tr457:
4911 #line 1 "rlscan.rl"
4912         {te = p+1;}
4913 #line 980 "rlscan.rl"
4914         {act = 99;}
4915         goto st167;
4916 tr460:
4917 #line 1 "rlscan.rl"
4918         {te = p+1;}
4919 #line 944 "rlscan.rl"
4920         {act = 91;}
4921         goto st167;
4922 st167:
4923         if ( ++p == pe )
4924                 goto _test_eof167;
4925 case 167:
4926 #line 4927 "rlscan.cpp"
4927         if ( (*p) == 95 )
4928                 goto tr297;
4929         if ( (*p) < 65 ) {
4930                 if ( 48 <= (*p) && (*p) <= 57 )
4931                         goto tr297;
4932         } else if ( (*p) > 90 ) {
4933                 if ( 97 <= (*p) && (*p) <= 122 )
4934                         goto tr297;
4935         } else
4936                 goto tr297;
4937         goto tr367;
4938 st168:
4939         if ( ++p == pe )
4940                 goto _test_eof168;
4941 case 168:
4942         if ( (*p) == 94 )
4943                 goto tr369;
4944         goto tr368;
4945 st169:
4946         if ( ++p == pe )
4947                 goto _test_eof169;
4948 case 169:
4949         switch( (*p) ) {
4950                 case 95: goto tr297;
4951                 case 99: goto st170;
4952                 case 108: goto st177;
4953         }
4954         if ( (*p) < 65 ) {
4955                 if ( 48 <= (*p) && (*p) <= 57 )
4956                         goto tr297;
4957         } else if ( (*p) > 90 ) {
4958                 if ( 97 <= (*p) && (*p) <= 122 )
4959                         goto tr297;
4960         } else
4961                 goto tr297;
4962         goto tr370;
4963 st170:
4964         if ( ++p == pe )
4965                 goto _test_eof170;
4966 case 170:
4967         switch( (*p) ) {
4968                 case 95: goto tr297;
4969                 case 99: goto st171;
4970                 case 116: goto st174;
4971         }
4972         if ( (*p) < 65 ) {
4973                 if ( 48 <= (*p) && (*p) <= 57 )
4974                         goto tr297;
4975         } else if ( (*p) > 90 ) {
4976                 if ( 97 <= (*p) && (*p) <= 122 )
4977                         goto tr297;
4978         } else
4979                 goto tr297;
4980         goto tr370;
4981 st171:
4982         if ( ++p == pe )
4983                 goto _test_eof171;
4984 case 171:
4985         switch( (*p) ) {
4986                 case 95: goto tr297;
4987                 case 101: goto st172;
4988         }
4989         if ( (*p) < 65 ) {
4990                 if ( 48 <= (*p) && (*p) <= 57 )
4991                         goto tr297;
4992         } else if ( (*p) > 90 ) {
4993                 if ( 97 <= (*p) && (*p) <= 122 )
4994                         goto tr297;
4995         } else
4996                 goto tr297;
4997         goto tr370;
4998 st172:
4999         if ( ++p == pe )
5000                 goto _test_eof172;
5001 case 172:
5002         switch( (*p) ) {
5003                 case 95: goto tr297;
5004                 case 115: goto st173;
5005         }
5006         if ( (*p) < 65 ) {
5007                 if ( 48 <= (*p) && (*p) <= 57 )
5008                         goto tr297;
5009         } else if ( (*p) > 90 ) {
5010                 if ( 97 <= (*p) && (*p) <= 122 )
5011                         goto tr297;
5012         } else
5013                 goto tr297;
5014         goto tr370;
5015 st173:
5016         if ( ++p == pe )
5017                 goto _test_eof173;
5018 case 173:
5019         switch( (*p) ) {
5020                 case 95: goto tr297;
5021                 case 115: goto tr377;
5022         }
5023         if ( (*p) < 65 ) {
5024                 if ( 48 <= (*p) && (*p) <= 57 )
5025                         goto tr297;
5026         } else if ( (*p) > 90 ) {
5027                 if ( 97 <= (*p) && (*p) <= 122 )
5028                         goto tr297;
5029         } else
5030                 goto tr297;
5031         goto tr370;
5032 st174:
5033         if ( ++p == pe )
5034                 goto _test_eof174;
5035 case 174:
5036         switch( (*p) ) {
5037                 case 95: goto tr297;
5038                 case 105: goto st175;
5039         }
5040         if ( (*p) < 65 ) {
5041                 if ( 48 <= (*p) && (*p) <= 57 )
5042                         goto tr297;
5043         } else if ( (*p) > 90 ) {
5044                 if ( 97 <= (*p) && (*p) <= 122 )
5045                         goto tr297;
5046         } else
5047                 goto tr297;
5048         goto tr370;
5049 st175:
5050         if ( ++p == pe )
5051                 goto _test_eof175;
5052 case 175:
5053         switch( (*p) ) {
5054                 case 95: goto tr297;
5055                 case 111: goto st176;
5056         }
5057         if ( (*p) < 65 ) {
5058                 if ( 48 <= (*p) && (*p) <= 57 )
5059                         goto tr297;
5060         } else if ( (*p) > 90 ) {
5061                 if ( 97 <= (*p) && (*p) <= 122 )
5062                         goto tr297;
5063         } else
5064                 goto tr297;
5065         goto tr370;
5066 st176:
5067         if ( ++p == pe )
5068                 goto _test_eof176;
5069 case 176:
5070         switch( (*p) ) {
5071                 case 95: goto tr297;
5072                 case 110: goto tr380;
5073         }
5074         if ( (*p) < 65 ) {
5075                 if ( 48 <= (*p) && (*p) <= 57 )
5076                         goto tr297;
5077         } else if ( (*p) > 90 ) {
5078                 if ( 97 <= (*p) && (*p) <= 122 )
5079                         goto tr297;
5080         } else
5081                 goto tr297;
5082         goto tr370;
5083 st177:
5084         if ( ++p == pe )
5085                 goto _test_eof177;
5086 case 177:
5087         switch( (*p) ) {
5088                 case 95: goto tr297;
5089                 case 112: goto st178;
5090         }
5091         if ( (*p) < 65 ) {
5092                 if ( 48 <= (*p) && (*p) <= 57 )
5093                         goto tr297;
5094         } else if ( (*p) > 90 ) {
5095                 if ( 97 <= (*p) && (*p) <= 122 )
5096                         goto tr297;
5097         } else
5098                 goto tr297;
5099         goto tr370;
5100 st178:
5101         if ( ++p == pe )
5102                 goto _test_eof178;
5103 case 178:
5104         switch( (*p) ) {
5105                 case 95: goto tr297;
5106                 case 104: goto st179;
5107         }
5108         if ( (*p) < 65 ) {
5109                 if ( 48 <= (*p) && (*p) <= 57 )
5110                         goto tr297;
5111         } else if ( (*p) > 90 ) {
5112                 if ( 97 <= (*p) && (*p) <= 122 )
5113                         goto tr297;
5114         } else
5115                 goto tr297;
5116         goto tr370;
5117 st179:
5118         if ( ++p == pe )
5119                 goto _test_eof179;
5120 case 179:
5121         switch( (*p) ) {
5122                 case 95: goto tr297;
5123                 case 116: goto st180;
5124         }
5125         if ( (*p) < 65 ) {
5126                 if ( 48 <= (*p) && (*p) <= 57 )
5127                         goto tr297;
5128         } else if ( (*p) > 90 ) {
5129                 if ( 97 <= (*p) && (*p) <= 122 )
5130                         goto tr297;
5131         } else
5132                 goto tr297;
5133         goto tr370;
5134 st180:
5135         if ( ++p == pe )
5136                 goto _test_eof180;
5137 case 180:
5138         switch( (*p) ) {
5139                 case 95: goto tr297;
5140                 case 121: goto st181;
5141         }
5142         if ( (*p) < 65 ) {
5143                 if ( 48 <= (*p) && (*p) <= 57 )
5144                         goto tr297;
5145         } else if ( (*p) > 90 ) {
5146                 if ( 97 <= (*p) && (*p) <= 122 )
5147                         goto tr297;
5148         } else
5149                 goto tr297;
5150         goto tr370;
5151 st181:
5152         if ( ++p == pe )
5153                 goto _test_eof181;
5154 case 181:
5155         switch( (*p) ) {
5156                 case 95: goto tr297;
5157                 case 112: goto st182;
5158         }
5159         if ( (*p) < 65 ) {
5160                 if ( 48 <= (*p) && (*p) <= 57 )
5161                         goto tr297;
5162         } else if ( (*p) > 90 ) {
5163                 if ( 97 <= (*p) && (*p) <= 122 )
5164                         goto tr297;
5165         } else
5166                 goto tr297;
5167         goto tr370;
5168 st182:
5169         if ( ++p == pe )
5170                 goto _test_eof182;
5171 case 182:
5172         switch( (*p) ) {
5173                 case 95: goto tr297;
5174                 case 101: goto tr386;
5175         }
5176         if ( (*p) < 65 ) {
5177                 if ( 48 <= (*p) && (*p) <= 57 )
5178                         goto tr297;
5179         } else if ( (*p) > 90 ) {
5180                 if ( 97 <= (*p) && (*p) <= 122 )
5181                         goto tr297;
5182         } else
5183                 goto tr297;
5184         goto tr370;
5185 st183:
5186         if ( ++p == pe )
5187                 goto _test_eof183;
5188 case 183:
5189         switch( (*p) ) {
5190                 case 95: goto tr297;
5191                 case 111: goto st184;
5192                 case 114: goto st185;
5193                 case 120: goto st186;
5194         }
5195         if ( (*p) < 65 ) {
5196                 if ( 48 <= (*p) && (*p) <= 57 )
5197                         goto tr297;
5198         } else if ( (*p) > 90 ) {
5199                 if ( 97 <= (*p) && (*p) <= 122 )
5200                         goto tr297;
5201         } else
5202                 goto tr297;
5203         goto tr370;
5204 st184:
5205         if ( ++p == pe )
5206                 goto _test_eof184;
5207 case 184:
5208         switch( (*p) ) {
5209                 case 95: goto tr297;
5210                 case 102: goto tr390;
5211         }
5212         if ( (*p) < 65 ) {
5213                 if ( 48 <= (*p) && (*p) <= 57 )
5214                         goto tr297;
5215         } else if ( (*p) > 90 ) {
5216                 if ( 97 <= (*p) && (*p) <= 122 )
5217                         goto tr297;
5218         } else
5219                 goto tr297;
5220         goto tr370;
5221 st185:
5222         if ( ++p == pe )
5223                 goto _test_eof185;
5224 case 185:
5225         switch( (*p) ) {
5226                 case 95: goto tr297;
5227                 case 114: goto tr391;
5228         }
5229         if ( (*p) < 65 ) {
5230                 if ( 48 <= (*p) && (*p) <= 57 )
5231                         goto tr297;
5232         } else if ( (*p) > 90 ) {
5233                 if ( 97 <= (*p) && (*p) <= 122 )
5234                         goto tr297;
5235         } else
5236                 goto tr297;
5237         goto tr370;
5238 st186:
5239         if ( ++p == pe )
5240                 goto _test_eof186;
5241 case 186:
5242         switch( (*p) ) {
5243                 case 95: goto tr297;
5244                 case 112: goto st187;
5245         }
5246         if ( (*p) < 65 ) {
5247                 if ( 48 <= (*p) && (*p) <= 57 )
5248                         goto tr297;
5249         } else if ( (*p) > 90 ) {
5250                 if ( 97 <= (*p) && (*p) <= 122 )
5251                         goto tr297;
5252         } else
5253                 goto tr297;
5254         goto tr370;
5255 st187:
5256         if ( ++p == pe )
5257                 goto _test_eof187;
5258 case 187:
5259         switch( (*p) ) {
5260                 case 95: goto tr297;
5261                 case 111: goto st188;
5262         }
5263         if ( (*p) < 65 ) {
5264                 if ( 48 <= (*p) && (*p) <= 57 )
5265                         goto tr297;
5266         } else if ( (*p) > 90 ) {
5267                 if ( 97 <= (*p) && (*p) <= 122 )
5268                         goto tr297;
5269         } else
5270                 goto tr297;
5271         goto tr370;
5272 st188:
5273         if ( ++p == pe )
5274                 goto _test_eof188;
5275 case 188:
5276         switch( (*p) ) {
5277                 case 95: goto tr297;
5278                 case 114: goto st189;
5279         }
5280         if ( (*p) < 65 ) {
5281                 if ( 48 <= (*p) && (*p) <= 57 )
5282                         goto tr297;
5283         } else if ( (*p) > 90 ) {
5284                 if ( 97 <= (*p) && (*p) <= 122 )
5285                         goto tr297;
5286         } else
5287                 goto tr297;
5288         goto tr370;
5289 st189:
5290         if ( ++p == pe )
5291                 goto _test_eof189;
5292 case 189:
5293         switch( (*p) ) {
5294                 case 95: goto tr297;
5295                 case 116: goto tr395;
5296         }
5297         if ( (*p) < 65 ) {
5298                 if ( 48 <= (*p) && (*p) <= 57 )
5299                         goto tr297;
5300         } else if ( (*p) > 90 ) {
5301                 if ( 97 <= (*p) && (*p) <= 122 )
5302                         goto tr297;
5303         } else
5304                 goto tr297;
5305         goto tr370;
5306 st190:
5307         if ( ++p == pe )
5308                 goto _test_eof190;
5309 case 190:
5310         switch( (*p) ) {
5311                 case 95: goto tr297;
5312                 case 114: goto st191;
5313         }
5314         if ( (*p) < 65 ) {
5315                 if ( 48 <= (*p) && (*p) <= 57 )
5316                         goto tr297;
5317         } else if ( (*p) > 90 ) {
5318                 if ( 97 <= (*p) && (*p) <= 122 )
5319                         goto tr297;
5320         } else
5321                 goto tr297;
5322         goto tr370;
5323 st191:
5324         if ( ++p == pe )
5325                 goto _test_eof191;
5326 case 191:
5327         switch( (*p) ) {
5328                 case 95: goto tr297;
5329                 case 111: goto st192;
5330         }
5331         if ( (*p) < 65 ) {
5332                 if ( 48 <= (*p) && (*p) <= 57 )
5333                         goto tr297;
5334         } else if ( (*p) > 90 ) {
5335                 if ( 97 <= (*p) && (*p) <= 122 )
5336                         goto tr297;
5337         } else
5338                 goto tr297;
5339         goto tr370;
5340 st192:
5341         if ( ++p == pe )
5342                 goto _test_eof192;
5343 case 192:
5344         switch( (*p) ) {
5345                 case 95: goto tr297;
5346                 case 109: goto tr398;
5347         }
5348         if ( (*p) < 65 ) {
5349                 if ( 48 <= (*p) && (*p) <= 57 )
5350                         goto tr297;
5351         } else if ( (*p) > 90 ) {
5352                 if ( 97 <= (*p) && (*p) <= 122 )
5353                         goto tr297;
5354         } else
5355                 goto tr297;
5356         goto tr370;
5357 st193:
5358         if ( ++p == pe )
5359                 goto _test_eof193;
5360 case 193:
5361         switch( (*p) ) {
5362                 case 95: goto tr297;
5363                 case 101: goto st194;
5364         }
5365         if ( (*p) < 65 ) {
5366                 if ( 48 <= (*p) && (*p) <= 57 )
5367                         goto tr297;
5368         } else if ( (*p) > 90 ) {
5369                 if ( 97 <= (*p) && (*p) <= 122 )
5370                         goto tr297;
5371         } else
5372                 goto tr297;
5373         goto tr370;
5374 st194:
5375         if ( ++p == pe )
5376                 goto _test_eof194;
5377 case 194:
5378         switch( (*p) ) {
5379                 case 95: goto tr297;
5380                 case 116: goto st195;
5381         }
5382         if ( (*p) < 65 ) {
5383                 if ( 48 <= (*p) && (*p) <= 57 )
5384                         goto tr297;
5385         } else if ( (*p) > 90 ) {
5386                 if ( 97 <= (*p) && (*p) <= 122 )
5387                         goto tr297;
5388         } else
5389                 goto tr297;
5390         goto tr370;
5391 st195:
5392         if ( ++p == pe )
5393                 goto _test_eof195;
5394 case 195:
5395         switch( (*p) ) {
5396                 case 95: goto tr297;
5397                 case 107: goto st196;
5398         }
5399         if ( (*p) < 65 ) {
5400                 if ( 48 <= (*p) && (*p) <= 57 )
5401                         goto tr297;
5402         } else if ( (*p) > 90 ) {
5403                 if ( 97 <= (*p) && (*p) <= 122 )
5404                         goto tr297;
5405         } else
5406                 goto tr297;
5407         goto tr370;
5408 st196:
5409         if ( ++p == pe )
5410                 goto _test_eof196;
5411 case 196:
5412         switch( (*p) ) {
5413                 case 95: goto tr297;
5414                 case 101: goto st197;
5415         }
5416         if ( (*p) < 65 ) {
5417                 if ( 48 <= (*p) && (*p) <= 57 )
5418                         goto tr297;
5419         } else if ( (*p) > 90 ) {
5420                 if ( 97 <= (*p) && (*p) <= 122 )
5421                         goto tr297;
5422         } else
5423                 goto tr297;
5424         goto tr370;
5425 st197:
5426         if ( ++p == pe )
5427                 goto _test_eof197;
5428 case 197:
5429         switch( (*p) ) {
5430                 case 95: goto tr297;
5431                 case 121: goto tr403;
5432         }
5433         if ( (*p) < 65 ) {
5434                 if ( 48 <= (*p) && (*p) <= 57 )
5435                         goto tr297;
5436         } else if ( (*p) > 90 ) {
5437                 if ( 97 <= (*p) && (*p) <= 122 )
5438                         goto tr297;
5439         } else
5440                 goto tr297;
5441         goto tr370;
5442 st198:
5443         if ( ++p == pe )
5444                 goto _test_eof198;
5445 case 198:
5446         switch( (*p) ) {
5447                 case 95: goto tr297;
5448                 case 109: goto st199;
5449                 case 110: goto st203;
5450         }
5451         if ( (*p) < 65 ) {
5452                 if ( 48 <= (*p) && (*p) <= 57 )
5453                         goto tr297;
5454         } else if ( (*p) > 90 ) {
5455                 if ( 97 <= (*p) && (*p) <= 122 )
5456                         goto tr297;
5457         } else
5458                 goto tr297;
5459         goto tr370;
5460 st199:
5461         if ( ++p == pe )
5462                 goto _test_eof199;
5463 case 199:
5464         switch( (*p) ) {
5465                 case 95: goto tr297;
5466                 case 112: goto st200;
5467         }
5468         if ( (*p) < 65 ) {
5469                 if ( 48 <= (*p) && (*p) <= 57 )
5470                         goto tr297;
5471         } else if ( (*p) > 90 ) {
5472                 if ( 97 <= (*p) && (*p) <= 122 )
5473                         goto tr297;
5474         } else
5475                 goto tr297;
5476         goto tr370;
5477 st200:
5478         if ( ++p == pe )
5479                 goto _test_eof200;
5480 case 200:
5481         switch( (*p) ) {
5482                 case 95: goto tr297;
5483                 case 111: goto st201;
5484         }
5485         if ( (*p) < 65 ) {
5486                 if ( 48 <= (*p) && (*p) <= 57 )
5487                         goto tr297;
5488         } else if ( (*p) > 90 ) {
5489                 if ( 97 <= (*p) && (*p) <= 122 )
5490                         goto tr297;
5491         } else
5492                 goto tr297;
5493         goto tr370;
5494 st201:
5495         if ( ++p == pe )
5496                 goto _test_eof201;
5497 case 201:
5498         switch( (*p) ) {
5499                 case 95: goto tr297;
5500                 case 114: goto st202;
5501         }
5502         if ( (*p) < 65 ) {
5503                 if ( 48 <= (*p) && (*p) <= 57 )
5504                         goto tr297;
5505         } else if ( (*p) > 90 ) {
5506                 if ( 97 <= (*p) && (*p) <= 122 )
5507                         goto tr297;
5508         } else
5509                 goto tr297;
5510         goto tr370;
5511 st202:
5512         if ( ++p == pe )
5513                 goto _test_eof202;
5514 case 202:
5515         switch( (*p) ) {
5516                 case 95: goto tr297;
5517                 case 116: goto tr409;
5518         }
5519         if ( (*p) < 65 ) {
5520                 if ( 48 <= (*p) && (*p) <= 57 )
5521                         goto tr297;
5522         } else if ( (*p) > 90 ) {
5523                 if ( 97 <= (*p) && (*p) <= 122 )
5524                         goto tr297;
5525         } else
5526                 goto tr297;
5527         goto tr370;
5528 st203:
5529         if ( ++p == pe )
5530                 goto _test_eof203;
5531 case 203:
5532         switch( (*p) ) {
5533                 case 95: goto tr297;
5534                 case 99: goto st204;
5535                 case 119: goto st208;
5536         }
5537         if ( (*p) < 65 ) {
5538                 if ( 48 <= (*p) && (*p) <= 57 )
5539                         goto tr297;
5540         } else if ( (*p) > 90 ) {
5541                 if ( 97 <= (*p) && (*p) <= 122 )
5542                         goto tr297;
5543         } else
5544                 goto tr297;
5545         goto tr370;
5546 st204:
5547         if ( ++p == pe )
5548                 goto _test_eof204;
5549 case 204:
5550         switch( (*p) ) {
5551                 case 95: goto tr297;
5552                 case 108: goto st205;
5553         }
5554         if ( (*p) < 65 ) {
5555                 if ( 48 <= (*p) && (*p) <= 57 )
5556                         goto tr297;
5557         } else if ( (*p) > 90 ) {
5558                 if ( 97 <= (*p) && (*p) <= 122 )
5559                         goto tr297;
5560         } else
5561                 goto tr297;
5562         goto tr370;
5563 st205:
5564         if ( ++p == pe )
5565                 goto _test_eof205;
5566 case 205:
5567         switch( (*p) ) {
5568                 case 95: goto tr297;
5569                 case 117: goto st206;
5570         }
5571         if ( (*p) < 65 ) {
5572                 if ( 48 <= (*p) && (*p) <= 57 )
5573                         goto tr297;
5574         } else if ( (*p) > 90 ) {
5575                 if ( 97 <= (*p) && (*p) <= 122 )
5576                         goto tr297;
5577         } else
5578                 goto tr297;
5579         goto tr370;
5580 st206:
5581         if ( ++p == pe )
5582                 goto _test_eof206;
5583 case 206:
5584         switch( (*p) ) {
5585                 case 95: goto tr297;
5586                 case 100: goto st207;
5587         }
5588         if ( (*p) < 65 ) {
5589                 if ( 48 <= (*p) && (*p) <= 57 )
5590                         goto tr297;
5591         } else if ( (*p) > 90 ) {
5592                 if ( 97 <= (*p) && (*p) <= 122 )
5593                         goto tr297;
5594         } else
5595                 goto tr297;
5596         goto tr370;
5597 st207:
5598         if ( ++p == pe )
5599                 goto _test_eof207;
5600 case 207:
5601         switch( (*p) ) {
5602                 case 95: goto tr297;
5603                 case 101: goto tr415;
5604         }
5605         if ( (*p) < 65 ) {
5606                 if ( 48 <= (*p) && (*p) <= 57 )
5607                         goto tr297;
5608         } else if ( (*p) > 90 ) {
5609                 if ( 97 <= (*p) && (*p) <= 122 )
5610                         goto tr297;
5611         } else
5612                 goto tr297;
5613         goto tr370;
5614 st208:
5615         if ( ++p == pe )
5616                 goto _test_eof208;
5617 case 208:
5618         switch( (*p) ) {
5619                 case 95: goto tr297;
5620                 case 104: goto st209;
5621         }
5622         if ( (*p) < 65 ) {
5623                 if ( 48 <= (*p) && (*p) <= 57 )
5624                         goto tr297;
5625         } else if ( (*p) > 90 ) {
5626                 if ( 97 <= (*p) && (*p) <= 122 )
5627                         goto tr297;
5628         } else
5629                 goto tr297;
5630         goto tr370;
5631 st209:
5632         if ( ++p == pe )
5633                 goto _test_eof209;
5634 case 209:
5635         switch( (*p) ) {
5636                 case 95: goto tr297;
5637                 case 101: goto st210;
5638         }
5639         if ( (*p) < 65 ) {
5640                 if ( 48 <= (*p) && (*p) <= 57 )
5641                         goto tr297;
5642         } else if ( (*p) > 90 ) {
5643                 if ( 97 <= (*p) && (*p) <= 122 )
5644                         goto tr297;
5645         } else
5646                 goto tr297;
5647         goto tr370;
5648 st210:
5649         if ( ++p == pe )
5650                 goto _test_eof210;
5651 case 210:
5652         switch( (*p) ) {
5653                 case 95: goto tr297;
5654                 case 110: goto tr418;
5655         }
5656         if ( (*p) < 65 ) {
5657                 if ( 48 <= (*p) && (*p) <= 57 )
5658                         goto tr297;
5659         } else if ( (*p) > 90 ) {
5660                 if ( 97 <= (*p) && (*p) <= 122 )
5661                         goto tr297;
5662         } else
5663                 goto tr297;
5664         goto tr370;
5665 st211:
5666         if ( ++p == pe )
5667                 goto _test_eof211;
5668 case 211:
5669         switch( (*p) ) {
5670                 case 95: goto tr297;
5671                 case 101: goto st212;
5672         }
5673         if ( (*p) < 65 ) {
5674                 if ( 48 <= (*p) && (*p) <= 57 )
5675                         goto tr297;
5676         } else if ( (*p) > 90 ) {
5677                 if ( 97 <= (*p) && (*p) <= 122 )
5678                         goto tr297;
5679         } else
5680                 goto tr297;
5681         goto tr370;
5682 st212:
5683         if ( ++p == pe )
5684                 goto _test_eof212;
5685 case 212:
5686         switch( (*p) ) {
5687                 case 95: goto tr297;
5688                 case 114: goto st213;
5689         }
5690         if ( (*p) < 65 ) {
5691                 if ( 48 <= (*p) && (*p) <= 57 )
5692                         goto tr297;
5693         } else if ( (*p) > 90 ) {
5694                 if ( 97 <= (*p) && (*p) <= 122 )
5695                         goto tr297;
5696         } else
5697                 goto tr297;
5698         goto tr370;
5699 st213:
5700         if ( ++p == pe )
5701                 goto _test_eof213;
5702 case 213:
5703         switch( (*p) ) {
5704                 case 95: goto tr297;
5705                 case 114: goto tr421;
5706         }
5707         if ( (*p) < 65 ) {
5708                 if ( 48 <= (*p) && (*p) <= 57 )
5709                         goto tr297;
5710         } else if ( (*p) > 90 ) {
5711                 if ( 97 <= (*p) && (*p) <= 122 )
5712                         goto tr297;
5713         } else
5714                 goto tr297;
5715         goto tr370;
5716 st214:
5717         if ( ++p == pe )
5718                 goto _test_eof214;
5719 case 214:
5720         switch( (*p) ) {
5721                 case 95: goto tr297;
5722                 case 97: goto st215;
5723         }
5724         if ( (*p) < 65 ) {
5725                 if ( 48 <= (*p) && (*p) <= 57 )
5726                         goto tr297;
5727         } else if ( (*p) > 90 ) {
5728                 if ( 98 <= (*p) && (*p) <= 122 )
5729                         goto tr297;
5730         } else
5731                 goto tr297;
5732         goto tr370;
5733 st215:
5734         if ( ++p == pe )
5735                 goto _test_eof215;
5736 case 215:
5737         switch( (*p) ) {
5738                 case 95: goto tr297;
5739                 case 99: goto st216;
5740         }
5741         if ( (*p) < 65 ) {
5742                 if ( 48 <= (*p) && (*p) <= 57 )
5743                         goto tr297;
5744         } else if ( (*p) > 90 ) {
5745                 if ( 97 <= (*p) && (*p) <= 122 )
5746                         goto tr297;
5747         } else
5748                 goto tr297;
5749         goto tr370;
5750 st216:
5751         if ( ++p == pe )
5752                 goto _test_eof216;
5753 case 216:
5754         switch( (*p) ) {
5755                 case 95: goto tr297;
5756                 case 104: goto st217;
5757         }
5758         if ( (*p) < 65 ) {
5759                 if ( 48 <= (*p) && (*p) <= 57 )
5760                         goto tr297;
5761         } else if ( (*p) > 90 ) {
5762                 if ( 97 <= (*p) && (*p) <= 122 )
5763                         goto tr297;
5764         } else
5765                 goto tr297;
5766         goto tr370;
5767 st217:
5768         if ( ++p == pe )
5769                 goto _test_eof217;
5770 case 217:
5771         switch( (*p) ) {
5772                 case 95: goto tr297;
5773                 case 105: goto st218;
5774         }
5775         if ( (*p) < 65 ) {
5776                 if ( 48 <= (*p) && (*p) <= 57 )
5777                         goto tr297;
5778         } else if ( (*p) > 90 ) {
5779                 if ( 97 <= (*p) && (*p) <= 122 )
5780                         goto tr297;
5781         } else
5782                 goto tr297;
5783         goto tr370;
5784 st218:
5785         if ( ++p == pe )
5786                 goto _test_eof218;
5787 case 218:
5788         switch( (*p) ) {
5789                 case 95: goto tr297;
5790                 case 110: goto st219;
5791         }
5792         if ( (*p) < 65 ) {
5793                 if ( 48 <= (*p) && (*p) <= 57 )
5794                         goto tr297;
5795         } else if ( (*p) > 90 ) {
5796                 if ( 97 <= (*p) && (*p) <= 122 )
5797                         goto tr297;
5798         } else
5799                 goto tr297;
5800         goto tr370;
5801 st219:
5802         if ( ++p == pe )
5803                 goto _test_eof219;
5804 case 219:
5805         switch( (*p) ) {
5806                 case 95: goto tr297;
5807                 case 101: goto tr427;
5808         }
5809         if ( (*p) < 65 ) {
5810                 if ( 48 <= (*p) && (*p) <= 57 )
5811                         goto tr297;
5812         } else if ( (*p) > 90 ) {
5813                 if ( 97 <= (*p) && (*p) <= 122 )
5814                         goto tr297;
5815         } else
5816                 goto tr297;
5817         goto tr370;
5818 st220:
5819         if ( ++p == pe )
5820                 goto _test_eof220;
5821 case 220:
5822         switch( (*p) ) {
5823                 case 95: goto tr297;
5824                 case 117: goto st221;
5825         }
5826         if ( (*p) < 65 ) {
5827                 if ( 48 <= (*p) && (*p) <= 57 )
5828                         goto tr297;
5829         } else if ( (*p) > 90 ) {
5830                 if ( 97 <= (*p) && (*p) <= 122 )
5831                         goto tr297;
5832         } else
5833                 goto tr297;
5834         goto tr370;
5835 st221:
5836         if ( ++p == pe )
5837                 goto _test_eof221;
5838 case 221:
5839         switch( (*p) ) {
5840                 case 95: goto tr297;
5841                 case 116: goto st222;
5842         }
5843         if ( (*p) < 65 ) {
5844                 if ( 48 <= (*p) && (*p) <= 57 )
5845                         goto tr297;
5846         } else if ( (*p) > 90 ) {
5847                 if ( 97 <= (*p) && (*p) <= 122 )
5848                         goto tr297;
5849         } else
5850                 goto tr297;
5851         goto tr370;
5852 st222:
5853         if ( ++p == pe )
5854                 goto _test_eof222;
5855 case 222:
5856         switch( (*p) ) {
5857                 case 95: goto tr297;
5858                 case 119: goto st223;
5859         }
5860         if ( (*p) < 65 ) {
5861                 if ( 48 <= (*p) && (*p) <= 57 )
5862                         goto tr297;
5863         } else if ( (*p) > 90 ) {
5864                 if ( 97 <= (*p) && (*p) <= 122 )
5865                         goto tr297;
5866         } else
5867                 goto tr297;
5868         goto tr370;
5869 st223:
5870         if ( ++p == pe )
5871                 goto _test_eof223;
5872 case 223:
5873         switch( (*p) ) {
5874                 case 95: goto tr297;
5875                 case 104: goto st224;
5876         }
5877         if ( (*p) < 65 ) {
5878                 if ( 48 <= (*p) && (*p) <= 57 )
5879                         goto tr297;
5880         } else if ( (*p) > 90 ) {
5881                 if ( 97 <= (*p) && (*p) <= 122 )
5882                         goto tr297;
5883         } else
5884                 goto tr297;
5885         goto tr370;
5886 st224:
5887         if ( ++p == pe )
5888                 goto _test_eof224;
5889 case 224:
5890         switch( (*p) ) {
5891                 case 95: goto tr297;
5892                 case 101: goto st225;
5893         }
5894         if ( (*p) < 65 ) {
5895                 if ( 48 <= (*p) && (*p) <= 57 )
5896                         goto tr297;
5897         } else if ( (*p) > 90 ) {
5898                 if ( 97 <= (*p) && (*p) <= 122 )
5899                         goto tr297;
5900         } else
5901                 goto tr297;
5902         goto tr370;
5903 st225:
5904         if ( ++p == pe )
5905                 goto _test_eof225;
5906 case 225:
5907         switch( (*p) ) {
5908                 case 95: goto tr297;
5909                 case 110: goto tr433;
5910         }
5911         if ( (*p) < 65 ) {
5912                 if ( 48 <= (*p) && (*p) <= 57 )
5913                         goto tr297;
5914         } else if ( (*p) > 90 ) {
5915                 if ( 97 <= (*p) && (*p) <= 122 )
5916                         goto tr297;
5917         } else
5918                 goto tr297;
5919         goto tr370;
5920 st226:
5921         if ( ++p == pe )
5922                 goto _test_eof226;
5923 case 226:
5924         switch( (*p) ) {
5925                 case 95: goto tr297;
5926                 case 111: goto st227;
5927                 case 114: goto st232;
5928         }
5929         if ( (*p) < 65 ) {
5930                 if ( 48 <= (*p) && (*p) <= 57 )
5931                         goto tr297;
5932         } else if ( (*p) > 90 ) {
5933                 if ( 97 <= (*p) && (*p) <= 122 )
5934                         goto tr297;
5935         } else
5936                 goto tr297;
5937         goto tr370;
5938 st227:
5939         if ( ++p == pe )
5940                 goto _test_eof227;
5941 case 227:
5942         switch( (*p) ) {
5943                 case 95: goto tr297;
5944                 case 115: goto st228;
5945         }
5946         if ( (*p) < 65 ) {
5947                 if ( 48 <= (*p) && (*p) <= 57 )
5948                         goto tr297;
5949         } else if ( (*p) > 90 ) {
5950                 if ( 97 <= (*p) && (*p) <= 122 )
5951                         goto tr297;
5952         } else
5953                 goto tr297;
5954         goto tr370;
5955 st228:
5956         if ( ++p == pe )
5957                 goto _test_eof228;
5958 case 228:
5959         switch( (*p) ) {
5960                 case 95: goto tr297;
5961                 case 116: goto st229;
5962         }
5963         if ( (*p) < 65 ) {
5964                 if ( 48 <= (*p) && (*p) <= 57 )
5965                         goto tr297;
5966         } else if ( (*p) > 90 ) {
5967                 if ( 97 <= (*p) && (*p) <= 122 )
5968                         goto tr297;
5969         } else
5970                 goto tr297;
5971         goto tr370;
5972 st229:
5973         if ( ++p == pe )
5974                 goto _test_eof229;
5975 case 229:
5976         switch( (*p) ) {
5977                 case 95: goto tr297;
5978                 case 112: goto st230;
5979         }
5980         if ( (*p) < 65 ) {
5981                 if ( 48 <= (*p) && (*p) <= 57 )
5982                         goto tr297;
5983         } else if ( (*p) > 90 ) {
5984                 if ( 97 <= (*p) && (*p) <= 122 )
5985                         goto tr297;
5986         } else
5987                 goto tr297;
5988         goto tr370;
5989 st230:
5990         if ( ++p == pe )
5991                 goto _test_eof230;
5992 case 230:
5993         switch( (*p) ) {
5994                 case 95: goto tr297;
5995                 case 111: goto st231;
5996         }
5997         if ( (*p) < 65 ) {
5998                 if ( 48 <= (*p) && (*p) <= 57 )
5999                         goto tr297;
6000         } else if ( (*p) > 90 ) {
6001                 if ( 97 <= (*p) && (*p) <= 122 )
6002                         goto tr297;
6003         } else
6004                 goto tr297;
6005         goto tr370;
6006 st231:
6007         if ( ++p == pe )
6008                 goto _test_eof231;
6009 case 231:
6010         switch( (*p) ) {
6011                 case 95: goto tr297;
6012                 case 112: goto tr440;
6013         }
6014         if ( (*p) < 65 ) {
6015                 if ( 48 <= (*p) && (*p) <= 57 )
6016                         goto tr297;
6017         } else if ( (*p) > 90 ) {
6018                 if ( 97 <= (*p) && (*p) <= 122 )
6019                         goto tr297;
6020         } else
6021                 goto tr297;
6022         goto tr370;
6023 st232:
6024         if ( ++p == pe )
6025                 goto _test_eof232;
6026 case 232:
6027         switch( (*p) ) {
6028                 case 95: goto tr297;
6029                 case 101: goto st233;
6030         }
6031         if ( (*p) < 65 ) {
6032                 if ( 48 <= (*p) && (*p) <= 57 )
6033                         goto tr297;
6034         } else if ( (*p) > 90 ) {
6035                 if ( 97 <= (*p) && (*p) <= 122 )
6036                         goto tr297;
6037         } else
6038                 goto tr297;
6039         goto tr370;
6040 st233:
6041         if ( ++p == pe )
6042                 goto _test_eof233;
6043 case 233:
6044         switch( (*p) ) {
6045                 case 95: goto tr297;
6046                 case 112: goto st234;
6047         }
6048         if ( (*p) < 65 ) {
6049                 if ( 48 <= (*p) && (*p) <= 57 )
6050                         goto tr297;
6051         } else if ( (*p) > 90 ) {
6052                 if ( 97 <= (*p) && (*p) <= 122 )
6053                         goto tr297;
6054         } else
6055                 goto tr297;
6056         goto tr370;
6057 st234:
6058         if ( ++p == pe )
6059                 goto _test_eof234;
6060 case 234:
6061         switch( (*p) ) {
6062                 case 95: goto tr297;
6063                 case 117: goto st235;
6064         }
6065         if ( (*p) < 65 ) {
6066                 if ( 48 <= (*p) && (*p) <= 57 )
6067                         goto tr297;
6068         } else if ( (*p) > 90 ) {
6069                 if ( 97 <= (*p) && (*p) <= 122 )
6070                         goto tr297;
6071         } else
6072                 goto tr297;
6073         goto tr370;
6074 st235:
6075         if ( ++p == pe )
6076                 goto _test_eof235;
6077 case 235:
6078         switch( (*p) ) {
6079                 case 95: goto tr297;
6080                 case 115: goto st236;
6081         }
6082         if ( (*p) < 65 ) {
6083                 if ( 48 <= (*p) && (*p) <= 57 )
6084                         goto tr297;
6085         } else if ( (*p) > 90 ) {
6086                 if ( 97 <= (*p) && (*p) <= 122 )
6087                         goto tr297;
6088         } else
6089                 goto tr297;
6090         goto tr370;
6091 st236:
6092         if ( ++p == pe )
6093                 goto _test_eof236;
6094 case 236:
6095         switch( (*p) ) {
6096                 case 95: goto tr297;
6097                 case 104: goto tr445;
6098         }
6099         if ( (*p) < 65 ) {
6100                 if ( 48 <= (*p) && (*p) <= 57 )
6101                         goto tr297;
6102         } else if ( (*p) > 90 ) {
6103                 if ( 97 <= (*p) && (*p) <= 122 )
6104                         goto tr297;
6105         } else
6106                 goto tr297;
6107         goto tr370;
6108 st237:
6109         if ( ++p == pe )
6110                 goto _test_eof237;
6111 case 237:
6112         switch( (*p) ) {
6113                 case 95: goto tr297;
6114                 case 111: goto tr446;
6115         }
6116         if ( (*p) < 65 ) {
6117                 if ( 48 <= (*p) && (*p) <= 57 )
6118                         goto tr297;
6119         } else if ( (*p) > 90 ) {
6120                 if ( 97 <= (*p) && (*p) <= 122 )
6121                         goto tr297;
6122         } else
6123                 goto tr297;
6124         goto tr370;
6125 st238:
6126         if ( ++p == pe )
6127                 goto _test_eof238;
6128 case 238:
6129         switch( (*p) ) {
6130                 case 95: goto tr297;
6131                 case 97: goto st239;
6132         }
6133         if ( (*p) < 65 ) {
6134                 if ( 48 <= (*p) && (*p) <= 57 )
6135                         goto tr297;
6136         } else if ( (*p) > 90 ) {
6137                 if ( 98 <= (*p) && (*p) <= 122 )
6138                         goto tr297;
6139         } else
6140                 goto tr297;
6141         goto tr370;
6142 st239:
6143         if ( ++p == pe )
6144                 goto _test_eof239;
6145 case 239:
6146         switch( (*p) ) {
6147                 case 95: goto tr297;
6148                 case 114: goto st240;
6149         }
6150         if ( (*p) < 65 ) {
6151                 if ( 48 <= (*p) && (*p) <= 57 )
6152                         goto tr297;
6153         } else if ( (*p) > 90 ) {
6154                 if ( 97 <= (*p) && (*p) <= 122 )
6155                         goto tr297;
6156         } else
6157                 goto tr297;
6158         goto tr370;
6159 st240:
6160         if ( ++p == pe )
6161                 goto _test_eof240;
6162 case 240:
6163         switch( (*p) ) {
6164                 case 95: goto tr297;
6165                 case 105: goto st241;
6166         }
6167         if ( (*p) < 65 ) {
6168                 if ( 48 <= (*p) && (*p) <= 57 )
6169                         goto tr297;
6170         } else if ( (*p) > 90 ) {
6171                 if ( 97 <= (*p) && (*p) <= 122 )
6172                         goto tr297;
6173         } else
6174                 goto tr297;
6175         goto tr370;
6176 st241:
6177         if ( ++p == pe )
6178                 goto _test_eof241;
6179 case 241:
6180         switch( (*p) ) {
6181                 case 95: goto tr297;
6182                 case 97: goto st242;
6183         }
6184         if ( (*p) < 65 ) {
6185                 if ( 48 <= (*p) && (*p) <= 57 )
6186                         goto tr297;
6187         } else if ( (*p) > 90 ) {
6188                 if ( 98 <= (*p) && (*p) <= 122 )
6189                         goto tr297;
6190         } else
6191                 goto tr297;
6192         goto tr370;
6193 st242:
6194         if ( ++p == pe )
6195                 goto _test_eof242;
6196 case 242:
6197         switch( (*p) ) {
6198                 case 95: goto tr297;
6199                 case 98: goto st243;
6200         }
6201         if ( (*p) < 65 ) {
6202                 if ( 48 <= (*p) && (*p) <= 57 )
6203                         goto tr297;
6204         } else if ( (*p) > 90 ) {
6205                 if ( 97 <= (*p) && (*p) <= 122 )
6206                         goto tr297;
6207         } else
6208                 goto tr297;
6209         goto tr370;
6210 st243:
6211         if ( ++p == pe )
6212                 goto _test_eof243;
6213 case 243:
6214         switch( (*p) ) {
6215                 case 95: goto tr297;
6216                 case 108: goto st244;
6217         }
6218         if ( (*p) < 65 ) {
6219                 if ( 48 <= (*p) && (*p) <= 57 )
6220                         goto tr297;
6221         } else if ( (*p) > 90 ) {
6222                 if ( 97 <= (*p) && (*p) <= 122 )
6223                         goto tr297;
6224         } else
6225                 goto tr297;
6226         goto tr370;
6227 st244:
6228         if ( ++p == pe )
6229                 goto _test_eof244;
6230 case 244:
6231         switch( (*p) ) {
6232                 case 95: goto tr297;
6233                 case 101: goto tr453;
6234         }
6235         if ( (*p) < 65 ) {
6236                 if ( 48 <= (*p) && (*p) <= 57 )
6237                         goto tr297;
6238         } else if ( (*p) > 90 ) {
6239                 if ( 97 <= (*p) && (*p) <= 122 )
6240                         goto tr297;
6241         } else
6242                 goto tr297;
6243         goto tr370;
6244 st245:
6245         if ( ++p == pe )
6246                 goto _test_eof245;
6247 case 245:
6248         switch( (*p) ) {
6249                 case 95: goto tr297;
6250                 case 104: goto st246;
6251                 case 114: goto st248;
6252         }
6253         if ( (*p) < 65 ) {
6254                 if ( 48 <= (*p) && (*p) <= 57 )
6255                         goto tr297;
6256         } else if ( (*p) > 90 ) {
6257                 if ( 97 <= (*p) && (*p) <= 122 )
6258                         goto tr297;
6259         } else
6260                 goto tr297;
6261         goto tr370;
6262 st246:
6263         if ( ++p == pe )
6264                 goto _test_eof246;
6265 case 246:
6266         switch( (*p) ) {
6267                 case 95: goto tr297;
6268                 case 101: goto st247;
6269         }
6270         if ( (*p) < 65 ) {
6271                 if ( 48 <= (*p) && (*p) <= 57 )
6272                         goto tr297;
6273         } else if ( (*p) > 90 ) {
6274                 if ( 97 <= (*p) && (*p) <= 122 )
6275                         goto tr297;
6276         } else
6277                 goto tr297;
6278         goto tr370;
6279 st247:
6280         if ( ++p == pe )
6281                 goto _test_eof247;
6282 case 247:
6283         switch( (*p) ) {
6284                 case 95: goto tr297;
6285                 case 110: goto tr457;
6286         }
6287         if ( (*p) < 65 ) {
6288                 if ( 48 <= (*p) && (*p) <= 57 )
6289                         goto tr297;
6290         } else if ( (*p) > 90 ) {
6291                 if ( 97 <= (*p) && (*p) <= 122 )
6292                         goto tr297;
6293         } else
6294                 goto tr297;
6295         goto tr370;
6296 st248:
6297         if ( ++p == pe )
6298                 goto _test_eof248;
6299 case 248:
6300         switch( (*p) ) {
6301                 case 95: goto tr297;
6302                 case 105: goto st249;
6303         }
6304         if ( (*p) < 65 ) {
6305                 if ( 48 <= (*p) && (*p) <= 57 )
6306                         goto tr297;
6307         } else if ( (*p) > 90 ) {
6308                 if ( 97 <= (*p) && (*p) <= 122 )
6309                         goto tr297;
6310         } else
6311                 goto tr297;
6312         goto tr370;
6313 st249:
6314         if ( ++p == pe )
6315                 goto _test_eof249;
6316 case 249:
6317         switch( (*p) ) {
6318                 case 95: goto tr297;
6319                 case 116: goto st250;
6320         }
6321         if ( (*p) < 65 ) {
6322                 if ( 48 <= (*p) && (*p) <= 57 )
6323                         goto tr297;
6324         } else if ( (*p) > 90 ) {
6325                 if ( 97 <= (*p) && (*p) <= 122 )
6326                         goto tr297;
6327         } else
6328                 goto tr297;
6329         goto tr370;
6330 st250:
6331         if ( ++p == pe )
6332                 goto _test_eof250;
6333 case 250:
6334         switch( (*p) ) {
6335                 case 95: goto tr297;
6336                 case 101: goto tr460;
6337         }
6338         if ( (*p) < 65 ) {
6339                 if ( 48 <= (*p) && (*p) <= 57 )
6340                         goto tr297;
6341         } else if ( (*p) > 90 ) {
6342                 if ( 97 <= (*p) && (*p) <= 122 )
6343                         goto tr297;
6344         } else
6345                 goto tr297;
6346         goto tr370;
6347 st251:
6348         if ( ++p == pe )
6349                 goto _test_eof251;
6350 case 251:
6351         if ( (*p) == 42 )
6352                 goto tr461;
6353         goto tr315;
6354 tr313:
6355 #line 1 "rlscan.rl"
6356         {te = p+1;}
6357         goto st252;
6358 st252:
6359         if ( ++p == pe )
6360                 goto _test_eof252;
6361 case 252:
6362 #line 6363 "rlscan.cpp"
6363         if ( (*p) == 37 )
6364                 goto st30;
6365         goto tr315;
6366 st30:
6367         if ( ++p == pe )
6368                 goto _test_eof30;
6369 case 30:
6370         if ( (*p) == 37 )
6371                 goto tr57;
6372         goto tr45;
6373 tr58:
6374 #line 1135 "rlscan.rl"
6375         {{p = ((te))-1;}{ pass( *ts, 0, 0 ); }}
6376         goto st253;
6377 tr61:
6378 #line 1119 "rlscan.rl"
6379         {te = p+1;{ pass( IMP_Literal, ts, te ); }}
6380         goto st253;
6381 tr64:
6382 #line 630 "rlscan.rl"
6383         {
6384                 lastnl = p;
6385                 column = 0;
6386                 line++;
6387         }
6388 #line 1117 "rlscan.rl"
6389         {te = p+1;{ pass(); }}
6390         goto st253;
6391 tr463:
6392 #line 1135 "rlscan.rl"
6393         {te = p+1;{ pass( *ts, 0, 0 ); }}
6394         goto st253;
6395 tr464:
6396 #line 1134 "rlscan.rl"
6397         {te = p+1;}
6398         goto st253;
6399 tr474:
6400 #line 1133 "rlscan.rl"
6401         {te = p;p--;{ pass(); }}
6402         goto st253;
6403 tr475:
6404 #line 1135 "rlscan.rl"
6405         {te = p;p--;{ pass( *ts, 0, 0 ); }}
6406         goto st253;
6407 tr477:
6408 #line 1127 "rlscan.rl"
6409         {te = p;p--;{
6410                         updateCol();
6411                         singleLineSpec = true;
6412                         startSection();
6413                         {stack[top++] = 253; goto st146;}
6414                 }}
6415         goto st253;
6416 tr478:
6417 #line 1121 "rlscan.rl"
6418         {te = p+1;{
6419                         updateCol();
6420                         singleLineSpec = false;
6421                         startSection();
6422                         {stack[top++] = 253; goto st146;}
6423                 }}
6424         goto st253;
6425 tr479:
6426 #line 1116 "rlscan.rl"
6427         {te = p;p--;{ pass( IMP_UInt, ts, te ); }}
6428         goto st253;
6429 tr480:
6430 #line 1115 "rlscan.rl"
6431         {te = p;p--;{ pass( IMP_Word, ts, te ); }}
6432         goto st253;
6433 st253:
6434 #line 1 "rlscan.rl"
6435         {ts = 0;}
6436         if ( ++p == pe )
6437                 goto _test_eof253;
6438 case 253:
6439 #line 1 "rlscan.rl"
6440         {ts = p;}
6441 #line 6442 "rlscan.cpp"
6442         switch( (*p) ) {
6443                 case 0: goto tr464;
6444                 case 9: goto st254;
6445                 case 10: goto tr466;
6446                 case 32: goto st254;
6447                 case 34: goto tr467;
6448                 case 35: goto tr468;
6449                 case 37: goto st257;
6450                 case 39: goto tr470;
6451                 case 47: goto tr471;
6452                 case 95: goto st262;
6453         }
6454         if ( (*p) < 65 ) {
6455                 if ( 48 <= (*p) && (*p) <= 57 )
6456                         goto st261;
6457         } else if ( (*p) > 90 ) {
6458                 if ( 97 <= (*p) && (*p) <= 122 )
6459                         goto st262;
6460         } else
6461                 goto st262;
6462         goto tr463;
6463 tr466:
6464 #line 630 "rlscan.rl"
6465         {
6466                 lastnl = p;
6467                 column = 0;
6468                 line++;
6469         }
6470         goto st254;
6471 st254:
6472         if ( ++p == pe )
6473                 goto _test_eof254;
6474 case 254:
6475 #line 6476 "rlscan.cpp"
6476         switch( (*p) ) {
6477                 case 9: goto st254;
6478                 case 10: goto tr466;
6479                 case 32: goto st254;
6480         }
6481         goto tr474;
6482 tr467:
6483 #line 1 "rlscan.rl"
6484         {te = p+1;}
6485         goto st255;
6486 st255:
6487         if ( ++p == pe )
6488                 goto _test_eof255;
6489 case 255:
6490 #line 6491 "rlscan.cpp"
6491         switch( (*p) ) {
6492                 case 10: goto tr60;
6493                 case 34: goto tr61;
6494                 case 92: goto st32;
6495         }
6496         goto st31;
6497 tr60:
6498 #line 630 "rlscan.rl"
6499         {
6500                 lastnl = p;
6501                 column = 0;
6502                 line++;
6503         }
6504         goto st31;
6505 st31:
6506         if ( ++p == pe )
6507                 goto _test_eof31;
6508 case 31:
6509 #line 6510 "rlscan.cpp"
6510         switch( (*p) ) {
6511                 case 10: goto tr60;
6512                 case 34: goto tr61;
6513                 case 92: goto st32;
6514         }
6515         goto st31;
6516 st32:
6517         if ( ++p == pe )
6518                 goto _test_eof32;
6519 case 32:
6520         if ( (*p) == 10 )
6521                 goto tr60;
6522         goto st31;
6523 tr468:
6524 #line 1 "rlscan.rl"
6525         {te = p+1;}
6526         goto st256;
6527 st256:
6528         if ( ++p == pe )
6529                 goto _test_eof256;
6530 case 256:
6531 #line 6532 "rlscan.cpp"
6532         if ( (*p) == 10 )
6533                 goto tr64;
6534         goto st33;
6535 st33:
6536         if ( ++p == pe )
6537                 goto _test_eof33;
6538 case 33:
6539         if ( (*p) == 10 )
6540                 goto tr64;
6541         goto st33;
6542 st257:
6543         if ( ++p == pe )
6544                 goto _test_eof257;
6545 case 257:
6546         if ( (*p) == 37 )
6547                 goto st258;
6548         goto tr475;
6549 st258:
6550         if ( ++p == pe )
6551                 goto _test_eof258;
6552 case 258:
6553         if ( (*p) == 123 )
6554                 goto tr478;
6555         goto tr477;
6556 tr470:
6557 #line 1 "rlscan.rl"
6558         {te = p+1;}
6559         goto st259;
6560 st259:
6561         if ( ++p == pe )
6562                 goto _test_eof259;
6563 case 259:
6564 #line 6565 "rlscan.cpp"
6565         switch( (*p) ) {
6566                 case 10: goto tr66;
6567                 case 39: goto tr61;
6568                 case 92: goto st35;
6569         }
6570         goto st34;
6571 tr66:
6572 #line 630 "rlscan.rl"
6573         {
6574                 lastnl = p;
6575                 column = 0;
6576                 line++;
6577         }
6578         goto st34;
6579 st34:
6580         if ( ++p == pe )
6581                 goto _test_eof34;
6582 case 34:
6583 #line 6584 "rlscan.cpp"
6584         switch( (*p) ) {
6585                 case 10: goto tr66;
6586                 case 39: goto tr61;
6587                 case 92: goto st35;
6588         }
6589         goto st34;
6590 st35:
6591         if ( ++p == pe )
6592                 goto _test_eof35;
6593 case 35:
6594         if ( (*p) == 10 )
6595                 goto tr66;
6596         goto st34;
6597 tr471:
6598 #line 1 "rlscan.rl"
6599         {te = p+1;}
6600         goto st260;
6601 st260:
6602         if ( ++p == pe )
6603                 goto _test_eof260;
6604 case 260:
6605 #line 6606 "rlscan.cpp"
6606         switch( (*p) ) {
6607                 case 10: goto tr69;
6608                 case 47: goto tr61;
6609                 case 92: goto st37;
6610         }
6611         goto st36;
6612 tr69:
6613 #line 630 "rlscan.rl"
6614         {
6615                 lastnl = p;
6616                 column = 0;
6617                 line++;
6618         }
6619         goto st36;
6620 st36:
6621         if ( ++p == pe )
6622                 goto _test_eof36;
6623 case 36:
6624 #line 6625 "rlscan.cpp"
6625         switch( (*p) ) {
6626                 case 10: goto tr69;
6627                 case 47: goto tr61;
6628                 case 92: goto st37;
6629         }
6630         goto st36;
6631 st37:
6632         if ( ++p == pe )
6633                 goto _test_eof37;
6634 case 37:
6635         if ( (*p) == 10 )
6636                 goto tr69;
6637         goto st36;
6638 st261:
6639         if ( ++p == pe )
6640                 goto _test_eof261;
6641 case 261:
6642         if ( 48 <= (*p) && (*p) <= 57 )
6643                 goto st261;
6644         goto tr479;
6645 st262:
6646         if ( ++p == pe )
6647                 goto _test_eof262;
6648 case 262:
6649         if ( (*p) == 95 )
6650                 goto st262;
6651         if ( (*p) < 65 ) {
6652                 if ( 48 <= (*p) && (*p) <= 57 )
6653                         goto st262;
6654         } else if ( (*p) > 90 ) {
6655                 if ( 97 <= (*p) && (*p) <= 122 )
6656                         goto st262;
6657         } else
6658                 goto st262;
6659         goto tr480;
6660         }
6661         _test_eof38: cs = 38; goto _test_eof;
6662         _test_eof39: cs = 39; goto _test_eof;
6663         _test_eof40: cs = 40; goto _test_eof;
6664         _test_eof1: cs = 1; goto _test_eof;
6665         _test_eof2: cs = 2; goto _test_eof;
6666         _test_eof41: cs = 41; goto _test_eof;
6667         _test_eof42: cs = 42; goto _test_eof;
6668         _test_eof43: cs = 43; goto _test_eof;
6669         _test_eof3: cs = 3; goto _test_eof;
6670         _test_eof4: cs = 4; goto _test_eof;
6671         _test_eof44: cs = 44; goto _test_eof;
6672         _test_eof5: cs = 5; goto _test_eof;
6673         _test_eof6: cs = 6; goto _test_eof;
6674         _test_eof7: cs = 7; goto _test_eof;
6675         _test_eof45: cs = 45; goto _test_eof;
6676         _test_eof46: cs = 46; goto _test_eof;
6677         _test_eof47: cs = 47; goto _test_eof;
6678         _test_eof48: cs = 48; goto _test_eof;
6679         _test_eof49: cs = 49; goto _test_eof;
6680         _test_eof50: cs = 50; goto _test_eof;
6681         _test_eof51: cs = 51; goto _test_eof;
6682         _test_eof52: cs = 52; goto _test_eof;
6683         _test_eof53: cs = 53; goto _test_eof;
6684         _test_eof54: cs = 54; goto _test_eof;
6685         _test_eof8: cs = 8; goto _test_eof;
6686         _test_eof9: cs = 9; goto _test_eof;
6687         _test_eof55: cs = 55; goto _test_eof;
6688         _test_eof10: cs = 10; goto _test_eof;
6689         _test_eof56: cs = 56; goto _test_eof;
6690         _test_eof11: cs = 11; goto _test_eof;
6691         _test_eof12: cs = 12; goto _test_eof;
6692         _test_eof57: cs = 57; goto _test_eof;
6693         _test_eof13: cs = 13; goto _test_eof;
6694         _test_eof14: cs = 14; goto _test_eof;
6695         _test_eof58: cs = 58; goto _test_eof;
6696         _test_eof59: cs = 59; goto _test_eof;
6697         _test_eof15: cs = 15; goto _test_eof;
6698         _test_eof60: cs = 60; goto _test_eof;
6699         _test_eof61: cs = 61; goto _test_eof;
6700         _test_eof62: cs = 62; goto _test_eof;
6701         _test_eof63: cs = 63; goto _test_eof;
6702         _test_eof64: cs = 64; goto _test_eof;
6703         _test_eof65: cs = 65; goto _test_eof;
6704         _test_eof66: cs = 66; goto _test_eof;
6705         _test_eof67: cs = 67; goto _test_eof;
6706         _test_eof68: cs = 68; goto _test_eof;
6707         _test_eof69: cs = 69; goto _test_eof;
6708         _test_eof70: cs = 70; goto _test_eof;
6709         _test_eof71: cs = 71; goto _test_eof;
6710         _test_eof72: cs = 72; goto _test_eof;
6711         _test_eof73: cs = 73; goto _test_eof;
6712         _test_eof74: cs = 74; goto _test_eof;
6713         _test_eof75: cs = 75; goto _test_eof;
6714         _test_eof76: cs = 76; goto _test_eof;
6715         _test_eof77: cs = 77; goto _test_eof;
6716         _test_eof78: cs = 78; goto _test_eof;
6717         _test_eof79: cs = 79; goto _test_eof;
6718         _test_eof80: cs = 80; goto _test_eof;
6719         _test_eof81: cs = 81; goto _test_eof;
6720         _test_eof82: cs = 82; goto _test_eof;
6721         _test_eof83: cs = 83; goto _test_eof;
6722         _test_eof84: cs = 84; goto _test_eof;
6723         _test_eof85: cs = 85; goto _test_eof;
6724         _test_eof86: cs = 86; goto _test_eof;
6725         _test_eof87: cs = 87; goto _test_eof;
6726         _test_eof88: cs = 88; goto _test_eof;
6727         _test_eof89: cs = 89; goto _test_eof;
6728         _test_eof90: cs = 90; goto _test_eof;
6729         _test_eof91: cs = 91; goto _test_eof;
6730         _test_eof92: cs = 92; goto _test_eof;
6731         _test_eof93: cs = 93; goto _test_eof;
6732         _test_eof94: cs = 94; goto _test_eof;
6733         _test_eof95: cs = 95; goto _test_eof;
6734         _test_eof96: cs = 96; goto _test_eof;
6735         _test_eof97: cs = 97; goto _test_eof;
6736         _test_eof16: cs = 16; goto _test_eof;
6737         _test_eof17: cs = 17; goto _test_eof;
6738         _test_eof98: cs = 98; goto _test_eof;
6739         _test_eof18: cs = 18; goto _test_eof;
6740         _test_eof19: cs = 19; goto _test_eof;
6741         _test_eof99: cs = 99; goto _test_eof;
6742         _test_eof20: cs = 20; goto _test_eof;
6743         _test_eof21: cs = 21; goto _test_eof;
6744         _test_eof22: cs = 22; goto _test_eof;
6745         _test_eof100: cs = 100; goto _test_eof;
6746         _test_eof101: cs = 101; goto _test_eof;
6747         _test_eof23: cs = 23; goto _test_eof;
6748         _test_eof102: cs = 102; goto _test_eof;
6749         _test_eof103: cs = 103; goto _test_eof;
6750         _test_eof104: cs = 104; goto _test_eof;
6751         _test_eof105: cs = 105; goto _test_eof;
6752         _test_eof106: cs = 106; goto _test_eof;
6753         _test_eof107: cs = 107; goto _test_eof;
6754         _test_eof108: cs = 108; goto _test_eof;
6755         _test_eof109: cs = 109; goto _test_eof;
6756         _test_eof110: cs = 110; goto _test_eof;
6757         _test_eof111: cs = 111; goto _test_eof;
6758         _test_eof112: cs = 112; goto _test_eof;
6759         _test_eof113: cs = 113; goto _test_eof;
6760         _test_eof114: cs = 114; goto _test_eof;
6761         _test_eof115: cs = 115; goto _test_eof;
6762         _test_eof116: cs = 116; goto _test_eof;
6763         _test_eof117: cs = 117; goto _test_eof;
6764         _test_eof118: cs = 118; goto _test_eof;
6765         _test_eof119: cs = 119; goto _test_eof;
6766         _test_eof120: cs = 120; goto _test_eof;
6767         _test_eof121: cs = 121; goto _test_eof;
6768         _test_eof122: cs = 122; goto _test_eof;
6769         _test_eof123: cs = 123; goto _test_eof;
6770         _test_eof124: cs = 124; goto _test_eof;
6771         _test_eof125: cs = 125; goto _test_eof;
6772         _test_eof126: cs = 126; goto _test_eof;
6773         _test_eof127: cs = 127; goto _test_eof;
6774         _test_eof128: cs = 128; goto _test_eof;
6775         _test_eof129: cs = 129; goto _test_eof;
6776         _test_eof130: cs = 130; goto _test_eof;
6777         _test_eof131: cs = 131; goto _test_eof;
6778         _test_eof132: cs = 132; goto _test_eof;
6779         _test_eof133: cs = 133; goto _test_eof;
6780         _test_eof134: cs = 134; goto _test_eof;
6781         _test_eof135: cs = 135; goto _test_eof;
6782         _test_eof136: cs = 136; goto _test_eof;
6783         _test_eof137: cs = 137; goto _test_eof;
6784         _test_eof138: cs = 138; goto _test_eof;
6785         _test_eof139: cs = 139; goto _test_eof;
6786         _test_eof140: cs = 140; goto _test_eof;
6787         _test_eof141: cs = 141; goto _test_eof;
6788         _test_eof142: cs = 142; goto _test_eof;
6789         _test_eof143: cs = 143; goto _test_eof;
6790         _test_eof144: cs = 144; goto _test_eof;
6791         _test_eof145: cs = 145; goto _test_eof;
6792         _test_eof146: cs = 146; goto _test_eof;
6793         _test_eof147: cs = 147; goto _test_eof;
6794         _test_eof148: cs = 148; goto _test_eof;
6795         _test_eof24: cs = 24; goto _test_eof;
6796         _test_eof149: cs = 149; goto _test_eof;
6797         _test_eof25: cs = 25; goto _test_eof;
6798         _test_eof150: cs = 150; goto _test_eof;
6799         _test_eof26: cs = 26; goto _test_eof;
6800         _test_eof151: cs = 151; goto _test_eof;
6801         _test_eof152: cs = 152; goto _test_eof;
6802         _test_eof153: cs = 153; goto _test_eof;
6803         _test_eof27: cs = 27; goto _test_eof;
6804         _test_eof28: cs = 28; goto _test_eof;
6805         _test_eof154: cs = 154; goto _test_eof;
6806         _test_eof155: cs = 155; goto _test_eof;
6807         _test_eof156: cs = 156; goto _test_eof;
6808         _test_eof157: cs = 157; goto _test_eof;
6809         _test_eof158: cs = 158; goto _test_eof;
6810         _test_eof29: cs = 29; goto _test_eof;
6811         _test_eof159: cs = 159; goto _test_eof;
6812         _test_eof160: cs = 160; goto _test_eof;
6813         _test_eof161: cs = 161; goto _test_eof;
6814         _test_eof162: cs = 162; goto _test_eof;
6815         _test_eof163: cs = 163; goto _test_eof;
6816         _test_eof164: cs = 164; goto _test_eof;
6817         _test_eof165: cs = 165; goto _test_eof;
6818         _test_eof166: cs = 166; goto _test_eof;
6819         _test_eof167: cs = 167; goto _test_eof;
6820         _test_eof168: cs = 168; goto _test_eof;
6821         _test_eof169: cs = 169; goto _test_eof;
6822         _test_eof170: cs = 170; goto _test_eof;
6823         _test_eof171: cs = 171; goto _test_eof;
6824         _test_eof172: cs = 172; goto _test_eof;
6825         _test_eof173: cs = 173; goto _test_eof;
6826         _test_eof174: cs = 174; goto _test_eof;
6827         _test_eof175: cs = 175; goto _test_eof;
6828         _test_eof176: cs = 176; goto _test_eof;
6829         _test_eof177: cs = 177; goto _test_eof;
6830         _test_eof178: cs = 178; goto _test_eof;
6831         _test_eof179: cs = 179; goto _test_eof;
6832         _test_eof180: cs = 180; goto _test_eof;
6833         _test_eof181: cs = 181; goto _test_eof;
6834         _test_eof182: cs = 182; goto _test_eof;
6835         _test_eof183: cs = 183; goto _test_eof;
6836         _test_eof184: cs = 184; goto _test_eof;
6837         _test_eof185: cs = 185; goto _test_eof;
6838         _test_eof186: cs = 186; goto _test_eof;
6839         _test_eof187: cs = 187; goto _test_eof;
6840         _test_eof188: cs = 188; goto _test_eof;
6841         _test_eof189: cs = 189; goto _test_eof;
6842         _test_eof190: cs = 190; goto _test_eof;
6843         _test_eof191: cs = 191; goto _test_eof;
6844         _test_eof192: cs = 192; goto _test_eof;
6845         _test_eof193: cs = 193; goto _test_eof;
6846         _test_eof194: cs = 194; goto _test_eof;
6847         _test_eof195: cs = 195; goto _test_eof;
6848         _test_eof196: cs = 196; goto _test_eof;
6849         _test_eof197: cs = 197; goto _test_eof;
6850         _test_eof198: cs = 198; goto _test_eof;
6851         _test_eof199: cs = 199; goto _test_eof;
6852         _test_eof200: cs = 200; goto _test_eof;
6853         _test_eof201: cs = 201; goto _test_eof;
6854         _test_eof202: cs = 202; goto _test_eof;
6855         _test_eof203: cs = 203; goto _test_eof;
6856         _test_eof204: cs = 204; goto _test_eof;
6857         _test_eof205: cs = 205; goto _test_eof;
6858         _test_eof206: cs = 206; goto _test_eof;
6859         _test_eof207: cs = 207; goto _test_eof;
6860         _test_eof208: cs = 208; goto _test_eof;
6861         _test_eof209: cs = 209; goto _test_eof;
6862         _test_eof210: cs = 210; goto _test_eof;
6863         _test_eof211: cs = 211; goto _test_eof;
6864         _test_eof212: cs = 212; goto _test_eof;
6865         _test_eof213: cs = 213; goto _test_eof;
6866         _test_eof214: cs = 214; goto _test_eof;
6867         _test_eof215: cs = 215; goto _test_eof;
6868         _test_eof216: cs = 216; goto _test_eof;
6869         _test_eof217: cs = 217; goto _test_eof;
6870         _test_eof218: cs = 218; goto _test_eof;
6871         _test_eof219: cs = 219; goto _test_eof;
6872         _test_eof220: cs = 220; goto _test_eof;
6873         _test_eof221: cs = 221; goto _test_eof;
6874         _test_eof222: cs = 222; goto _test_eof;
6875         _test_eof223: cs = 223; goto _test_eof;
6876         _test_eof224: cs = 224; goto _test_eof;
6877         _test_eof225: cs = 225; goto _test_eof;
6878         _test_eof226: cs = 226; goto _test_eof;
6879         _test_eof227: cs = 227; goto _test_eof;
6880         _test_eof228: cs = 228; goto _test_eof;
6881         _test_eof229: cs = 229; goto _test_eof;
6882         _test_eof230: cs = 230; goto _test_eof;
6883         _test_eof231: cs = 231; goto _test_eof;
6884         _test_eof232: cs = 232; goto _test_eof;
6885         _test_eof233: cs = 233; goto _test_eof;
6886         _test_eof234: cs = 234; goto _test_eof;
6887         _test_eof235: cs = 235; goto _test_eof;
6888         _test_eof236: cs = 236; goto _test_eof;
6889         _test_eof237: cs = 237; goto _test_eof;
6890         _test_eof238: cs = 238; goto _test_eof;
6891         _test_eof239: cs = 239; goto _test_eof;
6892         _test_eof240: cs = 240; goto _test_eof;
6893         _test_eof241: cs = 241; goto _test_eof;
6894         _test_eof242: cs = 242; goto _test_eof;
6895         _test_eof243: cs = 243; goto _test_eof;
6896         _test_eof244: cs = 244; goto _test_eof;
6897         _test_eof245: cs = 245; goto _test_eof;
6898         _test_eof246: cs = 246; goto _test_eof;
6899         _test_eof247: cs = 247; goto _test_eof;
6900         _test_eof248: cs = 248; goto _test_eof;
6901         _test_eof249: cs = 249; goto _test_eof;
6902         _test_eof250: cs = 250; goto _test_eof;
6903         _test_eof251: cs = 251; goto _test_eof;
6904         _test_eof252: cs = 252; goto _test_eof;
6905         _test_eof30: cs = 30; goto _test_eof;
6906         _test_eof253: cs = 253; goto _test_eof;
6907         _test_eof254: cs = 254; goto _test_eof;
6908         _test_eof255: cs = 255; goto _test_eof;
6909         _test_eof31: cs = 31; goto _test_eof;
6910         _test_eof32: cs = 32; goto _test_eof;
6911         _test_eof256: cs = 256; goto _test_eof;
6912         _test_eof33: cs = 33; goto _test_eof;
6913         _test_eof257: cs = 257; goto _test_eof;
6914         _test_eof258: cs = 258; goto _test_eof;
6915         _test_eof259: cs = 259; goto _test_eof;
6916         _test_eof34: cs = 34; goto _test_eof;
6917         _test_eof35: cs = 35; goto _test_eof;
6918         _test_eof260: cs = 260; goto _test_eof;
6919         _test_eof36: cs = 36; goto _test_eof;
6920         _test_eof37: cs = 37; goto _test_eof;
6921         _test_eof261: cs = 261; goto _test_eof;
6922         _test_eof262: cs = 262; goto _test_eof;
6923
6924         _test_eof: {}
6925         if ( p == eof )
6926         {
6927         switch ( cs ) {
6928         case 39: goto tr82;
6929         case 40: goto tr83;
6930         case 1: goto tr0;
6931         case 2: goto tr0;
6932         case 41: goto tr83;
6933         case 42: goto tr85;
6934         case 43: goto tr83;
6935         case 3: goto tr0;
6936         case 4: goto tr0;
6937         case 44: goto tr83;
6938         case 5: goto tr0;
6939         case 6: goto tr0;
6940         case 7: goto tr0;
6941         case 45: goto tr87;
6942         case 46: goto tr88;
6943         case 47: goto tr89;
6944         case 48: goto tr89;
6945         case 49: goto tr89;
6946         case 50: goto tr89;
6947         case 51: goto tr89;
6948         case 53: goto tr113;
6949         case 54: goto tr114;
6950         case 8: goto tr14;
6951         case 9: goto tr14;
6952         case 55: goto tr114;
6953         case 10: goto tr14;
6954         case 56: goto tr114;
6955         case 11: goto tr14;
6956         case 12: goto tr14;
6957         case 57: goto tr114;
6958         case 13: goto tr14;
6959         case 14: goto tr14;
6960         case 58: goto tr115;
6961         case 59: goto tr115;
6962         case 15: goto tr27;
6963         case 60: goto tr117;
6964         case 61: goto tr114;
6965         case 62: goto tr119;
6966         case 63: goto tr120;
6967         case 64: goto tr120;
6968         case 65: goto tr120;
6969         case 66: goto tr120;
6970         case 67: goto tr120;
6971         case 68: goto tr134;
6972         case 69: goto tr120;
6973         case 70: goto tr120;
6974         case 71: goto tr120;
6975         case 72: goto tr120;
6976         case 73: goto tr120;
6977         case 74: goto tr120;
6978         case 75: goto tr120;
6979         case 76: goto tr120;
6980         case 77: goto tr120;
6981         case 78: goto tr120;
6982         case 79: goto tr120;
6983         case 80: goto tr120;
6984         case 81: goto tr120;
6985         case 82: goto tr120;
6986         case 83: goto tr120;
6987         case 84: goto tr120;
6988         case 85: goto tr120;
6989         case 86: goto tr120;
6990         case 87: goto tr120;
6991         case 88: goto tr120;
6992         case 89: goto tr120;
6993         case 90: goto tr120;
6994         case 91: goto tr120;
6995         case 92: goto tr120;
6996         case 93: goto tr120;
6997         case 94: goto tr120;
6998         case 96: goto tr181;
6999         case 97: goto tr182;
7000         case 16: goto tr29;
7001         case 17: goto tr29;
7002         case 98: goto tr182;
7003         case 18: goto tr29;
7004         case 19: goto tr29;
7005         case 99: goto tr182;
7006         case 20: goto tr29;
7007         case 21: goto tr29;
7008         case 22: goto tr29;
7009         case 100: goto tr183;
7010         case 101: goto tr183;
7011         case 23: goto tr43;
7012         case 102: goto tr185;
7013         case 103: goto tr182;
7014         case 104: goto tr187;
7015         case 105: goto tr188;
7016         case 106: goto tr188;
7017         case 107: goto tr188;
7018         case 108: goto tr188;
7019         case 109: goto tr188;
7020         case 110: goto tr202;
7021         case 111: goto tr188;
7022         case 112: goto tr188;
7023         case 113: goto tr188;
7024         case 114: goto tr188;
7025         case 115: goto tr188;
7026         case 116: goto tr188;
7027         case 117: goto tr188;
7028         case 118: goto tr188;
7029         case 119: goto tr188;
7030         case 120: goto tr188;
7031         case 121: goto tr188;
7032         case 122: goto tr188;
7033         case 123: goto tr188;
7034         case 124: goto tr188;
7035         case 125: goto tr188;
7036         case 126: goto tr188;
7037         case 127: goto tr188;
7038         case 128: goto tr188;
7039         case 129: goto tr188;
7040         case 130: goto tr188;
7041         case 131: goto tr188;
7042         case 132: goto tr188;
7043         case 133: goto tr188;
7044         case 134: goto tr188;
7045         case 135: goto tr188;
7046         case 136: goto tr188;
7047         case 138: goto tr237;
7048         case 140: goto tr255;
7049         case 141: goto tr257;
7050         case 142: goto tr259;
7051         case 144: goto tr275;
7052         case 145: goto tr276;
7053         case 147: goto tr314;
7054         case 148: goto tr315;
7055         case 24: goto tr45;
7056         case 149: goto tr316;
7057         case 25: goto tr45;
7058         case 150: goto tr315;
7059         case 26: goto tr45;
7060         case 151: goto tr315;
7061         case 152: goto tr315;
7062         case 153: goto tr315;
7063         case 27: goto tr45;
7064         case 28: goto tr45;
7065         case 154: goto tr315;
7066         case 155: goto tr315;
7067         case 156: goto tr315;
7068         case 157: goto tr334;
7069         case 158: goto tr334;
7070         case 29: goto tr55;
7071         case 159: goto tr336;
7072         case 160: goto tr315;
7073         case 161: goto tr340;
7074         case 162: goto tr315;
7075         case 163: goto tr349;
7076         case 164: goto tr315;
7077         case 165: goto tr315;
7078         case 166: goto tr315;
7079         case 167: goto tr367;
7080         case 168: goto tr368;
7081         case 169: goto tr370;
7082         case 170: goto tr370;
7083         case 171: goto tr370;
7084         case 172: goto tr370;
7085         case 173: goto tr370;
7086         case 174: goto tr370;
7087         case 175: goto tr370;
7088         case 176: goto tr370;
7089         case 177: goto tr370;
7090         case 178: goto tr370;
7091         case 179: goto tr370;
7092         case 180: goto tr370;
7093         case 181: goto tr370;
7094         case 182: goto tr370;
7095         case 183: goto tr370;
7096         case 184: goto tr370;
7097         case 185: goto tr370;
7098         case 186: goto tr370;
7099         case 187: goto tr370;
7100         case 188: goto tr370;
7101         case 189: goto tr370;
7102         case 190: goto tr370;
7103         case 191: goto tr370;
7104         case 192: goto tr370;
7105         case 193: goto tr370;
7106         case 194: goto tr370;
7107         case 195: goto tr370;
7108         case 196: goto tr370;
7109         case 197: goto tr370;
7110         case 198: goto tr370;
7111         case 199: goto tr370;
7112         case 200: goto tr370;
7113         case 201: goto tr370;
7114         case 202: goto tr370;
7115         case 203: goto tr370;
7116         case 204: goto tr370;
7117         case 205: goto tr370;
7118         case 206: goto tr370;
7119         case 207: goto tr370;
7120         case 208: goto tr370;
7121         case 209: goto tr370;
7122         case 210: goto tr370;
7123         case 211: goto tr370;
7124         case 212: goto tr370;
7125         case 213: goto tr370;
7126         case 214: goto tr370;
7127         case 215: goto tr370;
7128         case 216: goto tr370;
7129         case 217: goto tr370;
7130         case 218: goto tr370;
7131         case 219: goto tr370;
7132         case 220: goto tr370;
7133         case 221: goto tr370;
7134         case 222: goto tr370;
7135         case 223: goto tr370;
7136         case 224: goto tr370;
7137         case 225: goto tr370;
7138         case 226: goto tr370;
7139         case 227: goto tr370;
7140         case 228: goto tr370;
7141         case 229: goto tr370;
7142         case 230: goto tr370;
7143         case 231: goto tr370;
7144         case 232: goto tr370;
7145         case 233: goto tr370;
7146         case 234: goto tr370;
7147         case 235: goto tr370;
7148         case 236: goto tr370;
7149         case 237: goto tr370;
7150         case 238: goto tr370;
7151         case 239: goto tr370;
7152         case 240: goto tr370;
7153         case 241: goto tr370;
7154         case 242: goto tr370;
7155         case 243: goto tr370;
7156         case 244: goto tr370;
7157         case 245: goto tr370;
7158         case 246: goto tr370;
7159         case 247: goto tr370;
7160         case 248: goto tr370;
7161         case 249: goto tr370;
7162         case 250: goto tr370;
7163         case 251: goto tr315;
7164         case 252: goto tr315;
7165         case 30: goto tr45;
7166         case 254: goto tr474;
7167         case 255: goto tr475;
7168         case 31: goto tr58;
7169         case 32: goto tr58;
7170         case 256: goto tr475;
7171         case 33: goto tr58;
7172         case 257: goto tr475;
7173         case 258: goto tr477;
7174         case 259: goto tr475;
7175         case 34: goto tr58;
7176         case 35: goto tr58;
7177         case 260: goto tr475;
7178         case 36: goto tr58;
7179         case 37: goto tr58;
7180         case 261: goto tr479;
7181         case 262: goto tr480;
7182         }
7183         }
7184
7185         _out: {}
7186         }
7187
7188 #line 1230 "rlscan.rl"
7189
7190                 /* Check if we failed. */
7191                 if ( cs == rlscan_error ) {
7192                         /* Machine failed before finding a token. I'm not yet sure if this
7193                          * is reachable. */
7194                         scan_error() << "scanner error" << endl;
7195                         exit(1);
7196                 }
7197
7198                 /* Decide if we need to preserve anything. */
7199                 char *preserve = ts;
7200
7201                 /* Now set up the prefix. */
7202                 if ( preserve == 0 )
7203                         have = 0;
7204                 else {
7205                         /* There is data that needs to be shifted over. */
7206                         have = pe - preserve;
7207                         memmove( buf, preserve, have );
7208                         unsigned int shiftback = preserve - buf;
7209                         if ( ts != 0 )
7210                                 ts -= shiftback;
7211                         te -= shiftback;
7212
7213                         preserve = buf;
7214                 }
7215         }
7216
7217         delete[] buf;
7218 }