AutoPtr< List<String> > TokenWatcher::DumpInternal() { AutoPtr< List<String> > a = new List<String>; { AutoLock lock(mLock); Set<AutoPtr<IBinder> > keys; HashMap<AutoPtr<IBinder>, AutoPtr<Death> >::Iterator iter = mTokens.Begin(); for (; iter != mTokens.End(); ++iter) { keys.Insert(iter->mFirst); } StringBuilder sb("Token count: "); sb += mTokens.GetSize(); a->PushBack(sb.ToString()); Int32 i = 0; Set<AutoPtr<IBinder> >::Iterator iter2 = keys.Begin(); AutoPtr<IBinder> b; for (; iter2 != keys.End(); ++iter) { StringBuilder sb2("["); sb2 += i; sb2 += "] "; sb2 += mTokens[b]->mTag; sb2 += " - "; String bstr; b->ToString(&bstr); sb2 += bstr; a->PushBack(sb2.ToString()); i++; } } return a; }
template <class T> void print(const Set<T>& l, const string& name) { // Print the contents of a Set. Notice the presence of a constant iterator. cout << endl << name << ", size of set is " << l.Size() << "\n[ "; set<T>::const_iterator i; for (i = l.Begin(); i != l.End(); ++i) { cout << *i << " "; } cout << "]\n"; }
/*---------------------------------------------------------------------------------------------- Generate the actual FSM table for the pass. Process: * Initialize the table with the start state, corresponding to 0 slots matched. * For each rule in the pass, add a state corresponding to 1 slot matched. Keep track of the relevant rule(s) and whether the new state is a terminating state for the rule(s). * When we have created all the 1-slot-matched states, merge any equivalent states.... * For each 1-slot-matched, add 2-slots-matched states for any rules with at least 2 slots. Keep track of the relevant rule(s) and whether the new state is a terminating state for the rule(s). * When we have created all the 2-slots-matched states, merge any equivalent states. * Continue this process until we have created terminating states for every rule (ie, N-slots-matched state where the rule has N slots). ----------------------------------------------------------------------------------------------*/ void GdlPass::GenerateFsmTable(GrcManager * pcman) { // Hungarian: ifs = index of FsmState if (m_nGlobalID == -1) { m_nMaxRuleContext = 0; return; } m_pfsm = new FsmTable(m_nGlobalID, NumberOfFsmMachineClasses()); Assert(m_pfsm->RawNumberOfStates() == 0); // Create the start state, equivalent to no slots matched. m_pfsm->AddState(0); int ifsCurrent = 0; // Index of the first state whose slot-count == the slot count of currState, ie, the // beginning of the state range which may need to be fixed up as we merge. int ifsCurrSlotCntMin = 0; // Index of first state whose slot-count == slot count of currState + 1, ie, the // beginning of the state range in which to check for duplicates. int ifsNextSlotCntMin = 1; while (ifsCurrent < m_pfsm->RawNumberOfStates()) { FsmState * pfstateCurr = m_pfsm->RawStateAt(ifsCurrent); int critSlotsMatched = pfstateCurr->SlotsMatched(); if (!pfstateCurr->HasBeenMerged()) { for (int iprule = 0; iprule < m_vprule.Size(); iprule++) { GdlRule * prule = m_vprule[iprule]; if (ifsCurrent == 0 || // for state #0, all rules are consider matched pfstateCurr->RuleMatched(iprule)) { if (pfstateCurr->SlotsMatched() == prule->NumberOfInputItems()) { pfstateCurr->AddRuleToSuccessList(iprule); } else { Set<FsmMachineClass *> setpfsmc; GetMachineClassesForRuleItem(prule, critSlotsMatched, setpfsmc); for (Set<FsmMachineClass *>::iterator it = setpfsmc.Begin(); it != setpfsmc.End(); ++it) { FsmMachineClass * pfsmc = *it; int ifsmcColumn = pfsmc->Column(); int ifsNextState = pfstateCurr->CellValue(ifsmcColumn); if (ifsNextState == 0) { // Add a new state. ifsNextState = m_pfsm->RawNumberOfStates(); m_pfsm->AddState(critSlotsMatched + 1); pfstateCurr->SetCellValue(ifsmcColumn, ifsNextState); } // Store this rule as one matched for this state. m_pfsm->RawStateAt(ifsNextState)->AddRuleToMatchedList(iprule); } } } } } if (m_pfsm->RawNumberOfStates() > (ifsCurrent + 1) && m_pfsm->RawStateAt(ifsCurrent + 1)->SlotsMatched() != critSlotsMatched) { // We have just finished processing a group of states with critSlotsMatched, // which had the effect of creating a group of states where slots-matched == // critSlotsMatched + 1. There could be duplicates in the latter group, // which are pointed at by the former group. Mark the duplicates so that they // point to the earlier identical state. (Note that since we are currently // not actually deleting the duplicates, we don't need to fix up the earlier // group.) MergeIdenticalStates(ifsCurrSlotCntMin, ifsNextSlotCntMin, m_pfsm->RawNumberOfStates()); ifsCurrSlotCntMin = ifsNextSlotCntMin; ifsNextSlotCntMin = m_pfsm->RawNumberOfStates(); } ifsCurrent++; // go on to next state } m_nMaxRuleContext = m_pfsm->RawStateAt(ifsCurrent - 1)->m_critSlotsMatched; ReorderFsmStates(); GenerateStartStates(pcman); }