Hello list, I'm experimenting a bit with *boost.msm* from the *boost 1.52* library. Please consider the following small code snippted which generally defines a state machine with the states *State1*, *State2* and *State3*, and the events *Event1* (triggers the transition from State1 to State2) and *Event2* (triggers the transition from State2 to State3): #include <iostream> #include <boost/msm/back/state_machine.hpp> #include <boost/msm/front/state_machine_def.hpp> #include <boost/msm/front/functor_row.hpp> namespace { namespace msm = boost::msm; namespace msmf = boost::msm::front; namespace mpl = boost::mpl; // ----- Events struct Event1 {}; struct Event2 {}; // ----- State machine struct Sm1_:msmf::state_machine_def<Sm1_> { // States struct Init:msmf::state<> {}; struct State1:msmf::state<> { // Entry action template <class Event,class Fsm> void on_entry(Event const&, Fsm&) { std::cout << "State1::on_entry()" << std::endl; } // Exit action template <class Event,class Fsm> void on_exit(Event const&, Fsm&) { std::cout << "State1::on_exit()" << std::endl; } }; struct State2:msmf::state<> { // Entry action template <class Event,class Fsm> void on_entry(Event const&, Fsm&) { std::cout << "State2::on_entry()" << std::endl; } // Exit action template <class Event,class Fsm> void on_exit(Event const&, Fsm&) { std::cout << "State2::on_exit()" << std::endl; } }; struct State3:msmf::state<> { // Entry action template <class Event,class Fsm> void on_entry(Event const&, Fsm&) { std::cout << "State3::on_entry()" << std::endl; } // Exit action template <class Event,class Fsm> void on_exit(Event const&, Fsm&) { std::cout << "State3::on_exit()" << std::endl; } }; // Set initial state typedef State1 initial_state; // Actions struct InitAction { template <class Event, class Fsm, class SourceState, class TargetState> void operator()(Event const&, Fsm&, SourceState&, TargetState&) const { std::cout << "InitAction()" << std::endl; } }; struct transition_table:mpl::vector< // Start Event Next Action Guard msmf::Row < State1, Event1, State2, msmf::none, msmf::none >, msmf::Row < State2, Event2, State3, msmf::none, msmf::none > > {}; }; // Pick a back-end typedef msm::back::state_machine<Sm1_> Sm1; void test() { Sm1 sm1; sm1.start(); std::cout << "> Send Event2" << std::endl; sm1.process_event(Event2()); std::cout << "> Send Event1" << std::endl; sm1.process_event(Event1()); } } int main() { test(); return 0; } If I compile and execute the code above the software crashes due to the fact, that *Event2* is received in the state *State1*. My understanding of a state machine and boost.msm was, that all events which are not defined for a particular state, will be just ignored and the state receiving this unknown event (here *Event2*) will keept. Is there a possibility in boost.msm ( maybe by adopting to the transition table) to stay in the current state if an event was received which was not assigned to this state? Thank you in advance! Best regards, RaRi -- View this message in context: http://boost.2283326.n4.nabble.com/Boost-MSM-Ignore-events-that-were-not-exp... Sent from the Boost - Users mailing list archive at Nabble.com.