From e9ed7749d1ed4e2d73c5ba68f437cdcd830a65db Mon Sep 17 00:00:00 2001 From: thurston Date: Sun, 29 Apr 2007 03:50:47 +0000 Subject: [PATCH] In the variable statement changed the name "curstate" to "cs" (the default name used for the current state) and implemented the other names as their defaults. Now all variables (p, pe, cs, top, stack, act, tokstart, tokend) can be renamed. git-svn-id: http://svn.complang.org/ragel/trunk@207 052ea7fc-9027-0410-9066-f65837a77df0 --- ragel/parsedata.cpp | 35 +++++++++++++- ragel/parsedata.h | 15 +++++- ragel/rlparse.kl | 8 ++-- ragel/xmlcodegen.cpp | 100 ++++++++++++++++++++++++++-------------- ragel/xmlcodegen.h | 4 -- redfsm/gendata.cpp | 9 +++- redfsm/gendata.h | 12 ++++- redfsm/xmlparse.kh | 8 +++- redfsm/xmlparse.kl | 30 ++++++++++-- redfsm/xmltags.gperf | 9 +++- rlgen-cd/fsmcodegen.cpp | 104 +++++++++++++++++++++++++++++++++++++++--- rlgen-cd/fsmcodegen.h | 14 +++--- rlgen-java/javacodegen.cpp | 104 +++++++++++++++++++++++++++++++++++++++--- rlgen-java/javacodegen.h | 16 +++---- rlgen-ruby/rubycodegen.cpp | 111 ++++++++++++++++++++++++++++++++++++++++----- rlgen-ruby/rubycodegen.h | 15 +++--- 16 files changed, 492 insertions(+), 102 deletions(-) diff --git a/ragel/parsedata.cpp b/ragel/parsedata.cpp index b4e4bb1..206ad50 100644 --- a/ragel/parsedata.cpp +++ b/ragel/parsedata.cpp @@ -428,7 +428,14 @@ ParseData::ParseData( char *fileName, char *sectionName, alphTypeSet(false), getKeyExpr(0), accessExpr(0), - curStateExpr(0), + pExpr(0), + peExpr(0), + csExpr(0), + topExpr(0), + stackExpr(0), + actExpr(0), + tokstartExpr(0), + tokendExpr(0), lowerNum(0), upperNum(0), fileName(fileName), @@ -877,6 +884,32 @@ bool ParseData::setAlphType( char *s1 ) return valid; } +bool ParseData::setVariable( char *var, InlineList *inlineList ) +{ + bool set = true; + + if ( strcmp( var, "p" ) == 0 ) + pExpr = inlineList; + else if ( strcmp( var, "pe" ) == 0 ) + peExpr = inlineList; + else if ( strcmp( var, "cs" ) == 0 ) + csExpr = inlineList; + else if ( strcmp( var, "top" ) == 0 ) + topExpr = inlineList; + else if ( strcmp( var, "stack" ) == 0 ) + stackExpr = inlineList; + else if ( strcmp( var, "act" ) == 0 ) + actExpr = inlineList; + else if ( strcmp( var, "tokstart" ) == 0 ) + tokstartExpr = inlineList; + else if ( strcmp( var, "tokend" ) == 0 ) + tokendExpr = inlineList; + else + set = false; + + return set; +} + /* Initialize the key operators object that will be referenced by all fsms * created. */ void ParseData::initKeyOps( ) diff --git a/ragel/parsedata.h b/ragel/parsedata.h index 330d96a..2d614ae 100644 --- a/ragel/parsedata.h +++ b/ragel/parsedata.h @@ -55,6 +55,7 @@ struct ReOrItem; struct LongestMatch; typedef DList LmList; + /* Graph dictionary. */ struct GraphDictEl : @@ -189,6 +190,9 @@ struct ParseData bool setAlphType( char *s1, char *s2 ); bool setAlphType( char *s1 ); + /* Override one of the variables ragel uses. */ + bool setVariable( char *var, InlineList *inlineList ); + /* Unique actions. */ void removeDups( ActionTable &actionTable ); void removeActionDups( FsmAp *graph ); @@ -254,7 +258,16 @@ struct ParseData /* Element type and get key expression. */ InlineList *getKeyExpr; InlineList *accessExpr; - InlineList *curStateExpr; + + /* Overriding variables. */ + InlineList *pExpr; + InlineList *peExpr; + InlineList *csExpr; + InlineList *topExpr; + InlineList *stackExpr; + InlineList *actExpr; + InlineList *tokstartExpr; + InlineList *tokendExpr; /* The alphabet range. */ char *lowerNum, *upperNum; diff --git a/ragel/rlparse.kl b/ragel/rlparse.kl index 29dd1c2..d6c2c02 100644 --- a/ragel/rlparse.kl +++ b/ragel/rlparse.kl @@ -186,11 +186,9 @@ access_spec: variable_spec: KW_Variable opt_whitespace TK_Word inline_expr ';' final { /* FIXME: Need to implement the rest of this. */ - if ( strcmp( $3->data, "curstate" ) == 0 ) - pd->curStateExpr = $4->inlineList; - else { - error($3->loc) << "sorry, unimplementd" << endl; - } + bool wasSet = pd->setVariable( $3->data, $4->inlineList ); + if ( !wasSet ) + error($3->loc) << "bad variable name" << endl; }; opt_whitespace: opt_whitespace IL_WhiteSpace; diff --git a/ragel/xmlcodegen.cpp b/ragel/xmlcodegen.cpp index eba7e32..248959a 100644 --- a/ragel/xmlcodegen.cpp +++ b/ragel/xmlcodegen.cpp @@ -616,32 +616,6 @@ void XMLCodeGen::writeMachine() out << " \n"; } -void XMLCodeGen::writeAlphType() -{ - out << " " << - (keyOps->alphType - hostLang->hostTypes) << "\n"; -} - -void XMLCodeGen::writeGetKeyExpr() -{ - out << " "; - writeInlineList( pd->getKeyExpr, 0 ); - out << "\n"; -} - -void XMLCodeGen::writeAccessExpr() -{ - out << " "; - writeInlineList( pd->accessExpr, 0 ); - out << "\n"; -} - -void XMLCodeGen::writeCurStateExpr() -{ - out << " "; - writeInlineList( pd->curStateExpr, 0 ); - out << "\n"; -} void XMLCodeGen::writeConditions() { @@ -680,16 +654,76 @@ void XMLCodeGen::writeXML() { /* Open the definition. */ out << "\n"; - writeAlphType(); + + /* Alphabet type. */ + out << " " << + (keyOps->alphType - hostLang->hostTypes) << "\n"; - if ( pd->getKeyExpr != 0 ) - writeGetKeyExpr(); + /* Getkey expression. */ + if ( pd->getKeyExpr != 0 ) { + out << " "; + writeInlineList( pd->getKeyExpr, 0 ); + out << "\n"; + } - if ( pd->accessExpr != 0 ) - writeAccessExpr(); + /* Access expression. */ + if ( pd->accessExpr != 0 ) { + out << " "; + writeInlineList( pd->accessExpr, 0 ); + out << "\n"; + } + + /* + * Variable expressions. + */ - if ( pd->curStateExpr != 0 ) - writeCurStateExpr(); + if ( pd->pExpr != 0 ) { + out << " "; + writeInlineList( pd->pExpr, 0 ); + out << "\n"; + } + + if ( pd->peExpr != 0 ) { + out << " "; + writeInlineList( pd->peExpr, 0 ); + out << "\n"; + } + + if ( pd->csExpr != 0 ) { + out << " "; + writeInlineList( pd->csExpr, 0 ); + out << "\n"; + } + + if ( pd->topExpr != 0 ) { + out << " "; + writeInlineList( pd->topExpr, 0 ); + out << "\n"; + } + + if ( pd->stackExpr != 0 ) { + out << " "; + writeInlineList( pd->stackExpr, 0 ); + out << "\n"; + } + + if ( pd->actExpr != 0 ) { + out << " "; + writeInlineList( pd->actExpr, 0 ); + out << "\n"; + } + + if ( pd->tokstartExpr != 0 ) { + out << " "; + writeInlineList( pd->tokstartExpr, 0 ); + out << "\n"; + } + + if ( pd->tokendExpr != 0 ) { + out << " "; + writeInlineList( pd->tokendExpr, 0 ); + out << "\n"; + } writeExports(); diff --git a/ragel/xmlcodegen.h b/ragel/xmlcodegen.h index 6c80ac7..6f4823b 100644 --- a/ragel/xmlcodegen.h +++ b/ragel/xmlcodegen.h @@ -107,12 +107,8 @@ private: void writeExports(); bool writeNameInst( NameInst *nameInst ); void writeEntryPoints(); - void writeGetKeyExpr(); - void writeAccessExpr(); - void writeCurStateExpr(); void writeConditions(); void writeInlineList( InlineList *inlineList, InlineItem *context ); - void writeAlphType(); void writeActionList(); void writeActionTableList(); void reduceTrans( TransAp *trans ); diff --git a/redfsm/gendata.cpp b/redfsm/gendata.cpp index be22974..a5ff123 100644 --- a/redfsm/gendata.cpp +++ b/redfsm/gendata.cpp @@ -41,7 +41,14 @@ CodeGenData::CodeGenData( ostream &out ) errState(-1), getKeyExpr(0), accessExpr(0), - curStateExpr(0), + pExpr(0), + peExpr(0), + csExpr(0), + topExpr(0), + stackExpr(0), + actExpr(0), + tokstartExpr(0), + tokendExpr(0), wantComplete(0), hasLongestMatch(false), codeGenErrCount(0), diff --git a/redfsm/gendata.h b/redfsm/gendata.h index a5a3d0a..34d9bec 100644 --- a/redfsm/gendata.h +++ b/redfsm/gendata.h @@ -99,7 +99,17 @@ struct CodeGenData CondSpaceList condSpaceList; InlineList *getKeyExpr; InlineList *accessExpr; - InlineList *curStateExpr; + + /* Overriding variables. */ + InlineList *pExpr; + InlineList *peExpr; + InlineList *csExpr; + InlineList *topExpr; + InlineList *stackExpr; + InlineList *actExpr; + InlineList *tokstartExpr; + InlineList *tokendExpr; + KeyOps thisKeyOps; bool wantComplete; EntryIdVect entryPointIds; diff --git a/redfsm/xmlparse.kh b/redfsm/xmlparse.kh index 8526196..7b1d2a1 100644 --- a/redfsm/xmlparse.kh +++ b/redfsm/xmlparse.kh @@ -112,8 +112,12 @@ struct Parser TAG_hold, TAG_exec, TAG_holdte, TAG_execte, TAG_curs, TAG_targs, TAG_entry, TAG_data, TAG_lm_switch, TAG_init_act, TAG_set_act, TAG_set_tokend, TAG_get_tokend, TAG_init_tokstart, - TAG_set_tokstart, TAG_write, TAG_curstate, TAG_access, TAG_break, - TAG_arg; + TAG_set_tokstart; + + token TAG_write, TAG_access, TAG_break, TAG_arg, TAG_cs_expr; + + token TAG_p_expr, TAG_pe_expr, TAG_cs_expr, TAG_top_expr, + TAG_stack_expr, TAG_act_expr, TAG_tokstart_expr, TAG_tokend_expr; }%% %% write instance_data; diff --git a/redfsm/xmlparse.kl b/redfsm/xmlparse.kl index 11c42e1..5a969b9 100644 --- a/redfsm/xmlparse.kl +++ b/redfsm/xmlparse.kl @@ -161,9 +161,16 @@ ragel_def_item_list: ; ragel_def_item: tag_alph_type; ragel_def_item: tag_getkey_expr; ragel_def_item: tag_access_expr; -ragel_def_item: tag_curstate_expr; ragel_def_item: tag_export_list; ragel_def_item: tag_machine; +ragel_def_item: tag_p_expr; +ragel_def_item: tag_pe_expr; +ragel_def_item: tag_cs_expr; +ragel_def_item: tag_top_expr; +ragel_def_item: tag_stack_expr; +ragel_def_item: tag_act_expr; +ragel_def_item: tag_tokstart_expr; +ragel_def_item: tag_tokend_expr; tag_export_list: TAG_exports export_list '/' TAG_exports; @@ -198,10 +205,23 @@ tag_access_expr: TAG_access inline_list '/' TAG_access cgd->accessExpr = $2->inlineList; }; -tag_curstate_expr: TAG_curstate inline_list '/' TAG_curstate - final { - cgd->curStateExpr = $2->inlineList; - }; +tag_p_expr: TAG_p_expr inline_list '/' TAG_p_expr + final { cgd->pExpr = $2->inlineList; }; +tag_pe_expr: TAG_pe_expr inline_list '/' TAG_pe_expr + final { cgd->peExpr = $2->inlineList; }; +tag_cs_expr: TAG_cs_expr inline_list '/' TAG_cs_expr + final { cgd->csExpr = $2->inlineList; }; +tag_top_expr: TAG_top_expr inline_list '/' TAG_top_expr + final { cgd->topExpr = $2->inlineList; }; +tag_stack_expr: TAG_stack_expr inline_list '/' TAG_stack_expr + final { cgd->stackExpr = $2->inlineList; }; +tag_act_expr: TAG_act_expr inline_list '/' TAG_act_expr + final { cgd->actExpr = $2->inlineList; }; +tag_tokstart_expr: TAG_tokstart_expr inline_list '/' TAG_tokstart_expr + final { cgd->tokstartExpr = $2->inlineList; }; +tag_tokend_expr: TAG_tokend_expr inline_list '/' TAG_tokend_expr + final { cgd->tokendExpr = $2->inlineList; }; + tag_write: tag_write_head write_option_list '/' TAG_write final { diff --git a/redfsm/xmltags.gperf b/redfsm/xmltags.gperf index 7185bab..be4374e 100644 --- a/redfsm/xmltags.gperf +++ b/redfsm/xmltags.gperf @@ -72,7 +72,6 @@ set_tokend, TAG_set_tokend init_tokstart, TAG_init_tokstart set_tokstart, TAG_set_tokstart write, TAG_write -curstate, TAG_curstate access, TAG_access break, TAG_break arg, TAG_arg @@ -82,3 +81,11 @@ cond_list, TAG_cond_list c, TAG_c exports, TAG_exports ex, TAG_ex +p_expr, TAG_p_expr +pe_expr, TAG_pe_expr +cs_expr, TAG_cs_expr +top_expr, TAG_top_expr +stack_expr, TAG_stack_expr +act_expr, TAG_act_expr +tokstart_expr, TAG_tokstart_expr +tokend_expr, TAG_tokend_expr diff --git a/rlgen-cd/fsmcodegen.cpp b/rlgen-cd/fsmcodegen.cpp index 3ed0bb3..7fc8d5e 100644 --- a/rlgen-cd/fsmcodegen.cpp +++ b/rlgen-cd/fsmcodegen.cpp @@ -136,27 +136,117 @@ std::ostream &FsmCodeGen::ACTIONS_ARRAY() } +string FsmCodeGen::ACCESS() +{ + ostringstream ret; + if ( accessExpr != 0 ) + INLINE_LIST( ret, accessExpr, 0, false ); + return ret.str(); +} + + +string FsmCodeGen::P() +{ + ostringstream ret; + if ( pExpr == 0 ) + ret << "p"; + else { + ret << "("; + INLINE_LIST( ret, pExpr, 0, false ); + ret << ")"; + } + return ret.str(); +} + +string FsmCodeGen::PE() +{ + ostringstream ret; + if ( peExpr == 0 ) + ret << "pe"; + else { + ret << "("; + INLINE_LIST( ret, peExpr, 0, false ); + ret << ")"; + } + return ret.str(); +} + string FsmCodeGen::CS() { ostringstream ret; - if ( curStateExpr != 0 ) { + if ( csExpr == 0 ) + ret << ACCESS() << "cs"; + else { /* Emit the user supplied method of retrieving the key. */ ret << "("; - INLINE_LIST( ret, curStateExpr, 0, false ); + INLINE_LIST( ret, csExpr, 0, false ); ret << ")"; } + return ret.str(); +} + +string FsmCodeGen::TOP() +{ + ostringstream ret; + if ( topExpr == 0 ) + ret << ACCESS() + "top"; else { - /* Expression for retrieving the key, use simple dereference. */ - ret << ACCESS() << "cs"; + ret << "("; + INLINE_LIST( ret, topExpr, 0, false ); + ret << ")"; } return ret.str(); } -string FsmCodeGen::ACCESS() +string FsmCodeGen::STACK() { ostringstream ret; - if ( accessExpr != 0 ) - INLINE_LIST( ret, accessExpr, 0, false ); + if ( stackExpr == 0 ) + ret << ACCESS() + "stack"; + else { + ret << "("; + INLINE_LIST( ret, stackExpr, 0, false ); + ret << ")"; + } + return ret.str(); +} + +string FsmCodeGen::ACT() +{ + ostringstream ret; + if ( actExpr == 0 ) + ret << ACCESS() + "act"; + else { + ret << "("; + INLINE_LIST( ret, actExpr, 0, false ); + ret << ")"; + } + return ret.str(); +} + +string FsmCodeGen::TOKSTART() +{ + ostringstream ret; + if ( tokstartExpr == 0 ) + ret << ACCESS() + "tokstart"; + else { + ret << "("; + INLINE_LIST( ret, tokstartExpr, 0, false ); + ret << ")"; + } + return ret.str(); +} + +string FsmCodeGen::TOKEND() +{ + ostringstream ret; + if ( tokendExpr == 0 ) + ret << ACCESS() + "tokend"; + else { + ret << "("; + INLINE_LIST( ret, tokendExpr, 0, false ); + ret << ")"; + } return ret.str(); } diff --git a/rlgen-cd/fsmcodegen.h b/rlgen-cd/fsmcodegen.h index 628f9a9..e0834fc 100644 --- a/rlgen-cd/fsmcodegen.h +++ b/rlgen-cd/fsmcodegen.h @@ -90,16 +90,16 @@ protected: virtual string GET_KEY(); virtual ostream &SWITCH_DEFAULT() = 0; - string P() { return "p"; } - string PE() { return "pe"; } + string P(); + string PE(); string ACCESS(); string CS(); - string STACK() { return ACCESS() + "stack"; } - string TOP() { return ACCESS() + "top"; } - string TOKSTART() { return ACCESS() + "tokstart"; } - string TOKEND() { return ACCESS() + "tokend"; } - string ACT() { return ACCESS() + "act"; } + string STACK(); + string TOP(); + string TOKSTART(); + string TOKEND(); + string ACT(); string DATA_PREFIX(); string PM() { return "_" + DATA_PREFIX() + "partition_map"; } diff --git a/rlgen-java/javacodegen.cpp b/rlgen-java/javacodegen.cpp index 12afca2..1a5cee2 100644 --- a/rlgen-java/javacodegen.cpp +++ b/rlgen-java/javacodegen.cpp @@ -1199,30 +1199,120 @@ std::ostream &JavaTabCodeGen::ACTIONS_ARRAY() } +string JavaTabCodeGen::ACCESS() +{ + ostringstream ret; + if ( accessExpr != 0 ) + INLINE_LIST( ret, accessExpr, 0, false ); + return ret.str(); +} + +string JavaTabCodeGen::P() +{ + ostringstream ret; + if ( pExpr == 0 ) + ret << "p"; + else { + ret << "("; + INLINE_LIST( ret, pExpr, 0, false ); + ret << ")"; + } + return ret.str(); +} + +string JavaTabCodeGen::PE() +{ + ostringstream ret; + if ( peExpr == 0 ) + ret << "pe"; + else { + ret << "("; + INLINE_LIST( ret, peExpr, 0, false ); + ret << ")"; + } + return ret.str(); +} + string JavaTabCodeGen::CS() { ostringstream ret; - if ( curStateExpr != 0 ) { + if ( csExpr == 0 ) + ret << ACCESS() << "cs"; + else { /* Emit the user supplied method of retrieving the key. */ ret << "("; - INLINE_LIST( ret, curStateExpr, 0, false ); + INLINE_LIST( ret, csExpr, 0, false ); ret << ")"; } + return ret.str(); +} + +string JavaTabCodeGen::TOP() +{ + ostringstream ret; + if ( topExpr == 0 ) + ret << ACCESS() + "top"; else { - /* Expression for retrieving the key, use simple dereference. */ - ret << ACCESS() << "cs"; + ret << "("; + INLINE_LIST( ret, topExpr, 0, false ); + ret << ")"; } return ret.str(); } -string JavaTabCodeGen::ACCESS() +string JavaTabCodeGen::STACK() { ostringstream ret; - if ( accessExpr != 0 ) - INLINE_LIST( ret, accessExpr, 0, false ); + if ( stackExpr == 0 ) + ret << ACCESS() + "stack"; + else { + ret << "("; + INLINE_LIST( ret, stackExpr, 0, false ); + ret << ")"; + } + return ret.str(); +} + +string JavaTabCodeGen::ACT() +{ + ostringstream ret; + if ( actExpr == 0 ) + ret << ACCESS() + "act"; + else { + ret << "("; + INLINE_LIST( ret, actExpr, 0, false ); + ret << ")"; + } return ret.str(); } +string JavaTabCodeGen::TOKSTART() +{ + ostringstream ret; + if ( tokstartExpr == 0 ) + ret << ACCESS() + "tokstart"; + else { + ret << "("; + INLINE_LIST( ret, tokstartExpr, 0, false ); + ret << ")"; + } + return ret.str(); +} + +string JavaTabCodeGen::TOKEND() +{ + ostringstream ret; + if ( tokendExpr == 0 ) + ret << ACCESS() + "tokend"; + else { + ret << "("; + INLINE_LIST( ret, tokendExpr, 0, false ); + ret << ")"; + } + return ret.str(); +} + + string JavaTabCodeGen::GET_WIDE_KEY() { if ( redFsm->anyConditions() ) diff --git a/rlgen-java/javacodegen.h b/rlgen-java/javacodegen.h index 86f67a4..575ce6e 100644 --- a/rlgen-java/javacodegen.h +++ b/rlgen-java/javacodegen.h @@ -123,16 +123,16 @@ public: string WIDE_ALPH_TYPE(); string ARRAY_TYPE( unsigned long maxVal ); - string P() { return "p"; } - string PE() { return "pe"; } - string ACCESS(); + + string P(); + string PE(); string CS(); - string STACK() { return ACCESS() + "stack"; } - string TOP() { return ACCESS() + "top"; } - string TOKSTART() { return ACCESS() + "tokstart"; } - string TOKEND() { return ACCESS() + "tokend"; } - string ACT() { return ACCESS() + "act"; } + string STACK(); + string TOP(); + string TOKSTART(); + string TOKEND(); + string ACT(); string DATA_PREFIX(); string PM() { return "_" + DATA_PREFIX() + "partition_map"; } diff --git a/rlgen-ruby/rubycodegen.cpp b/rlgen-ruby/rubycodegen.cpp index 209e80a..2f38681 100644 --- a/rlgen-ruby/rubycodegen.cpp +++ b/rlgen-ruby/rubycodegen.cpp @@ -292,7 +292,7 @@ void RubyCodeGen::writeExec() out << INDENT_S() << P() << " += 1" ; if ( hasEnd ) - out << INDENT_S() << "_resume.call if p != pe"; + out << INDENT_S() << "_resume.call if " << P() << " != " << PE(); out << INDENT_D() << "end # cc _out" ; } @@ -1246,30 +1246,119 @@ std::ostream &RubyCodeGen::ACTIONS_ARRAY() } -string RubyCodeGen::CS() +string RubyCodeGen::ACCESS() { ostringstream ret; - if ( curStateExpr != 0 ) { - /* Emit the user supplied method of retrieving the key. */ - ret << "("; - INLINE_LIST( ret, curStateExpr, 0, false ); - ret << ")"; + if ( accessExpr != 0 ) + INLINE_LIST( ret, accessExpr, 0, false ); + return ret.str(); +} + +string RubyCodeGen::P() +{ + ostringstream ret; + if ( pExpr == 0 ) + ret << "p"; + else { + //ret << "("; + INLINE_LIST( ret, pExpr, 0, false ); + //ret << ")"; } + return ret.str(); +} + +string RubyCodeGen::PE() +{ + ostringstream ret; + if ( peExpr == 0 ) + ret << "pe"; else { - /* Expression for retrieving the key, use simple dereference. */ + //ret << "("; + INLINE_LIST( ret, peExpr, 0, false ); + //ret << ")"; + } + return ret.str(); +} + +string RubyCodeGen::CS() +{ + ostringstream ret; + if ( csExpr == 0 ) ret << ACCESS() << "cs"; + else { + //ret << "("; + INLINE_LIST( ret, csExpr, 0, false ); + //ret << ")"; } return ret.str(); } -string RubyCodeGen::ACCESS() +string RubyCodeGen::TOP() { ostringstream ret; - if ( accessExpr != 0 ) - INLINE_LIST( ret, accessExpr, 0, false ); + if ( topExpr == 0 ) + ret << ACCESS() + "top"; + else { + //ret << "("; + INLINE_LIST( ret, topExpr, 0, false ); + //ret << ")"; + } + return ret.str(); +} + +string RubyCodeGen::STACK() +{ + ostringstream ret; + if ( stackExpr == 0 ) + ret << ACCESS() + "stack"; + else { + //ret << "("; + INLINE_LIST( ret, stackExpr, 0, false ); + //ret << ")"; + } + return ret.str(); +} + +string RubyCodeGen::ACT() +{ + ostringstream ret; + if ( actExpr == 0 ) + ret << ACCESS() + "act"; + else { + //ret << "("; + INLINE_LIST( ret, actExpr, 0, false ); + //ret << ")"; + } return ret.str(); } +string RubyCodeGen::TOKSTART() +{ + ostringstream ret; + if ( tokstartExpr == 0 ) + ret << ACCESS() + "tokstart"; + else { + //ret << "("; + INLINE_LIST( ret, tokstartExpr, 0, false ); + //ret << ")"; + } + return ret.str(); +} + +string RubyCodeGen::TOKEND() +{ + ostringstream ret; + if ( tokendExpr == 0 ) + ret << ACCESS() + "tokend"; + else { + //ret << "("; + INLINE_LIST( ret, tokendExpr, 0, false ); + //ret << ")"; + } + return ret.str(); +} + + string RubyCodeGen::GET_WIDE_KEY() { if ( redFsm->anyConditions() ) diff --git a/rlgen-ruby/rubycodegen.h b/rlgen-ruby/rubycodegen.h index 773b949..dc32f68 100644 --- a/rlgen-ruby/rubycodegen.h +++ b/rlgen-ruby/rubycodegen.h @@ -118,16 +118,15 @@ public: string WIDE_ALPH_TYPE(); string ARRAY_TYPE( unsigned long maxVal ); - string P() { return "p"; } - string PE() { return "pe"; } - string ACCESS(); + string P(); + string PE(); string CS(); - string STACK() { return ACCESS() + "stack"; } - string TOP() { return ACCESS() + "top"; } - string TOKSTART() { return ACCESS() + "tokstart"; } - string TOKEND() { return ACCESS() + "tokend"; } - string ACT() { return ACCESS() + "act"; } + string TOP(); + string STACK(); + string ACT(); + string TOKSTART(); + string TOKEND(); string DATA_PREFIX(); string PM() { return "_" + DATA_PREFIX() + "partition_map"; } -- 2.7.4