update(add) packaging directory and spec file from OBSTF:Private, OBS
[external/ragel.git] / ragel / javacodegen.cpp
1 /*
2  *  Copyright 2006-2007 Adrian Thurston <thurston@complang.org>
3  *            2007 Colin Fleming <colin.fleming@caverock.com>
4  */
5
6 /*  This file is part of Ragel.
7  *
8  *  Ragel is free software; you can redistribute it and/or modify
9  *  it under the terms of the GNU General Public License as published by
10  *  the Free Software Foundation; either version 2 of the License, or
11  *  (at your option) any later version.
12  * 
13  *  Ragel is distributed in the hope that it will be useful,
14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  *  GNU General Public License for more details.
17  * 
18  *  You should have received a copy of the GNU General Public License
19  *  along with Ragel; if not, write to the Free Software
20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
21  */
22
23 #include "ragel.h"
24 #include "javacodegen.h"
25 #include "redfsm.h"
26 #include "gendata.h"
27 #include <iomanip>
28 #include <sstream>
29
30 /* Integer array line length. */
31 #define IALL 12
32
33 /* Static array initialization item count 
34  * (should be multiple of IALL). */
35 #define SAIIC 8184
36
37 #define _resume    1
38 #define _again     2
39 #define _eof_trans 3
40 #define _test_eof  4
41 #define _out       5
42
43 using std::setw;
44 using std::ios;
45 using std::ostringstream;
46 using std::string;
47 using std::cerr;
48
49 using std::istream;
50 using std::ifstream;
51 using std::ostream;
52 using std::ios;
53 using std::cin;
54 using std::cout;
55 using std::cerr;
56 using std::endl;
57
58 void javaLineDirective( ostream &out, const char *fileName, int line )
59 {
60         /* Write the preprocessor line info for to the input file. */
61         out << "// line " << line  << " \"";
62         for ( const char *pc = fileName; *pc != 0; pc++ ) {
63                 if ( *pc == '\\' )
64                         out << "\\\\";
65                 else
66                         out << *pc;
67         }
68         out << "\"\n";
69 }
70
71 void JavaTabCodeGen::genLineDirective( ostream &out )
72 {
73         std::streambuf *sbuf = out.rdbuf();
74         output_filter *filter = static_cast<output_filter*>(sbuf);
75         javaLineDirective( out, filter->fileName, filter->line + 1 );
76 }
77
78 void JavaTabCodeGen::GOTO( ostream &ret, int gotoDest, bool inFinish )
79 {
80         ret << "{" << vCS() << " = " << gotoDest << "; _goto_targ = " << _again << "; " << 
81                         CTRL_FLOW() << "continue _goto;}";
82 }
83
84 void JavaTabCodeGen::GOTO_EXPR( ostream &ret, GenInlineItem *ilItem, bool inFinish )
85 {
86         ret << "{" << vCS() << " = (";
87         INLINE_LIST( ret, ilItem->children, 0, inFinish );
88         ret << "); _goto_targ = " << _again << "; " << CTRL_FLOW() << "continue _goto;}";
89 }
90
91 void JavaTabCodeGen::CALL( ostream &ret, int callDest, int targState, bool inFinish )
92 {
93         if ( prePushExpr != 0 ) {
94                 ret << "{";
95                 INLINE_LIST( ret, prePushExpr, 0, false );
96         }
97
98         ret << "{" << STACK() << "[" << TOP() << "++] = " << vCS() << "; " << vCS() << " = " << 
99                         callDest << "; _goto_targ = " << _again << "; " << CTRL_FLOW() << "continue _goto;}";
100
101         if ( prePushExpr != 0 )
102                 ret << "}";
103 }
104
105 void JavaTabCodeGen::CALL_EXPR( ostream &ret, GenInlineItem *ilItem, int targState, bool inFinish )
106 {
107         if ( prePushExpr != 0 ) {
108                 ret << "{";
109                 INLINE_LIST( ret, prePushExpr, 0, false );
110         }
111
112         ret << "{" << STACK() << "[" << TOP() << "++] = " << vCS() << "; " << vCS() << " = (";
113         INLINE_LIST( ret, ilItem->children, targState, inFinish );
114         ret << "); _goto_targ = " << _again << "; " << CTRL_FLOW() << "continue _goto;}";
115
116         if ( prePushExpr != 0 )
117                 ret << "}";
118 }
119
120 void JavaTabCodeGen::RET( ostream &ret, bool inFinish )
121 {
122         ret << "{" << vCS() << " = " << STACK() << "[--" << TOP() << "];";
123
124         if ( postPopExpr != 0 ) {
125                 ret << "{";
126                 INLINE_LIST( ret, postPopExpr, 0, false );
127                 ret << "}";
128         }
129
130         ret << "_goto_targ = " << _again << "; " << CTRL_FLOW() << "continue _goto;}";
131 }
132
133 void JavaTabCodeGen::BREAK( ostream &ret, int targState )
134 {
135         ret << "{ " << P() << " += 1; _goto_targ = " << _out << "; " << 
136                         CTRL_FLOW() << " continue _goto;}";
137 }
138
139 void JavaTabCodeGen::NEXT( ostream &ret, int nextDest, bool inFinish )
140 {
141         ret << vCS() << " = " << nextDest << ";";
142 }
143
144 void JavaTabCodeGen::NEXT_EXPR( ostream &ret, GenInlineItem *ilItem, bool inFinish )
145 {
146         ret << vCS() << " = (";
147         INLINE_LIST( ret, ilItem->children, 0, inFinish );
148         ret << ");";
149 }
150
151 void JavaTabCodeGen::EXEC( ostream &ret, GenInlineItem *item, int targState, int inFinish )
152 {
153         /* The parser gives fexec two children. The double brackets are for D
154          * code. If the inline list is a single word it will get interpreted as a
155          * C-style cast by the D compiler. */
156         ret << "{" << P() << " = ((";
157         INLINE_LIST( ret, item->children, targState, inFinish );
158         ret << "))-1;}";
159 }
160
161 /* Write out an inline tree structure. Walks the list and possibly calls out
162  * to virtual functions than handle language specific items in the tree. */
163 void JavaTabCodeGen::INLINE_LIST( ostream &ret, GenInlineList *inlineList, 
164                 int targState, bool inFinish )
165 {
166         for ( GenInlineList::Iter item = *inlineList; item.lte(); item++ ) {
167                 switch ( item->type ) {
168                 case GenInlineItem::Text:
169                         ret << item->data;
170                         break;
171                 case GenInlineItem::Goto:
172                         GOTO( ret, item->targState->id, inFinish );
173                         break;
174                 case GenInlineItem::Call:
175                         CALL( ret, item->targState->id, targState, inFinish );
176                         break;
177                 case GenInlineItem::Next:
178                         NEXT( ret, item->targState->id, inFinish );
179                         break;
180                 case GenInlineItem::Ret:
181                         RET( ret, inFinish );
182                         break;
183                 case GenInlineItem::PChar:
184                         ret << P();
185                         break;
186                 case GenInlineItem::Char:
187                         ret << GET_KEY();
188                         break;
189                 case GenInlineItem::Hold:
190                         ret << P() << "--;";
191                         break;
192                 case GenInlineItem::Exec:
193                         EXEC( ret, item, targState, inFinish );
194                         break;
195                 case GenInlineItem::Curs:
196                         ret << "(_ps)";
197                         break;
198                 case GenInlineItem::Targs:
199                         ret << "(" << vCS() << ")";
200                         break;
201                 case GenInlineItem::Entry:
202                         ret << item->targState->id;
203                         break;
204                 case GenInlineItem::GotoExpr:
205                         GOTO_EXPR( ret, item, inFinish );
206                         break;
207                 case GenInlineItem::CallExpr:
208                         CALL_EXPR( ret, item, targState, inFinish );
209                         break;
210                 case GenInlineItem::NextExpr:
211                         NEXT_EXPR( ret, item, inFinish );
212                         break;
213                 case GenInlineItem::LmSwitch:
214                         LM_SWITCH( ret, item, targState, inFinish );
215                         break;
216                 case GenInlineItem::LmSetActId:
217                         SET_ACT( ret, item );
218                         break;
219                 case GenInlineItem::LmSetTokEnd:
220                         SET_TOKEND( ret, item );
221                         break;
222                 case GenInlineItem::LmGetTokEnd:
223                         GET_TOKEND( ret, item );
224                         break;
225                 case GenInlineItem::LmInitTokStart:
226                         INIT_TOKSTART( ret, item );
227                         break;
228                 case GenInlineItem::LmInitAct:
229                         INIT_ACT( ret, item );
230                         break;
231                 case GenInlineItem::LmSetTokStart:
232                         SET_TOKSTART( ret, item );
233                         break;
234                 case GenInlineItem::SubAction:
235                         SUB_ACTION( ret, item, targState, inFinish );
236                         break;
237                 case GenInlineItem::Break:
238                         BREAK( ret, targState );
239                         break;
240                 }
241         }
242 }
243
244 string JavaTabCodeGen::DATA_PREFIX()
245 {
246         if ( !noPrefix )
247                 return FSM_NAME() + "_";
248         return "";
249 }
250
251 /* Emit the alphabet data type. */
252 string JavaTabCodeGen::ALPH_TYPE()
253 {
254         string ret = keyOps->alphType->data1;
255         if ( keyOps->alphType->data2 != 0 ) {
256                 ret += " ";
257                 ret += + keyOps->alphType->data2;
258         }
259         return ret;
260 }
261
262 /* Emit the alphabet data type. */
263 string JavaTabCodeGen::WIDE_ALPH_TYPE()
264 {
265         string ret;
266         if ( redFsm->maxKey <= keyOps->maxKey )
267                 ret = ALPH_TYPE();
268         else {
269                 long long maxKeyVal = redFsm->maxKey.getLongLong();
270                 HostType *wideType = keyOps->typeSubsumes( keyOps->isSigned, maxKeyVal );
271                 assert( wideType != 0 );
272
273                 ret = wideType->data1;
274                 if ( wideType->data2 != 0 ) {
275                         ret += " ";
276                         ret += wideType->data2;
277                 }
278         }
279         return ret;
280 }
281
282
283
284 void JavaTabCodeGen::COND_TRANSLATE()
285 {
286         out << 
287                 "       _widec = " << GET_KEY() << ";\n"
288                 "       _keys = " << CO() << "[" << vCS() << "]*2\n;"
289                 "       _klen = " << CL() << "[" << vCS() << "];\n"
290                 "       if ( _klen > 0 ) {\n"
291                 "               int _lower = _keys\n;"
292                 "               int _mid;\n"
293                 "               int _upper = _keys + (_klen<<1) - 2;\n"
294                 "               while (true) {\n"
295                 "                       if ( _upper < _lower )\n"
296                 "                               break;\n"
297                 "\n"
298                 "                       _mid = _lower + (((_upper-_lower) >> 1) & ~1);\n"
299                 "                       if ( " << GET_WIDE_KEY() << " < " << CK() << "[_mid] )\n"
300                 "                               _upper = _mid - 2;\n"
301                 "                       else if ( " << GET_WIDE_KEY() << " > " << CK() << "[_mid+1] )\n"
302                 "                               _lower = _mid + 2;\n"
303                 "                       else {\n"
304                 "                               switch ( " << C() << "[" << CO() << "[" << vCS() << "]"
305                                                         " + ((_mid - _keys)>>1)] ) {\n"
306                 ;
307
308         for ( CondSpaceList::Iter csi = condSpaceList; csi.lte(); csi++ ) {
309                 GenCondSpace *condSpace = csi;
310                 out << "        case " << condSpace->condSpaceId << ": {\n";
311                 out << TABS(2) << "_widec = " << KEY(condSpace->baseKey) << 
312                                 " + (" << GET_KEY() << " - " << KEY(keyOps->minKey) << ");\n";
313
314                 for ( GenCondSet::Iter csi = condSpace->condSet; csi.lte(); csi++ ) {
315                         out << TABS(2) << "if ( ";
316                         CONDITION( out, *csi );
317                         Size condValOffset = ((1 << csi.pos()) * keyOps->alphSize());
318                         out << " ) _widec += " << condValOffset << ";\n";
319                 }
320
321                 out << 
322                         "               break;\n"
323                         "       }\n";
324         }
325
326         out << 
327                 "                               }\n"
328                 "                               break;\n"
329                 "                       }\n"
330                 "               }\n"
331                 "       }\n"
332                 "\n";
333 }
334
335
336 void JavaTabCodeGen::LOCATE_TRANS()
337 {
338         out <<
339                 "       _match: do {\n"
340                 "       _keys = " << KO() << "[" << vCS() << "]" << ";\n"
341                 "       _trans = " << IO() << "[" << vCS() << "];\n"
342                 "       _klen = " << SL() << "[" << vCS() << "];\n"
343                 "       if ( _klen > 0 ) {\n"
344                 "               int _lower = _keys;\n"
345                 "               int _mid;\n"
346                 "               int _upper = _keys + _klen - 1;\n"
347                 "               while (true) {\n"
348                 "                       if ( _upper < _lower )\n"
349                 "                               break;\n"
350                 "\n"
351                 "                       _mid = _lower + ((_upper-_lower) >> 1);\n"
352                 "                       if ( " << GET_WIDE_KEY() << " < " << K() << "[_mid] )\n"
353                 "                               _upper = _mid - 1;\n"
354                 "                       else if ( " << GET_WIDE_KEY() << " > " << K() << "[_mid] )\n"
355                 "                               _lower = _mid + 1;\n"
356                 "                       else {\n"
357                 "                               _trans += (_mid - _keys);\n"
358                 "                               break _match;\n"
359                 "                       }\n"
360                 "               }\n"
361                 "               _keys += _klen;\n"
362                 "               _trans += _klen;\n"
363                 "       }\n"
364                 "\n"
365                 "       _klen = " << RL() << "[" << vCS() << "];\n"
366                 "       if ( _klen > 0 ) {\n"
367                 "               int _lower = _keys;\n"
368                 "               int _mid;\n"
369                 "               int _upper = _keys + (_klen<<1) - 2;\n"
370                 "               while (true) {\n"
371                 "                       if ( _upper < _lower )\n"
372                 "                               break;\n"
373                 "\n"
374                 "                       _mid = _lower + (((_upper-_lower) >> 1) & ~1);\n"
375                 "                       if ( " << GET_WIDE_KEY() << " < " << K() << "[_mid] )\n"
376                 "                               _upper = _mid - 2;\n"
377                 "                       else if ( " << GET_WIDE_KEY() << " > " << K() << "[_mid+1] )\n"
378                 "                               _lower = _mid + 2;\n"
379                 "                       else {\n"
380                 "                               _trans += ((_mid - _keys)>>1);\n"
381                 "                               break _match;\n"
382                 "                       }\n"
383                 "               }\n"
384                 "               _trans += _klen;\n"
385                 "       }\n"
386                 "       } while (false);\n"
387                 "\n";
388 }
389
390 /* Determine if we should use indicies or not. */
391 void JavaTabCodeGen::calcIndexSize()
392 {
393         int sizeWithInds = 0, sizeWithoutInds = 0;
394
395         /* Calculate cost of using with indicies. */
396         for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
397                 int totalIndex = st->outSingle.length() + st->outRange.length() + 
398                                 (st->defTrans == 0 ? 0 : 1);
399                 sizeWithInds += arrayTypeSize(redFsm->maxIndex) * totalIndex;
400         }
401         sizeWithInds += arrayTypeSize(redFsm->maxState) * redFsm->transSet.length();
402         if ( redFsm->anyActions() )
403                 sizeWithInds += arrayTypeSize(redFsm->maxActionLoc) * redFsm->transSet.length();
404
405         /* Calculate the cost of not using indicies. */
406         for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
407                 int totalIndex = st->outSingle.length() + st->outRange.length() + 
408                                 (st->defTrans == 0 ? 0 : 1);
409                 sizeWithoutInds += arrayTypeSize(redFsm->maxState) * totalIndex;
410                 if ( redFsm->anyActions() )
411                         sizeWithoutInds += arrayTypeSize(redFsm->maxActionLoc) * totalIndex;
412         }
413
414         /* If using indicies reduces the size, use them. */
415         useIndicies = sizeWithInds < sizeWithoutInds;
416 }
417
418 int JavaTabCodeGen::TO_STATE_ACTION( RedStateAp *state )
419 {
420         int act = 0;
421         if ( state->toStateAction != 0 )
422                 act = state->toStateAction->location+1;
423         return act;
424 }
425
426 int JavaTabCodeGen::FROM_STATE_ACTION( RedStateAp *state )
427 {
428         int act = 0;
429         if ( state->fromStateAction != 0 )
430                 act = state->fromStateAction->location+1;
431         return act;
432 }
433
434 int JavaTabCodeGen::EOF_ACTION( RedStateAp *state )
435 {
436         int act = 0;
437         if ( state->eofAction != 0 )
438                 act = state->eofAction->location+1;
439         return act;
440 }
441
442
443 int JavaTabCodeGen::TRANS_ACTION( RedTransAp *trans )
444 {
445         /* If there are actions, emit them. Otherwise emit zero. */
446         int act = 0;
447         if ( trans->action != 0 )
448                 act = trans->action->location+1;
449         return act;
450 }
451
452 std::ostream &JavaTabCodeGen::TO_STATE_ACTION_SWITCH()
453 {
454         /* Walk the list of functions, printing the cases. */
455         for ( GenActionList::Iter act = actionList; act.lte(); act++ ) {
456                 /* Write out referenced actions. */
457                 if ( act->numToStateRefs > 0 ) {
458                         /* Write the case label, the action and the case break. */
459                         out << "\tcase " << act->actionId << ":\n";
460                         ACTION( out, act, 0, false );
461                         out << "\tbreak;\n";
462                 }
463         }
464
465         genLineDirective( out );
466         return out;
467 }
468
469 std::ostream &JavaTabCodeGen::FROM_STATE_ACTION_SWITCH()
470 {
471         /* Walk the list of functions, printing the cases. */
472         for ( GenActionList::Iter act = actionList; act.lte(); act++ ) {
473                 /* Write out referenced actions. */
474                 if ( act->numFromStateRefs > 0 ) {
475                         /* Write the case label, the action and the case break. */
476                         out << "\tcase " << act->actionId << ":\n";
477                         ACTION( out, act, 0, false );
478                         out << "\tbreak;\n";
479                 }
480         }
481
482         genLineDirective( out );
483         return out;
484 }
485
486 std::ostream &JavaTabCodeGen::EOF_ACTION_SWITCH()
487 {
488         /* Walk the list of functions, printing the cases. */
489         for ( GenActionList::Iter act = actionList; act.lte(); act++ ) {
490                 /* Write out referenced actions. */
491                 if ( act->numEofRefs > 0 ) {
492                         /* Write the case label, the action and the case break. */
493                         out << "\tcase " << act->actionId << ":\n";
494                         ACTION( out, act, 0, true );
495                         out << "\tbreak;\n";
496                 }
497         }
498
499         genLineDirective( out );
500         return out;
501 }
502
503
504 std::ostream &JavaTabCodeGen::ACTION_SWITCH()
505 {
506         /* Walk the list of functions, printing the cases. */
507         for ( GenActionList::Iter act = actionList; act.lte(); act++ ) {
508                 /* Write out referenced actions. */
509                 if ( act->numTransRefs > 0 ) {
510                         /* Write the case label, the action and the case break. */
511                         out << "\tcase " << act->actionId << ":\n";
512                         ACTION( out, act, 0, false );
513                         out << "\tbreak;\n";
514                 }
515         }
516
517         genLineDirective( out );
518         return out;
519 }
520
521 std::ostream &JavaTabCodeGen::COND_OFFSETS()
522 {
523         int curKeyOffset = 0;
524         for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
525                 /* Write the key offset. */
526                 ARRAY_ITEM( INT(curKeyOffset), st.last() );
527
528                 /* Move the key offset ahead. */
529                 curKeyOffset += st->stateCondList.length();
530         }
531         return out;
532 }
533
534 std::ostream &JavaTabCodeGen::KEY_OFFSETS()
535 {
536         int curKeyOffset = 0;
537         for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
538                 /* Write the key offset. */
539                 ARRAY_ITEM( INT(curKeyOffset), st.last() );
540
541                 /* Move the key offset ahead. */
542                 curKeyOffset += st->outSingle.length() + st->outRange.length()*2;
543         }
544         return out;
545 }
546
547
548 std::ostream &JavaTabCodeGen::INDEX_OFFSETS()
549 {
550         int curIndOffset = 0;
551         for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
552                 /* Write the index offset. */
553                 ARRAY_ITEM( INT(curIndOffset), st.last() );
554
555                 /* Move the index offset ahead. */
556                 curIndOffset += st->outSingle.length() + st->outRange.length();
557                 if ( st->defTrans != 0 )
558                         curIndOffset += 1;
559         }
560         return out;
561 }
562
563 std::ostream &JavaTabCodeGen::COND_LENS()
564 {
565         for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
566                 /* Write singles length. */
567                 ARRAY_ITEM( INT(st->stateCondList.length()), st.last() );
568         }
569         return out;
570 }
571
572
573 std::ostream &JavaTabCodeGen::SINGLE_LENS()
574 {
575         for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
576                 /* Write singles length. */
577                 ARRAY_ITEM( INT(st->outSingle.length()), st.last() );
578         }
579         return out;
580 }
581
582 std::ostream &JavaTabCodeGen::RANGE_LENS()
583 {
584         for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
585                 /* Emit length of range index. */
586                 ARRAY_ITEM( INT(st->outRange.length()), st.last() );
587         }
588         return out;
589 }
590
591 std::ostream &JavaTabCodeGen::TO_STATE_ACTIONS()
592 {
593         for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
594                 /* Write any eof action. */
595                 ARRAY_ITEM( INT(TO_STATE_ACTION(st)), st.last() );
596         }
597         return out;
598 }
599
600 std::ostream &JavaTabCodeGen::FROM_STATE_ACTIONS()
601 {
602         for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
603                 /* Write any eof action. */
604                 ARRAY_ITEM( INT(FROM_STATE_ACTION(st)), st.last() );
605         }
606         return out;
607 }
608
609 std::ostream &JavaTabCodeGen::EOF_ACTIONS()
610 {
611         for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
612                 /* Write any eof action. */
613                 ARRAY_ITEM( INT(EOF_ACTION(st)), st.last() );
614         }
615         return out;
616 }
617
618 std::ostream &JavaTabCodeGen::EOF_TRANS()
619 {
620         for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
621                 /* Write any eof action. */
622                 long trans = 0;
623                 if ( st->eofTrans != 0 ) {
624                         assert( st->eofTrans->pos >= 0 );
625                         trans = st->eofTrans->pos+1;
626                 }
627
628                 /* Write any eof action. */
629                 ARRAY_ITEM( INT(trans), st.last() );
630         }
631         return out;
632 }
633
634
635 std::ostream &JavaTabCodeGen::COND_KEYS()
636 {
637         for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
638                 /* Loop the state's transitions. */
639                 for ( GenStateCondList::Iter sc = st->stateCondList; sc.lte(); sc++ ) {
640                         /* Lower key. */
641                         ARRAY_ITEM( KEY( sc->lowKey ), false );
642                         ARRAY_ITEM( KEY( sc->highKey ), false );
643                 }
644         }
645
646         /* Output one last number so we don't have to figure out when the last
647          * entry is and avoid writing a comma. */
648         ARRAY_ITEM( INT(0), true );
649         return out;
650 }
651
652 std::ostream &JavaTabCodeGen::COND_SPACES()
653 {
654         for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
655                 /* Loop the state's transitions. */
656                 for ( GenStateCondList::Iter sc = st->stateCondList; sc.lte(); sc++ ) {
657                         /* Cond Space id. */
658                         ARRAY_ITEM( KEY( sc->condSpace->condSpaceId ), false );
659                 }
660         }
661
662         /* Output one last number so we don't have to figure out when the last
663          * entry is and avoid writing a comma. */
664         ARRAY_ITEM( INT(0), true );
665         return out;
666 }
667
668 std::ostream &JavaTabCodeGen::KEYS()
669 {
670         for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
671                 /* Loop the singles. */
672                 for ( RedTransList::Iter stel = st->outSingle; stel.lte(); stel++ ) {
673                         ARRAY_ITEM( KEY( stel->lowKey ), false );
674                 }
675
676                 /* Loop the state's transitions. */
677                 for ( RedTransList::Iter rtel = st->outRange; rtel.lte(); rtel++ ) {
678                         /* Lower key. */
679                         ARRAY_ITEM( KEY( rtel->lowKey ), false );
680
681                         /* Upper key. */
682                         ARRAY_ITEM( KEY( rtel->highKey ), false );
683                 }
684         }
685
686         /* Output one last number so we don't have to figure out when the last
687          * entry is and avoid writing a comma. */
688         ARRAY_ITEM( INT(0), true );
689         return out;
690 }
691
692 std::ostream &JavaTabCodeGen::INDICIES()
693 {
694         for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
695                 /* Walk the singles. */
696                 for ( RedTransList::Iter stel = st->outSingle; stel.lte(); stel++ ) {
697                         ARRAY_ITEM( KEY( stel->value->id ), false );
698                 }
699
700                 /* Walk the ranges. */
701                 for ( RedTransList::Iter rtel = st->outRange; rtel.lte(); rtel++ ) {
702                         ARRAY_ITEM( KEY( rtel->value->id ), false );
703                 }
704
705                 /* The state's default index goes next. */
706                 if ( st->defTrans != 0 ) {
707                         ARRAY_ITEM( KEY( st->defTrans->id ), false );
708                 }
709         }
710
711         /* Output one last number so we don't have to figure out when the last
712          * entry is and avoid writing a comma. */
713         ARRAY_ITEM( INT(0), true );
714         return out;
715 }
716
717 std::ostream &JavaTabCodeGen::TRANS_TARGS()
718 {
719         int totalTrans = 0;
720         for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
721                 /* Walk the singles. */
722                 for ( RedTransList::Iter stel = st->outSingle; stel.lte(); stel++ ) {
723                         RedTransAp *trans = stel->value;
724                         ARRAY_ITEM( KEY( trans->targ->id ), false );
725                         totalTrans++;
726                 }
727
728                 /* Walk the ranges. */
729                 for ( RedTransList::Iter rtel = st->outRange; rtel.lte(); rtel++ ) {
730                         RedTransAp *trans = rtel->value;
731                         ARRAY_ITEM( KEY( trans->targ->id ), false );
732                         totalTrans++;
733                 }
734
735                 /* The state's default target state. */
736                 if ( st->defTrans != 0 ) {
737                         RedTransAp *trans = st->defTrans;
738                         ARRAY_ITEM( KEY( trans->targ->id ), false );
739                         totalTrans++;
740                 }
741         }
742
743         for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
744                 if ( st->eofTrans != 0 ) {
745                         RedTransAp *trans = st->eofTrans;
746                         trans->pos = totalTrans++;
747                         ARRAY_ITEM( KEY( trans->targ->id ), false );
748                 }
749         }
750
751         /* Output one last number so we don't have to figure out when the last
752          * entry is and avoid writing a comma. */
753         ARRAY_ITEM( INT(0), true );
754         return out;
755 }
756
757
758 std::ostream &JavaTabCodeGen::TRANS_ACTIONS()
759 {
760         for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
761                 /* Walk the singles. */
762                 for ( RedTransList::Iter stel = st->outSingle; stel.lte(); stel++ ) {
763                         RedTransAp *trans = stel->value;
764                         ARRAY_ITEM( INT(TRANS_ACTION( trans )), false );
765                 }
766
767                 /* Walk the ranges. */
768                 for ( RedTransList::Iter rtel = st->outRange; rtel.lte(); rtel++ ) {
769                         RedTransAp *trans = rtel->value;
770                         ARRAY_ITEM( INT(TRANS_ACTION( trans )), false );
771                 }
772
773                 /* The state's default index goes next. */
774                 if ( st->defTrans != 0 ) {
775                         RedTransAp *trans = st->defTrans;
776                         ARRAY_ITEM( INT(TRANS_ACTION( trans )), false );
777                 }
778         }
779
780         for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
781                 if ( st->eofTrans != 0 ) {
782                         RedTransAp *trans = st->eofTrans;
783                         ARRAY_ITEM( INT(TRANS_ACTION( trans )), false );
784                 }
785         }
786
787         /* Output one last number so we don't have to figure out when the last
788          * entry is and avoid writing a comma. */
789         ARRAY_ITEM( INT(0), true );
790         return out;
791 }
792
793 std::ostream &JavaTabCodeGen::TRANS_TARGS_WI()
794 {
795         /* Transitions must be written ordered by their id. */
796         RedTransAp **transPtrs = new RedTransAp*[redFsm->transSet.length()];
797         for ( TransApSet::Iter trans = redFsm->transSet; trans.lte(); trans++ )
798                 transPtrs[trans->id] = trans;
799
800         /* Keep a count of the num of items in the array written. */
801         for ( int t = 0; t < redFsm->transSet.length(); t++ ) {
802                 /* Save the position. Needed for eofTargs. */
803                 RedTransAp *trans = transPtrs[t];
804                 trans->pos = t;
805
806                 /* Write out the target state. */
807                 ARRAY_ITEM( INT(trans->targ->id), ( t >= redFsm->transSet.length()-1 ) );
808         }
809         delete[] transPtrs;
810         return out;
811 }
812
813
814 std::ostream &JavaTabCodeGen::TRANS_ACTIONS_WI()
815 {
816         /* Transitions must be written ordered by their id. */
817         RedTransAp **transPtrs = new RedTransAp*[redFsm->transSet.length()];
818         for ( TransApSet::Iter trans = redFsm->transSet; trans.lte(); trans++ )
819                 transPtrs[trans->id] = trans;
820
821         /* Keep a count of the num of items in the array written. */
822         for ( int t = 0; t < redFsm->transSet.length(); t++ ) {
823                 /* Write the function for the transition. */
824                 RedTransAp *trans = transPtrs[t];
825                 ARRAY_ITEM( INT(TRANS_ACTION( trans )), ( t >= redFsm->transSet.length()-1 ) );
826         }
827         delete[] transPtrs;
828         return out;
829 }
830
831 void JavaTabCodeGen::writeExports()
832 {
833         if ( exportList.length() > 0 ) {
834                 for ( ExportList::Iter ex = exportList; ex.lte(); ex++ ) {
835                         STATIC_VAR( ALPH_TYPE(), DATA_PREFIX() + "ex_" + ex->name ) 
836                                         << " = " << KEY(ex->key) << ";\n";
837                 }
838                 out << "\n";
839         }
840 }
841
842 void JavaTabCodeGen::writeStart()
843 {
844         out << START_STATE_ID();
845 }
846
847 void JavaTabCodeGen::writeFirstFinal()
848 {
849         out << FIRST_FINAL_STATE();
850 }
851
852 void JavaTabCodeGen::writeError()
853 {
854         out << ERROR_STATE();
855 }
856
857 void JavaTabCodeGen::writeData()
858 {
859         /* If there are any transtion functions then output the array. If there
860          * are none, don't bother emitting an empty array that won't be used. */
861         if ( redFsm->anyActions() ) {
862                 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActArrItem), A() );
863                 ACTIONS_ARRAY();
864                 CLOSE_ARRAY() <<
865                 "\n";
866         }
867
868         if ( redFsm->anyConditions() ) {
869                 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxCondOffset), CO() );
870                 COND_OFFSETS();
871                 CLOSE_ARRAY() <<
872                 "\n";
873
874                 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxCondLen), CL() );
875                 COND_LENS();
876                 CLOSE_ARRAY() <<
877                 "\n";
878
879                 OPEN_ARRAY( WIDE_ALPH_TYPE(), CK() );
880                 COND_KEYS();
881                 CLOSE_ARRAY() <<
882                 "\n";
883
884                 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxCondSpaceId), C() );
885                 COND_SPACES();
886                 CLOSE_ARRAY() <<
887                 "\n";
888         }
889
890         OPEN_ARRAY( ARRAY_TYPE(redFsm->maxKeyOffset), KO() );
891         KEY_OFFSETS();
892         CLOSE_ARRAY() <<
893         "\n";
894
895         OPEN_ARRAY( WIDE_ALPH_TYPE(), K() );
896         KEYS();
897         CLOSE_ARRAY() <<
898         "\n";
899
900         OPEN_ARRAY( ARRAY_TYPE(redFsm->maxSingleLen), SL() );
901         SINGLE_LENS();
902         CLOSE_ARRAY() <<
903         "\n";
904
905         OPEN_ARRAY( ARRAY_TYPE(redFsm->maxRangeLen), RL() );
906         RANGE_LENS();
907         CLOSE_ARRAY() <<
908         "\n";
909
910         OPEN_ARRAY( ARRAY_TYPE(redFsm->maxIndexOffset), IO() );
911         INDEX_OFFSETS();
912         CLOSE_ARRAY() <<
913         "\n";
914
915         if ( useIndicies ) {
916                 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxIndex), I() );
917                 INDICIES();
918                 CLOSE_ARRAY() <<
919                 "\n";
920
921                 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxState), TT() );
922                 TRANS_TARGS_WI();
923                 CLOSE_ARRAY() <<
924                 "\n";
925
926                 if ( redFsm->anyActions() ) {
927                         OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), TA() );
928                         TRANS_ACTIONS_WI();
929                         CLOSE_ARRAY() <<
930                         "\n";
931                 }
932         }
933         else {
934                 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxState), TT() );
935                 TRANS_TARGS();
936                 CLOSE_ARRAY() <<
937                 "\n";
938
939                 if ( redFsm->anyActions() ) {
940                         OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), TA() );
941                         TRANS_ACTIONS();
942                         CLOSE_ARRAY() <<
943                         "\n";
944                 }
945         }
946
947         if ( redFsm->anyToStateActions() ) {
948                 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), TSA() );
949                 TO_STATE_ACTIONS();
950                 CLOSE_ARRAY() <<
951                 "\n";
952         }
953
954         if ( redFsm->anyFromStateActions() ) {
955                 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), FSA() );
956                 FROM_STATE_ACTIONS();
957                 CLOSE_ARRAY() <<
958                 "\n";
959         }
960
961         if ( redFsm->anyEofActions() ) {
962                 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), EA() );
963                 EOF_ACTIONS();
964                 CLOSE_ARRAY() <<
965                 "\n";
966         }
967
968         if ( redFsm->anyEofTrans() ) {
969                 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxIndexOffset+1), ET() );
970                 EOF_TRANS();
971                 CLOSE_ARRAY() <<
972                 "\n";
973         }
974
975         if ( redFsm->startState != 0 )
976                 STATIC_VAR( "int", START() ) << " = " << START_STATE_ID() << ";\n";
977
978         if ( !noFinal )
979                 STATIC_VAR( "int" , FIRST_FINAL() ) << " = " << FIRST_FINAL_STATE() << ";\n";
980
981         if ( !noError )
982                 STATIC_VAR( "int", ERROR() ) << " = " << ERROR_STATE() << ";\n";
983         
984         out << "\n";
985
986         if ( entryPointNames.length() > 0 ) {
987                 for ( EntryNameVect::Iter en = entryPointNames; en.lte(); en++ ) {
988                         STATIC_VAR( "int", DATA_PREFIX() + "en_" + *en ) << 
989                                         " = " << entryPointIds[en.pos()] << ";\n";
990                 }
991                 out << "\n";
992         }
993 }
994
995 void JavaTabCodeGen::writeExec()
996 {
997         out <<
998                 "       {\n"
999                 "       int _klen";
1000
1001         if ( redFsm->anyRegCurStateRef() )
1002                 out << ", _ps";
1003
1004         out << 
1005                 ";\n"
1006                 "       int _trans = 0;\n";
1007
1008         if ( redFsm->anyConditions() )
1009                 out << "        int _widec;\n";
1010
1011         if ( redFsm->anyToStateActions() || redFsm->anyRegActions() || 
1012                         redFsm->anyFromStateActions() )
1013         {
1014                 out << 
1015                         "       int _acts;\n"
1016                         "       int _nacts;\n";
1017         }
1018
1019         out <<
1020                 "       int _keys;\n"
1021                 "       int _goto_targ = 0;\n"
1022                 "\n";
1023         
1024         out <<
1025                 "       _goto: while (true) {\n"
1026                 "       switch ( _goto_targ ) {\n"
1027                 "       case 0:\n";
1028
1029         if ( !noEnd ) {
1030                 out << 
1031                         "       if ( " << P() << " == " << PE() << " ) {\n"
1032                         "               _goto_targ = " << _test_eof << ";\n"
1033                         "               continue _goto;\n"
1034                         "       }\n";
1035         }
1036
1037         if ( redFsm->errState != 0 ) {
1038                 out << 
1039                         "       if ( " << vCS() << " == " << redFsm->errState->id << " ) {\n"
1040                         "               _goto_targ = " << _out << ";\n"
1041                         "               continue _goto;\n"
1042                         "       }\n";
1043         }
1044
1045         out << "case " << _resume << ":\n"; 
1046
1047         if ( redFsm->anyFromStateActions() ) {
1048                 out <<
1049                         "       _acts = " << FSA() << "[" << vCS() << "]" << ";\n"
1050                         "       _nacts = " << CAST("int") << " " << A() << "[_acts++];\n"
1051                         "       while ( _nacts-- > 0 ) {\n"
1052                         "               switch ( " << A() << "[_acts++] ) {\n";
1053                         FROM_STATE_ACTION_SWITCH() <<
1054                         "               }\n"
1055                         "       }\n"
1056                         "\n";
1057         }
1058
1059         if ( redFsm->anyConditions() )
1060                 COND_TRANSLATE();
1061
1062         LOCATE_TRANS();
1063
1064         if ( useIndicies )
1065                 out << "        _trans = " << I() << "[_trans];\n";
1066         
1067         if ( redFsm->anyEofTrans() )
1068                 out << "case " << _eof_trans << ":\n";
1069
1070         if ( redFsm->anyRegCurStateRef() )
1071                 out << "        _ps = " << vCS() << ";\n";
1072
1073         out <<
1074                 "       " << vCS() << " = " << TT() << "[_trans];\n"
1075                 "\n";
1076
1077         if ( redFsm->anyRegActions() ) {
1078                 out <<
1079                         "       if ( " << TA() << "[_trans] != 0 ) {\n"
1080                         "               _acts = " <<  TA() << "[_trans]" << ";\n"
1081                         "               _nacts = " << CAST("int") << " " <<  A() << "[_acts++];\n"
1082                         "               while ( _nacts-- > 0 )\n        {\n"
1083                         "                       switch ( " << A() << "[_acts++] )\n"
1084                         "                       {\n";
1085                         ACTION_SWITCH() <<
1086                         "                       }\n"
1087                         "               }\n"
1088                         "       }\n"
1089                         "\n";
1090         }
1091
1092         out << "case " << _again << ":\n";
1093
1094         if ( redFsm->anyToStateActions() ) {
1095                 out <<
1096                         "       _acts = " << TSA() << "[" << vCS() << "]" << ";\n"
1097                         "       _nacts = " << CAST("int") << " " << A() << "[_acts++];\n"
1098                         "       while ( _nacts-- > 0 ) {\n"
1099                         "               switch ( " << A() << "[_acts++] ) {\n";
1100                         TO_STATE_ACTION_SWITCH() <<
1101                         "               }\n"
1102                         "       }\n"
1103                         "\n";
1104         }
1105
1106         if ( redFsm->errState != 0 ) {
1107                 out << 
1108                         "       if ( " << vCS() << " == " << redFsm->errState->id << " ) {\n"
1109                         "               _goto_targ = " << _out << ";\n"
1110                         "               continue _goto;\n"
1111                         "       }\n";
1112         }
1113
1114         if ( !noEnd ) {
1115                 out << 
1116                         "       if ( ++" << P() << " != " << PE() << " ) {\n"
1117                         "               _goto_targ = " << _resume << ";\n"
1118                         "               continue _goto;\n"
1119                         "       }\n";
1120         }
1121         else {
1122                 out << 
1123                         "       " << P() << " += 1;\n"
1124                         "       _goto_targ = " << _resume << ";\n"
1125                         "       continue _goto;\n";
1126         }
1127
1128         out << "case " << _test_eof << ":\n"; 
1129
1130         if ( redFsm->anyEofTrans() || redFsm->anyEofActions() ) {
1131                 out <<
1132                         "       if ( " << P() << " == " << vEOF() << " )\n"
1133                         "       {\n";
1134
1135                 if ( redFsm->anyEofTrans() ) {
1136                         out <<
1137                                 "       if ( " << ET() << "[" << vCS() << "] > 0 ) {\n"
1138                                 "               _trans = " << ET() << "[" << vCS() << "] - 1;\n"
1139                                 "               _goto_targ = " << _eof_trans << ";\n"
1140                                 "               continue _goto;\n"
1141                                 "       }\n";
1142                 }
1143
1144                 if ( redFsm->anyEofActions() ) {
1145                         out <<
1146                                 "       int __acts = " << EA() << "[" << vCS() << "]" << ";\n"
1147                                 "       int __nacts = " << CAST("int") << " " << A() << "[__acts++];\n"
1148                                 "       while ( __nacts-- > 0 ) {\n"
1149                                 "               switch ( " << A() << "[__acts++] ) {\n";
1150                                 EOF_ACTION_SWITCH() <<
1151                                 "               }\n"
1152                                 "       }\n";
1153                 }
1154
1155                 out <<
1156                         "       }\n"
1157                         "\n";
1158         }
1159
1160         out << "case " << _out << ":\n"; 
1161
1162         /* The switch and goto loop. */
1163         out << "        }\n";
1164         out << "        break; }\n";
1165
1166         /* The execute block. */
1167         out << "        }\n";
1168 }
1169
1170 std::ostream &JavaTabCodeGen::OPEN_ARRAY( string type, string name )
1171 {
1172         array_type = type;
1173         array_name = name;
1174         item_count = 0;
1175         div_count = 1;
1176
1177         out <<  "private static " << type << "[] init_" << name << "_0()\n"
1178                 "{\n\t"
1179                 "return new " << type << " [] {\n\t";
1180         return out;
1181 }
1182
1183 std::ostream &JavaTabCodeGen::ARRAY_ITEM( string item, bool last )
1184 {
1185         item_count++;
1186
1187         out << setw(5) << setiosflags(ios::right) << item;
1188         
1189         if ( !last ) {
1190                 if ( item_count % SAIIC == 0 ) {
1191                         out << "\n\t};\n};\n"
1192                                 "private static "<< array_type << "[] init_" << 
1193                                 array_name << "_" << div_count << "()\n"
1194                                 "{\n\t"
1195                                 "return new " << array_type << " [] {\n\t";
1196                         div_count++;
1197                 } else if (item_count % IALL == 0) { 
1198                         out << ",\n\t";
1199                 } else {
1200                         out << ",";
1201                 }
1202         }
1203         return out;
1204 }
1205
1206 std::ostream &JavaTabCodeGen::CLOSE_ARRAY()
1207 {
1208         out << "\n\t};\n}\n\n";
1209
1210         if (item_count < SAIIC) {
1211                 out << "private static final " << array_type << " " << array_name << 
1212                         "[] = init_" << array_name << "_0();\n\n";
1213         } else {
1214                 out << "private static final " << array_type << " [] combine_" << array_name
1215                         << "() {\n\t"
1216                         << array_type << " [] combined = new " << array_type << 
1217                         " [ " << item_count << " ];\n\t";
1218                 int block = 0;
1219                 int full_blocks = item_count / SAIIC;
1220                 for (;block < full_blocks; ++block) {
1221                         out << "System.arraycopy ( init_" << array_name << "_" << block << 
1222                                 "(), 0, combined, " << SAIIC * block << ", " << SAIIC << " );\n\t";
1223                 }
1224                 if ( (item_count % SAIIC) > 0 ) {
1225                         out << "System.arraycopy ( init_" << array_name << "_" << block << 
1226                                 "(), 0, combined, " << SAIIC * block << ", " << 
1227                                 (item_count % SAIIC) << " );\n\t";
1228                 }
1229                 out << "return combined;\n}\n";
1230                 out << "private static final " << array_type << " [] " << array_name << 
1231                         " = combine_" << array_name << "();";
1232         }
1233         return out;
1234 }
1235
1236
1237 std::ostream &JavaTabCodeGen::STATIC_VAR( string type, string name )
1238 {
1239         out << "static final " << type << " " << name;
1240         return out;
1241 }
1242
1243 string JavaTabCodeGen::ARR_OFF( string ptr, string offset )
1244 {
1245         return ptr + " + " + offset;
1246 }
1247
1248 string JavaTabCodeGen::CAST( string type )
1249 {
1250         return "(" + type + ")";
1251 }
1252
1253 string JavaTabCodeGen::NULL_ITEM()
1254 {
1255         /* In java we use integers instead of pointers. */
1256         return "-1";
1257 }
1258
1259 string JavaTabCodeGen::GET_KEY()
1260 {
1261         ostringstream ret;
1262         if ( getKeyExpr != 0 ) { 
1263                 /* Emit the user supplied method of retrieving the key. */
1264                 ret << "(";
1265                 INLINE_LIST( ret, getKeyExpr, 0, false );
1266                 ret << ")";
1267         }
1268         else {
1269                 /* Expression for retrieving the key, use simple dereference. */
1270                 ret << DATA() << "[" << P() << "]";
1271         }
1272         return ret.str();
1273 }
1274
1275 string JavaTabCodeGen::CTRL_FLOW()
1276 {
1277         return "if (true) ";
1278 }
1279
1280 unsigned int JavaTabCodeGen::arrayTypeSize( unsigned long maxVal )
1281 {
1282         long long maxValLL = (long long) maxVal;
1283         HostType *arrayType = keyOps->typeSubsumes( maxValLL );
1284         assert( arrayType != 0 );
1285         return arrayType->size;
1286 }
1287
1288 string JavaTabCodeGen::ARRAY_TYPE( unsigned long maxVal )
1289 {
1290         long long maxValLL = (long long) maxVal;
1291         HostType *arrayType = keyOps->typeSubsumes( maxValLL );
1292         assert( arrayType != 0 );
1293
1294         string ret = arrayType->data1;
1295         if ( arrayType->data2 != 0 ) {
1296                 ret += " ";
1297                 ret += arrayType->data2;
1298         }
1299         return ret;
1300 }
1301
1302
1303 /* Write out the fsm name. */
1304 string JavaTabCodeGen::FSM_NAME()
1305 {
1306         return fsmName;
1307 }
1308
1309 /* Emit the offset of the start state as a decimal integer. */
1310 string JavaTabCodeGen::START_STATE_ID()
1311 {
1312         ostringstream ret;
1313         ret << redFsm->startState->id;
1314         return ret.str();
1315 };
1316
1317 /* Write out the array of actions. */
1318 std::ostream &JavaTabCodeGen::ACTIONS_ARRAY()
1319 {
1320         ARRAY_ITEM( INT(0), false );
1321         for ( GenActionTableMap::Iter act = redFsm->actionMap; act.lte(); act++ ) {
1322                 /* Write out the length, which will never be the last character. */
1323                 ARRAY_ITEM( INT(act->key.length()), false );
1324
1325                 for ( GenActionTable::Iter item = act->key; item.lte(); item++ )
1326                         ARRAY_ITEM( INT(item->value->actionId), (act.last() && item.last()) );
1327         }
1328         return out;
1329 }
1330
1331
1332 string JavaTabCodeGen::ACCESS()
1333 {
1334         ostringstream ret;
1335         if ( accessExpr != 0 )
1336                 INLINE_LIST( ret, accessExpr, 0, false );
1337         return ret.str();
1338 }
1339
1340 string JavaTabCodeGen::P()
1341
1342         ostringstream ret;
1343         if ( pExpr == 0 )
1344                 ret << "p";
1345         else {
1346                 ret << "(";
1347                 INLINE_LIST( ret, pExpr, 0, false );
1348                 ret << ")";
1349         }
1350         return ret.str();
1351 }
1352
1353 string JavaTabCodeGen::PE()
1354 {
1355         ostringstream ret;
1356         if ( peExpr == 0 )
1357                 ret << "pe";
1358         else {
1359                 ret << "(";
1360                 INLINE_LIST( ret, peExpr, 0, false );
1361                 ret << ")";
1362         }
1363         return ret.str();
1364 }
1365
1366 string JavaTabCodeGen::vEOF()
1367 {
1368         ostringstream ret;
1369         if ( eofExpr == 0 )
1370                 ret << "eof";
1371         else {
1372                 ret << "(";
1373                 INLINE_LIST( ret, eofExpr, 0, false );
1374                 ret << ")";
1375         }
1376         return ret.str();
1377 }
1378
1379 string JavaTabCodeGen::vCS()
1380 {
1381         ostringstream ret;
1382         if ( csExpr == 0 )
1383                 ret << ACCESS() << "cs";
1384         else {
1385                 /* Emit the user supplied method of retrieving the key. */
1386                 ret << "(";
1387                 INLINE_LIST( ret, csExpr, 0, false );
1388                 ret << ")";
1389         }
1390         return ret.str();
1391 }
1392
1393 string JavaTabCodeGen::TOP()
1394 {
1395         ostringstream ret;
1396         if ( topExpr == 0 )
1397                 ret << ACCESS() + "top";
1398         else {
1399                 ret << "(";
1400                 INLINE_LIST( ret, topExpr, 0, false );
1401                 ret << ")";
1402         }
1403         return ret.str();
1404 }
1405
1406 string JavaTabCodeGen::STACK()
1407 {
1408         ostringstream ret;
1409         if ( stackExpr == 0 )
1410                 ret << ACCESS() + "stack";
1411         else {
1412                 ret << "(";
1413                 INLINE_LIST( ret, stackExpr, 0, false );
1414                 ret << ")";
1415         }
1416         return ret.str();
1417 }
1418
1419 string JavaTabCodeGen::ACT()
1420 {
1421         ostringstream ret;
1422         if ( actExpr == 0 )
1423                 ret << ACCESS() + "act";
1424         else {
1425                 ret << "(";
1426                 INLINE_LIST( ret, actExpr, 0, false );
1427                 ret << ")";
1428         }
1429         return ret.str();
1430 }
1431
1432 string JavaTabCodeGen::TOKSTART()
1433 {
1434         ostringstream ret;
1435         if ( tokstartExpr == 0 )
1436                 ret << ACCESS() + "ts";
1437         else {
1438                 ret << "(";
1439                 INLINE_LIST( ret, tokstartExpr, 0, false );
1440                 ret << ")";
1441         }
1442         return ret.str();
1443 }
1444
1445 string JavaTabCodeGen::TOKEND()
1446 {
1447         ostringstream ret;
1448         if ( tokendExpr == 0 )
1449                 ret << ACCESS() + "te";
1450         else {
1451                 ret << "(";
1452                 INLINE_LIST( ret, tokendExpr, 0, false );
1453                 ret << ")";
1454         }
1455         return ret.str();
1456 }
1457
1458 string JavaTabCodeGen::DATA()
1459 {
1460         ostringstream ret;
1461         if ( dataExpr == 0 )
1462                 ret << ACCESS() + "data";
1463         else {
1464                 ret << "(";
1465                 INLINE_LIST( ret, dataExpr, 0, false );
1466                 ret << ")";
1467         }
1468         return ret.str();
1469 }
1470
1471
1472 string JavaTabCodeGen::GET_WIDE_KEY()
1473 {
1474         if ( redFsm->anyConditions() ) 
1475                 return "_widec";
1476         else
1477                 return GET_KEY();
1478 }
1479
1480 string JavaTabCodeGen::GET_WIDE_KEY( RedStateAp *state )
1481 {
1482         if ( state->stateCondList.length() > 0 )
1483                 return "_widec";
1484         else
1485                 return GET_KEY();
1486 }
1487
1488 /* Write out level number of tabs. Makes the nested binary search nice
1489  * looking. */
1490 string JavaTabCodeGen::TABS( int level )
1491 {
1492         string result;
1493         while ( level-- > 0 )
1494                 result += "\t";
1495         return result;
1496 }
1497
1498 string JavaTabCodeGen::KEY( Key key )
1499 {
1500         ostringstream ret;
1501         if ( keyOps->isSigned || !hostLang->explicitUnsigned )
1502                 ret << key.getVal();
1503         else
1504                 ret << (unsigned long) key.getVal();
1505         return ret.str();
1506 }
1507
1508 string JavaTabCodeGen::INT( int i )
1509 {
1510         ostringstream ret;
1511         ret << i;
1512         return ret.str();
1513 }
1514
1515 void JavaTabCodeGen::LM_SWITCH( ostream &ret, GenInlineItem *item, 
1516                 int targState, int inFinish )
1517 {
1518         ret << 
1519                 "       switch( " << ACT() << " ) {\n";
1520
1521         for ( GenInlineList::Iter lma = *item->children; lma.lte(); lma++ ) {
1522                 /* Write the case label, the action and the case break. */
1523                 if ( lma->lmId < 0 )
1524                         ret << "        default:\n";
1525                 else
1526                         ret << "        case " << lma->lmId << ":\n";
1527
1528                 /* Write the block and close it off. */
1529                 ret << "        {";
1530                 INLINE_LIST( ret, lma->children, targState, inFinish );
1531                 ret << "}\n";
1532
1533                 ret << "        break;\n";
1534         }
1535
1536         ret << 
1537                 "       }\n"
1538                 "\t";
1539 }
1540
1541 void JavaTabCodeGen::SET_ACT( ostream &ret, GenInlineItem *item )
1542 {
1543         ret << ACT() << " = " << item->lmId << ";";
1544 }
1545
1546 void JavaTabCodeGen::SET_TOKEND( ostream &ret, GenInlineItem *item )
1547 {
1548         /* The tokend action sets tokend. */
1549         ret << TOKEND() << " = " << P();
1550         if ( item->offset != 0 ) 
1551                 out << "+" << item->offset;
1552         out << ";";
1553 }
1554
1555 void JavaTabCodeGen::GET_TOKEND( ostream &ret, GenInlineItem *item )
1556 {
1557         ret << TOKEND();
1558 }
1559
1560 void JavaTabCodeGen::INIT_TOKSTART( ostream &ret, GenInlineItem *item )
1561 {
1562         ret << TOKSTART() << " = " << NULL_ITEM() << ";";
1563 }
1564
1565 void JavaTabCodeGen::INIT_ACT( ostream &ret, GenInlineItem *item )
1566 {
1567         ret << ACT() << " = 0;";
1568 }
1569
1570 void JavaTabCodeGen::SET_TOKSTART( ostream &ret, GenInlineItem *item )
1571 {
1572         ret << TOKSTART() << " = " << P() << ";";
1573 }
1574
1575 void JavaTabCodeGen::SUB_ACTION( ostream &ret, GenInlineItem *item, 
1576                 int targState, bool inFinish )
1577 {
1578         if ( item->children->length() > 0 ) {
1579                 /* Write the block and close it off. */
1580                 ret << "{";
1581                 INLINE_LIST( ret, item->children, targState, inFinish );
1582                 ret << "}";
1583         }
1584 }
1585
1586 void JavaTabCodeGen::ACTION( ostream &ret, GenAction *action, int targState, bool inFinish )
1587 {
1588         /* Write the preprocessor line info for going into the source file. */
1589         javaLineDirective( ret, action->loc.fileName, action->loc.line );
1590
1591         /* Write the block and close it off. */
1592         ret << "\t{";
1593         INLINE_LIST( ret, action->inlineList, targState, inFinish );
1594         ret << "}\n";
1595 }
1596
1597 void JavaTabCodeGen::CONDITION( ostream &ret, GenAction *condition )
1598 {
1599         ret << "\n";
1600         javaLineDirective( ret, condition->loc.fileName, condition->loc.line );
1601         INLINE_LIST( ret, condition->inlineList, 0, false );
1602 }
1603
1604 string JavaTabCodeGen::ERROR_STATE()
1605 {
1606         ostringstream ret;
1607         if ( redFsm->errState != 0 )
1608                 ret << redFsm->errState->id;
1609         else
1610                 ret << "-1";
1611         return ret.str();
1612 }
1613
1614 string JavaTabCodeGen::FIRST_FINAL_STATE()
1615 {
1616         ostringstream ret;
1617         if ( redFsm->firstFinState != 0 )
1618                 ret << redFsm->firstFinState->id;
1619         else
1620                 ret << redFsm->nextStateId;
1621         return ret.str();
1622 }
1623
1624 void JavaTabCodeGen::writeInit()
1625 {
1626         out << "        {\n";
1627
1628         if ( !noCS )
1629                 out << "\t" << vCS() << " = " << START() << ";\n";
1630         
1631         /* If there are any calls, then the stack top needs initialization. */
1632         if ( redFsm->anyActionCalls() || redFsm->anyActionRets() )
1633                 out << "\t" << TOP() << " = 0;\n";
1634
1635         if ( hasLongestMatch ) {
1636                 out << 
1637                         "       " << TOKSTART() << " = " << NULL_ITEM() << ";\n"
1638                         "       " << TOKEND() << " = " << NULL_ITEM() << ";\n"
1639                         "       " << ACT() << " = 0;\n";
1640         }
1641         out << "        }\n";
1642 }
1643
1644 void JavaTabCodeGen::finishRagelDef()
1645 {
1646         /* The frontend will do this for us, but it may be a good idea to force it
1647          * if the intermediate file is edited. */
1648         redFsm->sortByStateId();
1649
1650         /* Choose default transitions and the single transition. */
1651         redFsm->chooseDefaultSpan();
1652                 
1653         /* Maybe do flat expand, otherwise choose single. */
1654         redFsm->chooseSingle();
1655
1656         /* If any errors have occured in the input file then don't write anything. */
1657         if ( gblErrorCount > 0 )
1658                 return;
1659         
1660         /* Anlayze Machine will find the final action reference counts, among
1661          * other things. We will use these in reporting the usage
1662          * of fsm directives in action code. */
1663         analyzeMachine();
1664
1665         /* Determine if we should use indicies. */
1666         calcIndexSize();
1667 }
1668
1669 ostream &JavaTabCodeGen::source_warning( const InputLoc &loc )
1670 {
1671         cerr << sourceFileName << ":" << loc.line << ":" << loc.col << ": warning: ";
1672         return cerr;
1673 }
1674
1675 ostream &JavaTabCodeGen::source_error( const InputLoc &loc )
1676 {
1677         gblErrorCount += 1;
1678         assert( sourceFileName != 0 );
1679         cerr << sourceFileName << ":" << loc.line << ":" << loc.col << ": ";
1680         return cerr;
1681 }
1682
1683