?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Edits to chapter four.
[ragel.git] / rlgen-ruby / ruby-ftabcodegen.cpp
blobf841e4952f656329b17b2e7e635e787dae18acc9
1 /*
2 * 2007 Victor Hugo Borja <vic@rubyforge.org>
3 * Copyright 2001-2007 Adrian Thurston <thurston@cs.queensu.ca>
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 <iomanip>
24 #include <sstream>
25 #include "redfsm.h"
26 #include "gendata.h"
27 #include "rlgen-ruby.h"
28 #include "ruby-ftabcodegen.h"
29
30 using std::ostream;
31 using std::ostringstream;
32 using std::string;
33 using std::cerr;
34 using std::endl;
35
36 void RubyFTabCodeGen::GOTO( ostream &out, int gotoDest, bool inFinish )
37 {
38 out <<
39 " begin\n"
40 " " << CS() << " = " << gotoDest << "\n"
41 " _goto_level = _again\n"
42 " next\n"
43 " end\n";
44 }
45
46 void RubyFTabCodeGen::GOTO_EXPR( ostream &out, InlineItem *ilItem, bool inFinish )
47 {
48 out <<
49 " begin\n"
50 " " << CS() << " = (";
51 INLINE_LIST( out, ilItem->children, 0, inFinish );
52 out << ")\n";
53 out <<
54 " _goto_level = _again\n"
55 " next\n"
56 " end\n";
57 }
58
59 void RubyFTabCodeGen::CALL( ostream &out, int callDest, int targState, bool inFinish )
60 {
61 if ( prePushExpr != 0 ) {
62 out << "begin\n";
63 INLINE_LIST( out, prePushExpr, 0, false );
64 }
65
66 out <<
67 " begin\n"
68 " " << STACK() << "[" << TOP() << "] = " << CS() << "\n"
69 " " << TOP() << "+= 1\n"
70 " " << CS() << " = " << callDest << "\n"
71 " _goto_level = _again\n"
72 " next\n"
73 " end\n";
74
75 if ( prePushExpr != 0 )
76 out << "end\n";
77 }
78
79 void RubyFTabCodeGen::CALL_EXPR(ostream &out, InlineItem *ilItem,
80 int targState, bool inFinish )
81 {
82 if ( prePushExpr != 0 ) {
83 out << "begin\n";
84 INLINE_LIST( out, prePushExpr, 0, false );
85 }
86
87 out <<
88 " begin\n"
89 " " << STACK() << "[" << TOP() << "] = " << CS() << "\n"
90 " " << TOP() << " += 1\n"
91 " " << CS() << " = (";
92 INLINE_LIST( out, ilItem->children, targState, inFinish );
93 out << ")\n";
94
95 out <<
96 " _goto_level = _again\n"
97 " next\n"
98 " end\n";
99
100 if ( prePushExpr != 0 )
101 out << "end\n";
102 }
103
104 void RubyFTabCodeGen::RET( ostream &out, bool inFinish )
105 {
106 out <<
107 " begin\n"
108 " " << TOP() << " -= 1\n"
109 " " << CS() << " = " << STACK() << "[" << TOP() << "]\n";
110
111 if ( postPopExpr != 0 ) {
112 out << "begin\n";
113 INLINE_LIST( out, postPopExpr, 0, false );
114 out << "end\n";
115 }
116
117 out <<
118 " _goto_level = _again\n"
119 " next\n"
120 " end\n";
121 }
122
123 void RubyFTabCodeGen::BREAK( ostream &out, int targState )
124 {
125 out <<
126 " begin\n"
127 " _goto_level = _out\n"
128 " next\n"
129 " end\n";
130 }
131
132
133 std::ostream &RubyFTabCodeGen::TO_STATE_ACTION_SWITCH()
134 {
135 /* Loop the actions. */
136 for ( ActionTableMap::Iter redAct = redFsm->actionMap; redAct.lte(); redAct++ ) {
137 if ( redAct->numToStateRefs > 0 ) {
138 /* Write the entry label. */
139 out << "\twhen " << redAct->actListId+1 << " then\n";
140
141 /* Write each action in the list of action items. */
142 for ( ActionTable::Iter item = redAct->key; item.lte(); item++ )
143 ACTION( out, item->value, 0, false );
144
145 }
146 }
147
148 genLineDirective( out );
149 return out;
150 }
151
152 /* Write out the function switch. This switch is keyed on the values
153 * of the func index. */
154 std::ostream &RubyFTabCodeGen::FROM_STATE_ACTION_SWITCH()
155 {
156 /* Loop the actions. */
157 for ( ActionTableMap::Iter redAct = redFsm->actionMap; redAct.lte(); redAct++ ) {
158 if ( redAct->numFromStateRefs > 0 ) {
159 /* Write the entry label. */
160 out << "\twhen " << redAct->actListId+1 << " then\n";
161
162 /* Write each action in the list of action items. */
163 for ( ActionTable::Iter item = redAct->key; item.lte(); item++ )
164 ACTION( out, item->value, 0, false );
165
166 }
167 }
168
169 genLineDirective( out );
170 return out;
171 }
172
173 std::ostream &RubyFTabCodeGen::EOF_ACTION_SWITCH()
174 {
175 /* Loop the actions. */
176 for ( ActionTableMap::Iter redAct = redFsm->actionMap; redAct.lte(); redAct++ ) {
177 if ( redAct->numEofRefs > 0 ) {
178 /* Write the entry label. */
179 out << "\twhen " << redAct->actListId+1 << " then\n";
180
181 /* Write each action in the list of action items. */
182 for ( ActionTable::Iter item = redAct->key; item.lte(); item++ )
183 ACTION( out, item->value, 0, true );
184
185 }
186 }
187
188 genLineDirective( out );
189 return out;
190 }
191
192 /* Write out the function switch. This switch is keyed on the values
193 * of the func index. */
194 std::ostream &RubyFTabCodeGen::ACTION_SWITCH()
195 {
196 /* Loop the actions. */
197 for ( ActionTableMap::Iter redAct = redFsm->actionMap; redAct.lte(); redAct++ ) {
198 if ( redAct->numTransRefs > 0 ) {
199 /* Write the entry label. */
200 out << "\twhen " << redAct->actListId+1 << " then\n";
201
202 /* Write each action in the list of action items. */
203 for ( ActionTable::Iter item = redAct->key; item.lte(); item++ )
204 ACTION( out, item->value, 0, false );
205
206 }
207 }
208
209 genLineDirective( out );
210 return out;
211 }
212
213
214 int RubyFTabCodeGen::TO_STATE_ACTION( RedStateAp *state )
215 {
216 int act = 0;
217 if ( state->toStateAction != 0 )
218 act = state->toStateAction->actListId+1;
219 return act;
220 }
221
222 int RubyFTabCodeGen::FROM_STATE_ACTION( RedStateAp *state )
223 {
224 int act = 0;
225 if ( state->fromStateAction != 0 )
226 act = state->fromStateAction->actListId+1;
227 return act;
228 }
229
230 int RubyFTabCodeGen::EOF_ACTION( RedStateAp *state )
231 {
232 int act = 0;
233 if ( state->eofAction != 0 )
234 act = state->eofAction->actListId+1;
235 return act;
236 }
237
238
239 /* Write out the function for a transition. */
240 int RubyFTabCodeGen::TRANS_ACTION( RedTransAp *trans )
241 {
242 int action = 0;
243 if ( trans->action != 0 )
244 action = trans->action->actListId+1;
245 return action;
246 }
247
248 void RubyFTabCodeGen::writeData()
249 {
250
251 if ( redFsm->anyConditions() ) {
252 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxCondOffset), CO() );
253 COND_OFFSETS();
254 CLOSE_ARRAY() <<
255 "\n";
256
257 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxCondLen), CL() );
258 COND_LENS();
259 CLOSE_ARRAY() <<
260 "\n";
261
262 OPEN_ARRAY( WIDE_ALPH_TYPE(), CK() );
263 COND_KEYS();
264 CLOSE_ARRAY() <<
265 "\n";
266
267 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxCondSpaceId), C() );
268 COND_SPACES();
269 CLOSE_ARRAY() <<
270 "\n";
271 }
272
273 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxKeyOffset), KO() );
274 KEY_OFFSETS();
275 CLOSE_ARRAY() <<
276 "\n";
277
278 OPEN_ARRAY( WIDE_ALPH_TYPE(), K() );
279 KEYS();
280 CLOSE_ARRAY() <<
281 "\n";
282
283 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxSingleLen), SL() );
284 SINGLE_LENS();
285 CLOSE_ARRAY() <<
286 "\n";
287
288 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxRangeLen), RL() );
289 RANGE_LENS();
290 CLOSE_ARRAY() <<
291 "\n";
292
293 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxIndexOffset), IO() );
294 INDEX_OFFSETS();
295 CLOSE_ARRAY() <<
296 "\n";
297
298 if ( useIndicies ) {
299 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxIndex), I() );
300 INDICIES();
301 CLOSE_ARRAY() <<
302 "\n";
303
304 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxState), TT() );
305 TRANS_TARGS_WI();
306 CLOSE_ARRAY() <<
307 "\n";
308
309 if ( redFsm->anyActions() ) {
310 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActListId), TA() );
311 TRANS_ACTIONS_WI();
312 CLOSE_ARRAY() <<
313 "\n";
314 }
315 }
316 else {
317 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxState), TT() );
318 TRANS_TARGS();
319 CLOSE_ARRAY() <<
320 "\n";
321
322 if ( redFsm->anyActions() ) {
323 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActListId), TA() );
324 TRANS_ACTIONS();
325 CLOSE_ARRAY() <<
326 "\n";
327 }
328 }
329
330 if ( redFsm->anyToStateActions() ) {
331 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), TSA() );
332 TO_STATE_ACTIONS();
333 CLOSE_ARRAY() <<
334 "\n";
335 }
336
337 if ( redFsm->anyFromStateActions() ) {
338 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), FSA() );
339 FROM_STATE_ACTIONS();
340 CLOSE_ARRAY() <<
341 "\n";
342 }
343
344 if ( redFsm->anyEofActions() ) {
345 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActListId), EA() );
346 EOF_ACTIONS();
347 CLOSE_ARRAY() <<
348 "\n";
349 }
350
351 if ( redFsm->anyEofTrans() ) {
352 OPEN_ARRAY( ARRAY_TYPE(redFsm->maxIndex+1), ET() );
353 EOF_TRANS();
354 CLOSE_ARRAY() <<
355 "\n";
356 }
357
358 STATE_IDS();
359 }
360
361 void RubyFTabCodeGen::writeExec()
362 {
363 out <<
364 "begin\n"
365 " testEof = false\n"
366 " _klen, _trans, _keys";
367
368 if ( redFsm->anyRegCurStateRef() )
369 out << ", _ps";
370
371 if ( redFsm->anyConditions() )
372 out << ", _widec";
373
374 out << " = nil\n";
375
376 out <<
377 " _goto_level = 0\n"
378 " _resume = 10\n"
379 " _eof_trans = 15\n"
380 " _again = 20\n"
381 " _test_eof = 30\n"
382 " _out = 40\n";
383
384 out <<
385 " while true\n"
386 " if _goto_level <= 0\n";
387
388 if ( hasEnd ) {
389 out <<
390 " if " << P() << " == " << PE() << "\n"
391 " _goto_level = _test_eof\n"
392 " next\n"
393 " end\n";
394 }
395
396 if ( redFsm->errState != 0 ) {
397 out <<
398 " if " << CS() << " == " << redFsm->errState->id << "\n"
399 " _goto_level = _out\n"
400 " next\n"
401 " end\n";
402 }
403
404 /* The resume label. */
405 out <<
406 " end\n"
407 " if _goto_level <= _resume\n";
408
409 if ( redFsm->anyFromStateActions() ) {
410 out <<
411 " case " << FSA() << "[" << CS() << "] \n";
412 FROM_STATE_ACTION_SWITCH() <<
413 " end # from state action switch \n"
414 "\n";
415 }
416
417 if ( redFsm->anyConditions() )
418 COND_TRANSLATE();
419
420 LOCATE_TRANS();
421
422 if ( useIndicies )
423 out << " _trans = " << I() << "[_trans];\n";
424
425 if ( redFsm->anyEofTrans() ) {
426 out <<
427 " end\n"
428 " if _goto_level <= _eof_trans\n";
429 }
430
431 if ( redFsm->anyRegCurStateRef() )
432 out << " _ps = " << CS() << ";\n";
433
434 out <<
435 " " << CS() << " = " << TT() << "[_trans];\n"
436 "\n";
437
438 if ( redFsm->anyRegActions() ) {
439 out <<
440 " if " << TA() << "[_trans] != 0\n"
441 "\n"
442 " case " << TA() << "[_trans] \n";
443 ACTION_SWITCH() <<
444 " end # action switch \n"
445 " end\n"
446 "\n";
447 }
448
449 /* The again label. */
450 out <<
451 " end\n"
452 " if _goto_level <= _again\n";
453
454 if ( redFsm->anyToStateActions() ) {
455 out <<
456 " case " << TSA() << "[" << CS() << "] \n";
457 TO_STATE_ACTION_SWITCH() <<
458 " end\n"
459 "\n";
460 }
461
462 if ( redFsm->errState != 0 ) {
463 out <<
464 " if " << CS() << " == " << redFsm->errState->id << "\n"
465 " _goto_level = _out\n"
466 " next\n"
467 " end\n";
468 }
469
470 out << " " << P() << " += 1\n";
471
472 if ( hasEnd ) {
473 out <<
474 " if " << P() << " != " << PE() << "\n"
475 " _goto_level = _resume\n"
476 " next\n"
477 " end\n";
478 }
479 else {
480 out <<
481 " _goto_level = _resume\n"
482 " next\n";
483 }
484
485 /* The test eof label. */
486 out <<
487 " end\n"
488 " if _goto_level <= _test_eof\n";
489
490 if ( redFsm->anyEofTrans() || redFsm->anyEofActions() ) {
491 out <<
492 " if " << P() << " == " << EOFV() << "\n";
493
494 if ( redFsm->anyEofTrans() ) {
495 out <<
496 " if " << ET() << "[" << CS() << "] > 0\n"
497 " _trans = " << ET() << "[" << CS() << "] - 1;\n"
498 " _goto_level = _eof_trans\n"
499 " next;\n"
500 " end\n";
501 }
502
503 if ( redFsm->anyEofActions() ) {
504 out <<
505 " begin\n"
506 " case ( " << EA() << "[" << CS() << "] )\n";
507 EOF_ACTION_SWITCH() <<
508 " end\n"
509 " end\n";
510 }
511
512 out <<
513 " end\n"
514 "\n";
515 }
516
517 out <<
518 " end\n"
519 " if _goto_level <= _out\n"
520 " break\n"
521 " end\n"
522 "end\n";
523
524 /* Wrapping the execute block. */
525 out << " end\n";
526 }
527
528
529 void RubyFTabCodeGen::calcIndexSize()
530 {
531 int sizeWithInds = 0, sizeWithoutInds = 0;
532
533 /* Calculate cost of using with indicies. */
534 for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
535 int totalIndex = st->outSingle.length() + st->outRange.length() +
536 (st->defTrans == 0 ? 0 : 1);
537 sizeWithInds += arrayTypeSize(redFsm->maxIndex) * totalIndex;
538 }
539 sizeWithInds += arrayTypeSize(redFsm->maxState) * redFsm->transSet.length();
540 if ( redFsm->anyActions() )
541 sizeWithInds += arrayTypeSize(redFsm->maxActListId) * redFsm->transSet.length();
542
543 /* Calculate the cost of not using indicies. */
544 for ( RedStateList::Iter st = redFsm->stateList; st.lte(); st++ ) {
545 int totalIndex = st->outSingle.length() + st->outRange.length() +
546 (st->defTrans == 0 ? 0 : 1);
547 sizeWithoutInds += arrayTypeSize(redFsm->maxState) * totalIndex;
548 if ( redFsm->anyActions() )
549 sizeWithoutInds += arrayTypeSize(redFsm->maxActListId) * totalIndex;
550 }
551
552 /* If using indicies reduces the size, use them. */
553 useIndicies = sizeWithInds < sizeWithoutInds;
554 }
555
556 /*
557 * Local Variables:
558 * mode: c++
559 * indent-tabs-mode: 1
560 * c-file-style: "bsd"
561 * End:
562 */
Ragel State Machine Compiler