void BackendGen::makeActionTableList()
{
/* Must first order the action tables based on their id. */
int numTables = nextActionTableId;
RedActionTable **tables = new RedActionTable*[numTables];
for ( ActionTableMap::Iter at = actionTableMap; at.lte(); at++ )
tables[at->id] = at;
cgd->initActionTableList( numTables );
curActionTable = 0;
for ( int t = 0; t < numTables; t++ ) {
long length = tables[t]->key.length();
/* Collect the action table. */
RedAction *redAct = cgd->allActionTables + curActionTable;
redAct->actListId = curActionTable;
redAct->key.setAsNew( length );
for ( ActionTable::Iter atel = tables[t]->key; atel.lte(); atel++ ) {
redAct->key[atel.pos()].key = 0;
redAct->key[atel.pos()].value = cgd->allActions +
atel->value->actionId;
}
/* Insert into the action table map. */
cgd->redFsm->actionMap.insert( redAct );
curActionTable += 1;
}
delete[] tables;
}
/* Zeros out the function ordering keys. This may be called before minimization
* when it is known that no more fsm operations are going to be done. This
* will achieve greater reduction as states will not be separated on the basis
* of function ordering. */
void FsmAp::nullActionKeys( )
{
/* For each state... */
for ( StateList::Iter state = stateList; state.lte(); state++ ) {
/* Walk the transitions for the state. */
for ( TransList::Iter trans = state->outList; trans.lte(); trans++ ) {
/* Walk the action table for the transition. */
for ( ActionTable::Iter action = trans->actionTable;
action.lte(); action++ )
action->key = 0;
/* Walk the action table for the transition. */
for ( LmActionTable::Iter action = trans->lmActionTable;
action.lte(); action++ )
action->key = 0;
}
/* Null the action keys of the to state action table. */
for ( ActionTable::Iter action = state->toStateActionTable;
action.lte(); action++ )
action->key = 0;
/* Null the action keys of the from state action table. */
for ( ActionTable::Iter action = state->fromStateActionTable;
action.lte(); action++ )
action->key = 0;
/* Null the action keys of the out transtions. */
for ( ActionTable::Iter action = state->outActionTable;
action.lte(); action++ )
action->key = 0;
/* Null the action keys of the error action table. */
for ( ErrActionTable::Iter action = state->errActionTable;
action.lte(); action++ )
action->ordering = 0;
/* Null the action keys eof action table. */
for ( ActionTable::Iter action = state->eofActionTable;
action.lte(); action++ )
action->key = 0;
}
}
/* Shift the function ordering of the start transitions to start
* at fromOrder and increase in units of 1. Useful before staring.
* Returns the maximum number of order numbers used. */
int FsmAp::shiftStartActionOrder( int fromOrder )
{
int maxUsed = 0;
/* Walk the start state's transitions, shifting function ordering. */
for ( TransList::Iter trans = startState->outList; trans.lte(); trans++ ) {
/* Walk the function data for the transition and set the keys to
* increasing values starting at fromOrder. */
int curFromOrder = fromOrder;
ActionTable::Iter action = trans->actionTable;
for ( ; action.lte(); action++ )
action->key = curFromOrder++;
/* Keep track of the max number of orders used. */
if ( curFromOrder - fromOrder > maxUsed )
maxUsed = curFromOrder - fromOrder;
}
return maxUsed;
}
void XMLCodeGen::writeActionTableList()
{
/* Must first order the action tables based on their id. */
int numTables = nextActionTableId;
RedActionTable **tables = new RedActionTable*[numTables];
for ( ActionTableMap::Iter at = actionTableMap; at.lte(); at++ )
tables[at->id] = at;
out << " <action_table_list length=\"" << numTables << "\">\n";
for ( int t = 0; t < numTables; t++ ) {
out << " <action_table id=\"" << t << "\" length=\"" <<
tables[t]->key.length() << "\">";
for ( ActionTable::Iter atel = tables[t]->key; atel.lte(); atel++ ) {
out << atel->value->actionId;
if ( ! atel.last() )
out << " ";
}
out << "</action_table>\n";
}
out << " </action_table_list>\n";
delete[] tables;
}
/* Write out the array of actions. */
std::ostream &FsmCodeGen::ACTIONS_ARRAY()
{
out << "\t0, ";
int totalActions = 1;
for ( ActionTableMap::Iter act = redFsm->actionMap; act.lte(); act++ ) {
/* Write out the length, which will never be the last character. */
out << act->key.length() << ", ";
/* Put in a line break every 8 */
if ( totalActions++ % 8 == 7 )
out << "\n\t";
for ( ActionTable::Iter item = act->key; item.lte(); item++ ) {
out << item->value->actionId;
if ( ! (act.last() && item.last()) )
out << ", ";
/* Put in a line break every 8 */
if ( totalActions++ % 8 == 7 )
out << "\n\t";
}
}
out << "\n";
return out;
}
/* Set all the action from another action table in this table. */
void ActionTable::setActions( const ActionTable &other )
{
for ( ActionTable::Iter action = other; action.lte(); action++ )
insertMulti( action->key, action->value );
}