ragel/cdcodegen.cpp

   1 /*
   2  *  Copyright 2001-2006 Adrian Thurston <thurston@complang.org>
   3  *            2004 Erich Ocean <eric.ocean@ampede.com>
   4  *            2005 Alan West <alan@alanz.com>
   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 "cdcodegen.h"
  25 #include "ragel.h"
  26 #include "redfsm.h"
  27 #include "gendata.h"
  28 #include <sstream>
  29 #include <string>
  30 #include <assert.h>
  31
  32
  33 using std::ostream;
  34 using std::ostringstream;
  35 using std::string;
  36 using std::cerr;
  37 using std::endl;
  38 using std::istream;
  39 using std::ifstream;
  40 using std::ostream;
  41 using std::ios;
  42 using std::cin;
  43 using std::cout;
  44 using std::cerr;
  45 using std::endl;
  46
  47
  48 extern int numSplitPartitions;
  49 extern bool noLineDirectives;
  50
  51 void cdLineDirective( ostream &out, const char *fileName, int line )
  52 {
  53         if ( noLineDirectives )
  54                 out << "/* ";
  55
  56         /* Write the preprocessor line info for to the input file. */
  57         out << "#line " << line  << " \"";
  58         for ( const char *pc = fileName; *pc != 0; pc++ ) {
  59                 if ( *pc == '\\' )
  60                         out << "\\\\";
  61                 else
  62                         out << *pc;
  63         }
  64         out << '"';
  65
  66         if ( noLineDirectives )
  67                 out << " */";
  68
  69         out << '\n';
  70 }
  71
  72 void FsmCodeGen::genLineDirective( ostream &out )
  73 {
  74         std::streambuf *sbuf = out.rdbuf();
  75         output_filter *filter = static_cast<output_filter*>(sbuf);
  76         cdLineDirective( out, filter->fileName, filter->line + 1 );
  77 }
  78
  79
  80 /* Init code gen with in parameters. */
  81 FsmCodeGen::FsmCodeGen( ostream &out )
  82 :
  83         CodeGenData(out)
  84 {
  85 }
  86
  87 unsigned int FsmCodeGen::arrayTypeSize( unsigned long maxVal )
  88 {
  89         long long maxValLL = (long long) maxVal;
  90         HostType *arrayType = keyOps->typeSubsumes( maxValLL );
  91         assert( arrayType != 0 );
  92         return arrayType->size;
  93 }
  94
  95 string FsmCodeGen::ARRAY_TYPE( unsigned long maxVal )
  96 {
  97         long long maxValLL = (long long) maxVal;
  98         HostType *arrayType = keyOps->typeSubsumes( maxValLL );
  99         assert( arrayType != 0 );
 100
 101         string ret = arrayType->data1;
 102         if ( arrayType->data2 != 0 ) {
 103                 ret += " ";
 104                 ret += arrayType->data2;
 105         }
 106         return ret;
 107 }
 108
 109
 110 /* Write out the fsm name. */
 111 string FsmCodeGen::FSM_NAME()
 112 {
 113         return fsmName;
 114 }
 115
 116 /* Emit the offset of the start state as a decimal integer. */
 117 string FsmCodeGen::START_STATE_ID()
 118 {
 119         ostringstream ret;
 120         ret << redFsm->startState->id;
 121         return ret.str();
 122 };
 123
 124 /* Write out the array of actions. */
 125 std::ostream &FsmCodeGen::ACTIONS_ARRAY()
 126 {
 127         out << "\t0, ";
 128         int totalActions = 1;
 129         for ( GenActionTableMap::Iter act = redFsm->actionMap; act.lte(); act++ ) {
 130                 /* Write out the length, which will never be the last character. */
 131                 out << act->key.length() << ", ";
 132                 /* Put in a line break every 8 */
 133                 if ( totalActions++ % 8 == 7 )
 134                         out << "\n\t";
 135
 136                 for ( GenActionTable::Iter item = act->key; item.lte(); item++ ) {
 137                         out << item->value->actionId;
 138                         if ( ! (act.last() && item.last()) )
 139                                 out << ", ";
 140
 141                         /* Put in a line break every 8 */
 142                         if ( totalActions++ % 8 == 7 )
 143                                 out << "\n\t";
 144                 }
 145         }
 146         out << "\n";
 147         return out;
 148 }
 149
 150
 151 string FsmCodeGen::ACCESS()
 152 {
 153         ostringstream ret;
 154         if ( accessExpr != 0 )
 155                 INLINE_LIST( ret, accessExpr, 0, false, false );
 156         return ret.str();
 157 }
 158
 159
 160 string FsmCodeGen::P()
 161 {
 162         ostringstream ret;
 163         if ( pExpr == 0 )
 164                 ret << "p";
 165         else {
 166                 ret << "(";
 167                 INLINE_LIST( ret, pExpr, 0, false, false );
 168                 ret << ")";
 169         }
 170         return ret.str();
 171 }
 172
 173 string FsmCodeGen::PE()
 174 {
 175         ostringstream ret;
 176         if ( peExpr == 0 )
 177                 ret << "pe";
 178         else {
 179                 ret << "(";
 180                 INLINE_LIST( ret, peExpr, 0, false, false );
 181                 ret << ")";
 182         }
 183         return ret.str();
 184 }
 185
 186 string FsmCodeGen::vEOF()
 187 {
 188         ostringstream ret;
 189         if ( eofExpr == 0 )
 190                 ret << "eof";
 191         else {
 192                 ret << "(";
 193                 INLINE_LIST( ret, eofExpr, 0, false, false );
 194                 ret << ")";
 195         }
 196         return ret.str();
 197 }
 198
 199 string FsmCodeGen::vCS()
 200 {
 201         ostringstream ret;
 202         if ( csExpr == 0 )
 203                 ret << ACCESS() << "cs";
 204         else {
 205                 /* Emit the user supplied method of retrieving the key. */
 206                 ret << "(";
 207                 INLINE_LIST( ret, csExpr, 0, false, false );
 208                 ret << ")";
 209         }
 210         return ret.str();
 211 }
 212
 213 string FsmCodeGen::TOP()
 214 {
 215         ostringstream ret;
 216         if ( topExpr == 0 )
 217                 ret << ACCESS() + "top";
 218         else {
 219                 ret << "(";
 220                 INLINE_LIST( ret, topExpr, 0, false, false );
 221                 ret << ")";
 222         }
 223         return ret.str();
 224 }
 225
 226 string FsmCodeGen::STACK()
 227 {
 228         ostringstream ret;
 229         if ( stackExpr == 0 )
 230                 ret << ACCESS() + "stack";
 231         else {
 232                 ret << "(";
 233                 INLINE_LIST( ret, stackExpr, 0, false, false );
 234                 ret << ")";
 235         }
 236         return ret.str();
 237 }
 238
 239 string FsmCodeGen::ACT()
 240 {
 241         ostringstream ret;
 242         if ( actExpr == 0 )
 243                 ret << ACCESS() + "act";
 244         else {
 245                 ret << "(";
 246                 INLINE_LIST( ret, actExpr, 0, false, false );
 247                 ret << ")";
 248         }
 249         return ret.str();
 250 }
 251
 252 string FsmCodeGen::TOKSTART()
 253 {
 254         ostringstream ret;
 255         if ( tokstartExpr == 0 )
 256                 ret << ACCESS() + "ts";
 257         else {
 258                 ret << "(";
 259                 INLINE_LIST( ret, tokstartExpr, 0, false, false );
 260                 ret << ")";
 261         }
 262         return ret.str();
 263 }
 264
 265 string FsmCodeGen::TOKEND()
 266 {
 267         ostringstream ret;
 268         if ( tokendExpr == 0 )
 269                 ret << ACCESS() + "te";
 270         else {
 271                 ret << "(";
 272                 INLINE_LIST( ret, tokendExpr, 0, false, false );
 273                 ret << ")";
 274         }
 275         return ret.str();
 276 }
 277
 278 string FsmCodeGen::GET_WIDE_KEY()
 279 {
 280         if ( redFsm->anyConditions() )
 281                 return "_widec";
 282         else
 283                 return GET_KEY();
 284 }
 285
 286 string FsmCodeGen::GET_WIDE_KEY( RedStateAp *state )
 287 {
 288         if ( state->stateCondList.length() > 0 )
 289                 return "_widec";
 290         else
 291                 return GET_KEY();
 292 }
 293
 294 string FsmCodeGen::GET_KEY()
 295 {
 296         ostringstream ret;
 297         if ( getKeyExpr != 0 ) {
 298                 /* Emit the user supplied method of retrieving the key. */
 299                 ret << "(";
 300                 INLINE_LIST( ret, getKeyExpr, 0, false, false );
 301                 ret << ")";
 302         }
 303         else {
 304                 /* Expression for retrieving the key, use simple dereference. */
 305                 ret << "(*" << P() << ")";
 306         }
 307         return ret.str();
 308 }
 309
 310 /* Write out level number of tabs. Makes the nested binary search nice
 311  * looking. */
 312 string FsmCodeGen::TABS( int level )
 313 {
 314         string result;
 315         while ( level-- > 0 )
 316                 result += "\t";
 317         return result;
 318 }
 319
 320 /* Write out a key from the fsm code gen. Depends on wether or not the key is
 321  * signed. */
 322 string FsmCodeGen::KEY( Key key )
 323 {
 324         ostringstream ret;
 325         if ( keyOps->isSigned || !hostLang->explicitUnsigned )
 326                 ret << key.getVal();
 327         else
 328                 ret << (unsigned long) key.getVal() << 'u';
 329         return ret.str();
 330 }
 331
 332 bool FsmCodeGen::isAlphTypeSigned()
 333 {
 334         return keyOps->isSigned;
 335 }
 336
 337 bool FsmCodeGen::isWideAlphTypeSigned()
 338 {
 339         string ret;
 340         if ( redFsm->maxKey <= keyOps->maxKey )
 341                 return isAlphTypeSigned();
 342         else {
 343                 long long maxKeyVal = redFsm->maxKey.getLongLong();
 344                 HostType *wideType = keyOps->typeSubsumes( keyOps->isSigned, maxKeyVal );
 345                 return wideType->isSigned;
 346         }
 347 }
 348
 349 string FsmCodeGen::WIDE_KEY( RedStateAp *state, Key key )
 350 {
 351         if ( state->stateCondList.length() > 0 ) {
 352                 ostringstream ret;
 353                 if ( isWideAlphTypeSigned() )
 354                         ret << key.getVal();
 355                 else
 356                         ret << (unsigned long) key.getVal() << 'u';
 357                 return ret.str();
 358         }
 359         else {
 360                 return KEY( key );
 361         }
 362 }
 363
 364
 365
 366 void FsmCodeGen::EXEC( ostream &ret, GenInlineItem *item, int targState, int inFinish )
 367 {
 368         /* The parser gives fexec two children. The double brackets are for D
 369          * code. If the inline list is a single word it will get interpreted as a
 370          * C-style cast by the D compiler. */
 371         ret << "{" << P() << " = ((";
 372         INLINE_LIST( ret, item->children, targState, inFinish, false );
 373         ret << "))-1;}";
 374 }
 375
 376 void FsmCodeGen::LM_SWITCH( ostream &ret, GenInlineItem *item,
 377                 int targState, int inFinish, bool csForced )
 378 {
 379         ret <<
 380                 "       switch( " << ACT() << " ) {\n";
 381
 382         bool haveDefault = false;
 383         for ( GenInlineList::Iter lma = *item->children; lma.lte(); lma++ ) {
 384                 /* Write the case label, the action and the case break. */
 385                 if ( lma->lmId < 0 ) {
 386                         ret << "        default:\n";
 387                         haveDefault = true;
 388                 }
 389                 else
 390                         ret << "        case " << lma->lmId << ":\n";
 391
 392                 /* Write the block and close it off. */
 393                 ret << "        {";
 394                 INLINE_LIST( ret, lma->children, targState, inFinish, csForced );
 395                 ret << "}\n";
 396
 397                 ret << "        break;\n";
 398         }
 399
 400         if ( (hostLang->lang == HostLang::D || hostLang->lang == HostLang::D2) && !haveDefault )
 401                 ret << "        default: break;";
 402
 403         ret <<
 404                 "       }\n"
 405                 "\t";
 406 }
 407
 408 void FsmCodeGen::SET_ACT( ostream &ret, GenInlineItem *item )
 409 {
 410         ret << ACT() << " = " << item->lmId << ";";
 411 }
 412
 413 void FsmCodeGen::SET_TOKEND( ostream &ret, GenInlineItem *item )
 414 {
 415         /* The tokend action sets tokend. */
 416         ret << TOKEND() << " = " << P();
 417         if ( item->offset != 0 )
 418                 out << "+" << item->offset;
 419         out << ";";
 420 }
 421
 422 void FsmCodeGen::GET_TOKEND( ostream &ret, GenInlineItem *item )
 423 {
 424         ret << TOKEND();
 425 }
 426
 427 void FsmCodeGen::INIT_TOKSTART( ostream &ret, GenInlineItem *item )
 428 {
 429         ret << TOKSTART() << " = " << NULL_ITEM() << ";";
 430 }
 431
 432 void FsmCodeGen::INIT_ACT( ostream &ret, GenInlineItem *item )
 433 {
 434         ret << ACT() << " = 0;";
 435 }
 436
 437 void FsmCodeGen::SET_TOKSTART( ostream &ret, GenInlineItem *item )
 438 {
 439         ret << TOKSTART() << " = " << P() << ";";
 440 }
 441
 442 void FsmCodeGen::SUB_ACTION( ostream &ret, GenInlineItem *item,
 443                 int targState, bool inFinish, bool csForced )
 444 {
 445         if ( item->children->length() > 0 ) {
 446                 /* Write the block and close it off. */
 447                 ret << "{";
 448                 INLINE_LIST( ret, item->children, targState, inFinish, csForced );
 449                 ret << "}";
 450         }
 451 }
 452
 453
 454 /* Write out an inline tree structure. Walks the list and possibly calls out
 455  * to virtual functions than handle language specific items in the tree. */
 456 void FsmCodeGen::INLINE_LIST( ostream &ret, GenInlineList *inlineList,
 457                 int targState, bool inFinish, bool csForced )
 458 {
 459         for ( GenInlineList::Iter item = *inlineList; item.lte(); item++ ) {
 460                 switch ( item->type ) {
 461                 case GenInlineItem::Text:
 462                         ret << item->data;
 463                         break;
 464                 case GenInlineItem::Goto:
 465                         GOTO( ret, item->targState->id, inFinish );
 466                         break;
 467                 case GenInlineItem::Call:
 468                         CALL( ret, item->targState->id, targState, inFinish );
 469                         break;
 470                 case GenInlineItem::Next:
 471                         NEXT( ret, item->targState->id, inFinish );
 472                         break;
 473                 case GenInlineItem::Ret:
 474                         RET( ret, inFinish );
 475                         break;
 476                 case GenInlineItem::PChar:
 477                         ret << P();
 478                         break;
 479                 case GenInlineItem::Char:
 480                         ret << GET_KEY();
 481                         break;
 482                 case GenInlineItem::Hold:
 483                         ret << P() << "--;";
 484                         break;
 485                 case GenInlineItem::Exec:
 486                         EXEC( ret, item, targState, inFinish );
 487                         break;
 488                 case GenInlineItem::Curs:
 489                         CURS( ret, inFinish );
 490                         break;
 491                 case GenInlineItem::Targs:
 492                         TARGS( ret, inFinish, targState );
 493                         break;
 494                 case GenInlineItem::Entry:
 495                         ret << item->targState->id;
 496                         break;
 497                 case GenInlineItem::GotoExpr:
 498                         GOTO_EXPR( ret, item, inFinish );
 499                         break;
 500                 case GenInlineItem::CallExpr:
 501                         CALL_EXPR( ret, item, targState, inFinish );
 502                         break;
 503                 case GenInlineItem::NextExpr:
 504                         NEXT_EXPR( ret, item, inFinish );
 505                         break;
 506                 case GenInlineItem::LmSwitch:
 507                         LM_SWITCH( ret, item, targState, inFinish, csForced );
 508                         break;
 509                 case GenInlineItem::LmSetActId:
 510                         SET_ACT( ret, item );
 511                         break;
 512                 case GenInlineItem::LmSetTokEnd:
 513                         SET_TOKEND( ret, item );
 514                         break;
 515                 case GenInlineItem::LmGetTokEnd:
 516                         GET_TOKEND( ret, item );
 517                         break;
 518                 case GenInlineItem::LmInitTokStart:
 519                         INIT_TOKSTART( ret, item );
 520                         break;
 521                 case GenInlineItem::LmInitAct:
 522                         INIT_ACT( ret, item );
 523                         break;
 524                 case GenInlineItem::LmSetTokStart:
 525                         SET_TOKSTART( ret, item );
 526                         break;
 527                 case GenInlineItem::SubAction:
 528                         SUB_ACTION( ret, item, targState, inFinish, csForced );
 529                         break;
 530                 case GenInlineItem::Break:
 531                         BREAK( ret, targState, csForced );
 532                         break;
 533                 }
 534         }
 535 }
 536 /* Write out paths in line directives. Escapes any special characters. */
 537 string FsmCodeGen::LDIR_PATH( char *path )
 538 {
 539         ostringstream ret;
 540         for ( char *pc = path; *pc != 0; pc++ ) {
 541                 if ( *pc == '\\' )
 542                         ret << "\\\\";
 543                 else
 544                         ret << *pc;
 545         }
 546         return ret.str();
 547 }
 548
 549 void FsmCodeGen::ACTION( ostream &ret, GenAction *action, int targState,
 550                 bool inFinish, bool csForced )
 551 {
 552         /* Write the preprocessor line info for going into the source file. */
 553         cdLineDirective( ret, action->loc.fileName, action->loc.line );
 554
 555         /* Write the block and close it off. */
 556         ret << "\t{";
 557         INLINE_LIST( ret, action->inlineList, targState, inFinish, csForced );
 558         ret << "}\n";
 559 }
 560
 561 void FsmCodeGen::CONDITION( ostream &ret, GenAction *condition )
 562 {
 563         ret << "\n";
 564         cdLineDirective( ret, condition->loc.fileName, condition->loc.line );
 565         INLINE_LIST( ret, condition->inlineList, 0, false, false );
 566 }
 567
 568 string FsmCodeGen::ERROR_STATE()
 569 {
 570         ostringstream ret;
 571         if ( redFsm->errState != 0 )
 572                 ret << redFsm->errState->id;
 573         else
 574                 ret << "-1";
 575         return ret.str();
 576 }
 577
 578 string FsmCodeGen::FIRST_FINAL_STATE()
 579 {
 580         ostringstream ret;
 581         if ( redFsm->firstFinState != 0 )
 582                 ret << redFsm->firstFinState->id;
 583         else
 584                 ret << redFsm->nextStateId;
 585         return ret.str();
 586 }
 587
 588 void FsmCodeGen::writeInit()
 589 {
 590         out << "        {\n";
 591
 592         if ( !noCS )
 593                 out << "\t" << vCS() << " = " << START() << ";\n";
 594
 595         /* If there are any calls, then the stack top needs initialization. */
 596         if ( redFsm->anyActionCalls() || redFsm->anyActionRets() )
 597                 out << "\t" << TOP() << " = 0;\n";
 598
 599         if ( hasLongestMatch ) {
 600                 out <<
 601                         "       " << TOKSTART() << " = " << NULL_ITEM() << ";\n"
 602                         "       " << TOKEND() << " = " << NULL_ITEM() << ";\n"
 603                         "       " << ACT() << " = 0;\n";
 604         }
 605         out << "        }\n";
 606 }
 607
 608 string FsmCodeGen::DATA_PREFIX()
 609 {
 610         if ( !noPrefix )
 611                 return FSM_NAME() + "_";
 612         return "";
 613 }
 614
 615 /* Emit the alphabet data type. */
 616 string FsmCodeGen::ALPH_TYPE()
 617 {
 618         string ret = keyOps->alphType->data1;
 619         if ( keyOps->alphType->data2 != 0 ) {
 620                 ret += " ";
 621                 ret += + keyOps->alphType->data2;
 622         }
 623         return ret;
 624 }
 625
 626 /* Emit the alphabet data type. */
 627 string FsmCodeGen::WIDE_ALPH_TYPE()
 628 {
 629         string ret;
 630         if ( redFsm->maxKey <= keyOps->maxKey )
 631                 ret = ALPH_TYPE();
 632         else {
 633                 long long maxKeyVal = redFsm->maxKey.getLongLong();
 634                 HostType *wideType = keyOps->typeSubsumes( keyOps->isSigned, maxKeyVal );
 635                 assert( wideType != 0 );
 636
 637                 ret = wideType->data1;
 638                 if ( wideType->data2 != 0 ) {
 639                         ret += " ";
 640                         ret += wideType->data2;
 641                 }
 642         }
 643         return ret;
 644 }
 645
 646 void FsmCodeGen::STATE_IDS()
 647 {
 648         if ( redFsm->startState != 0 )
 649                 STATIC_VAR( "int", START() ) << " = " << START_STATE_ID() << ";\n";
 650
 651         if ( !noFinal )
 652                 STATIC_VAR( "int" , FIRST_FINAL() ) << " = " << FIRST_FINAL_STATE() << ";\n";
 653
 654         if ( !noError )
 655                 STATIC_VAR( "int", ERROR() ) << " = " << ERROR_STATE() << ";\n";
 656
 657         out << "\n";
 658
 659         if ( entryPointNames.length() > 0 ) {
 660                 for ( EntryNameVect::Iter en = entryPointNames; en.lte(); en++ ) {
 661                         STATIC_VAR( "int", DATA_PREFIX() + "en_" + *en ) <<
 662                                         " = " << entryPointIds[en.pos()] << ";\n";
 663                 }
 664                 out << "\n";
 665         }
 666 }
 667
 668 void FsmCodeGen::writeStart()
 669 {
 670         out << START_STATE_ID();
 671 }
 672
 673 void FsmCodeGen::writeFirstFinal()
 674 {
 675         out << FIRST_FINAL_STATE();
 676 }
 677
 678 void FsmCodeGen::writeError()
 679 {
 680         out << ERROR_STATE();
 681 }
 682
 683 /*
 684  * Language specific, but style independent code generators functions.
 685  */
 686
 687 string CCodeGen::PTR_CONST()
 688 {
 689         return "const ";
 690 }
 691
 692 string CCodeGen::PTR_CONST_END()
 693 {
 694         return "";
 695 }
 696
 697 std::ostream &CCodeGen::OPEN_ARRAY( string type, string name )
 698 {
 699         out << "static const " << type << " " << name << "[] = {\n";
 700         return out;
 701 }
 702
 703 std::ostream &CCodeGen::CLOSE_ARRAY()
 704 {
 705         return out << "};\n";
 706 }
 707
 708 std::ostream &CCodeGen::STATIC_VAR( string type, string name )
 709 {
 710         out << "static const " << type << " " << name;
 711         return out;
 712 }
 713
 714 string CCodeGen::UINT( )
 715 {
 716         return "unsigned int";
 717 }
 718
 719 string CCodeGen::ARR_OFF( string ptr, string offset )
 720 {
 721         return ptr + " + " + offset;
 722 }
 723
 724 string CCodeGen::CAST( string type )
 725 {
 726         return "(" + type + ")";
 727 }
 728
 729 string CCodeGen::NULL_ITEM()
 730 {
 731         return "0";
 732 }
 733
 734 string CCodeGen::POINTER()
 735 {
 736         return " *";
 737 }
 738
 739 std::ostream &CCodeGen::SWITCH_DEFAULT()
 740 {
 741         return out;
 742 }
 743
 744 string CCodeGen::CTRL_FLOW()
 745 {
 746         return "";
 747 }
 748
 749 void CCodeGen::writeExports()
 750 {
 751         if ( exportList.length() > 0 ) {
 752                 for ( ExportList::Iter ex = exportList; ex.lte(); ex++ ) {
 753                         out << "#define " << DATA_PREFIX() << "ex_" << ex->name << " " <<
 754                                         KEY(ex->key) << "\n";
 755                 }
 756                 out << "\n";
 757         }
 758 }
 759
 760 /*
 761  * D Specific
 762  */
 763
 764 string DCodeGen::NULL_ITEM()
 765 {
 766         return "null";
 767 }
 768
 769 string DCodeGen::POINTER()
 770 {
 771         // multiple items seperated by commas can also be pointer types.
 772         return "* ";
 773 }
 774
 775 string DCodeGen::PTR_CONST()
 776 {
 777         return "";
 778 }
 779
 780 string DCodeGen::PTR_CONST_END()
 781 {
 782         return "";
 783 }
 784
 785 std::ostream &DCodeGen::OPEN_ARRAY( string type, string name )
 786 {
 787         out << "static const " << type << "[] " << name << " = [\n";
 788         return out;
 789 }
 790
 791 std::ostream &DCodeGen::CLOSE_ARRAY()
 792 {
 793         return out << "];\n";
 794 }
 795
 796 std::ostream &DCodeGen::STATIC_VAR( string type, string name )
 797 {
 798         out << "static const " << type << " " << name;
 799         return out;
 800 }
 801
 802 string DCodeGen::ARR_OFF( string ptr, string offset )
 803 {
 804         return "&" + ptr + "[" + offset + "]";
 805 }
 806
 807 string DCodeGen::CAST( string type )
 808 {
 809         return "cast(" + type + ")";
 810 }
 811
 812 string DCodeGen::UINT( )
 813 {
 814         return "uint";
 815 }
 816
 817 std::ostream &DCodeGen::SWITCH_DEFAULT()
 818 {
 819         out << "                default: break;\n";
 820         return out;
 821 }
 822
 823 string DCodeGen::CTRL_FLOW()
 824 {
 825         return "if (true) ";
 826 }
 827
 828 void DCodeGen::writeExports()
 829 {
 830         if ( exportList.length() > 0 ) {
 831                 for ( ExportList::Iter ex = exportList; ex.lte(); ex++ ) {
 832                         out << "static const " << ALPH_TYPE() << " " << DATA_PREFIX() <<
 833                                         "ex_" << ex->name << " = " << KEY(ex->key) << ";\n";
 834                 }
 835                 out << "\n";
 836         }
 837 }
 838
 839 /*
 840  * End D-specific code.
 841  */
 842
 843 /*
 844  * D2 Specific
 845  */
 846
 847 string D2CodeGen::NULL_ITEM()
 848 {
 849         return "null";
 850 }
 851
 852 string D2CodeGen::POINTER()
 853 {
 854         // multiple items seperated by commas can also be pointer types.
 855         return "* ";
 856 }
 857
 858 string D2CodeGen::PTR_CONST()
 859 {
 860         return "const(";
 861 }
 862
 863 string D2CodeGen::PTR_CONST_END()
 864 {
 865         return ")";
 866 }
 867
 868 std::ostream &D2CodeGen::OPEN_ARRAY( string type, string name )
 869 {
 870         out << "enum " << type << "[] " << name << " = [\n";
 871         return out;
 872 }
 873
 874 std::ostream &D2CodeGen::CLOSE_ARRAY()
 875 {
 876         return out << "];\n";
 877 }
 878
 879 std::ostream &D2CodeGen::STATIC_VAR( string type, string name )
 880 {
 881         out << "enum " << type << " " << name;
 882         return out;
 883 }
 884
 885 string D2CodeGen::ARR_OFF( string ptr, string offset )
 886 {
 887         return "&" + ptr + "[" + offset + "]";
 888 }
 889
 890 string D2CodeGen::CAST( string type )
 891 {
 892         return "cast(" + type + ")";
 893 }
 894
 895 string D2CodeGen::UINT( )
 896 {
 897         return "uint";
 898 }
 899
 900 std::ostream &D2CodeGen::SWITCH_DEFAULT()
 901 {
 902         out << "                default: break;\n";
 903         return out;
 904 }
 905
 906 string D2CodeGen::CTRL_FLOW()
 907 {
 908         return "if (true) ";
 909 }
 910
 911 void D2CodeGen::writeExports()
 912 {
 913         if ( exportList.length() > 0 ) {
 914                 for ( ExportList::Iter ex = exportList; ex.lte(); ex++ ) {
 915                         out << "enum " << ALPH_TYPE() << " " << DATA_PREFIX() <<
 916                                         "ex_" << ex->name << " = " << KEY(ex->key) << ";\n";
 917                 }
 918                 out << "\n";
 919         }
 920 }
 921
 922 void D2CodeGen::SUB_ACTION( ostream &ret, GenInlineItem *item,
 923                 int targState, bool inFinish, bool csForced )
 924 {
 925         if ( item->children->length() > 0 ) {
 926                 /* Write the block and close it off. */
 927                 ret << "{{";
 928                 INLINE_LIST( ret, item->children, targState, inFinish, csForced );
 929                 ret << "}}";
 930         }
 931 }
 932
 933 void D2CodeGen::ACTION( ostream &ret, GenAction *action, int targState,
 934                 bool inFinish, bool csForced )
 935 {
 936         /* Write the preprocessor line info for going into the source file. */
 937         cdLineDirective( ret, action->loc.fileName, action->loc.line );
 938
 939         /* Write the block and close it off. */
 940         ret << "\t{{";
 941         INLINE_LIST( ret, action->inlineList, targState, inFinish, csForced );
 942         ret << "}}\n";
 943 }
 944
 945 /*
 946  * End D2-specific code.
 947  */
 948
 949 void FsmCodeGen::finishRagelDef()
 950 {
 951         if ( codeStyle == GenGoto || codeStyle == GenFGoto ||
 952                         codeStyle == GenIpGoto || codeStyle == GenSplit )
 953         {
 954                 /* For directly executable machines there is no required state
 955                  * ordering. Choose a depth-first ordering to increase the
 956                  * potential for fall-throughs. */
 957                 redFsm->depthFirstOrdering();
 958         }
 959         else {
 960                 /* The frontend will do this for us, but it may be a good idea to
 961                  * force it if the intermediate file is edited. */
 962                 redFsm->sortByStateId();
 963         }
 964
 965         /* Choose default transitions and the single transition. */
 966         redFsm->chooseDefaultSpan();
 967
 968         /* Maybe do flat expand, otherwise choose single. */
 969         if ( codeStyle == GenFlat || codeStyle == GenFFlat )
 970                 redFsm->makeFlat();
 971         else
 972                 redFsm->chooseSingle();
 973
 974         /* If any errors have occured in the input file then don't write anything. */
 975         if ( gblErrorCount > 0 )
 976                 return;
 977
 978         if ( codeStyle == GenSplit )
 979                 redFsm->partitionFsm( numSplitPartitions );
 980
 981         if ( codeStyle == GenIpGoto || codeStyle == GenSplit )
 982                 redFsm->setInTrans();
 983
 984         /* Anlayze Machine will find the final action reference counts, among
 985          * other things. We will use these in reporting the usage
 986          * of fsm directives in action code. */
 987         analyzeMachine();
 988
 989         /* Determine if we should use indicies. */
 990         calcIndexSize();
 991 }
 992
 993 ostream &FsmCodeGen::source_warning( const InputLoc &loc )
 994 {
 995         cerr << sourceFileName << ":" << loc.line << ":" << loc.col << ": warning: ";
 996         return cerr;
 997 }
 998
 999 ostream &FsmCodeGen::source_error( const InputLoc &loc )
1000 {
1001         gblErrorCount += 1;
1002         assert( sourceFileName != 0 );
1003         cerr << sourceFileName << ":" << loc.line << ":" << loc.col << ": ";
1004         return cerr;
1005 }
1006