static void dump(const char_state_machine &csm_, rules &rules_,
ostream &stream_)
{
for (std::size_t dfa_ = 0, dfas_ = csm_.size(); dfa_ < dfas_; ++dfa_)
{
lexer_state(stream_);
stream_ << rules_.state(dfa_) << std::endl << std::endl;
dump_ex(csm_._sm_deque[dfa_], stream_);
}
}
// Internal function actually performing the work of dumping the
// state machine in DOT.
static void dump_ex (
id_type dfa_id_,
const typename char_state_machine::dfa &dfa_,
rules &rules_,
ostream &stream_)
{
const std::size_t states_ = dfa_._states.size ();
typename dfa_state::id_type_string_token_map::const_iterator iter_;
typename dfa_state::id_type_string_token_map::const_iterator end_;
stream_ << std::endl;
for (std::size_t i_ = 0; i_ < states_; ++i_)
{
const dfa_state &state_ = dfa_._states[i_];
const string name = node_name(dfa_id_, i_);
if (i_ == 0)
{
stream_ << " " << name << " [shape = doublecircle, xlabel=\""
<< rules_.state(dfa_id_) << "\"];" << std::endl;
}
else if (state_._end_state)
{
stream_ << " " << name << " [shape = doublecircle, xlabel=\"id ="
<< static_cast<std::size_t>(state_._id) << "\"];" << std::endl;
}
else {
stream_ << " " << name << " [shape = circle];" << std::endl;
}
}
stream_ << std::endl;
for (std::size_t i_ = 0; i_ < states_; ++i_)
{
const dfa_state &state_ = dfa_._states[i_];
iter_ = state_._transitions.begin ();
end_ = state_._transitions.end ();
const string src_name = node_name(dfa_id_, i_);
for (; iter_ != end_; ++iter_)
{
const string dst_name = node_name(dfa_id_, iter_->first);
stream_ << " " << src_name << " -> " << dst_name << " [label = \"";
string_token token_ = iter_->second;
open_bracket (stream_);
if (!iter_->second.any () && iter_->second.negatable ())
{
token_.negate ();
negated (stream_);
}
string chars_;
typename string_token::range_vector::const_iterator
ranges_iter_ = token_._ranges.begin ();
typename string_token::range_vector::const_iterator
ranges_end_ = token_._ranges.end ();
for (; ranges_iter_ != ranges_end_; ++ranges_iter_)
{
if (ranges_iter_->first == '^' ||
ranges_iter_->first == ']')
{
stream_ << "\\\\";
}
chars_ = double_escape_char(ranges_iter_->first);
if (ranges_iter_->first != ranges_iter_->second)
{
if (ranges_iter_->first + 1 < ranges_iter_->second)
{
chars_ += '-';
}
if (ranges_iter_->second == '^' ||
ranges_iter_->second == ']')
{
stream_ << "\\\\";
}
chars_ += double_escape_char(ranges_iter_->second);
}
stream_ << chars_;
}
close_bracket (stream_);
stream_ << "\"];" << std::endl;
}
if (state_._end_state) {
const string dst_name = node_name(state_._next_dfa, 0);
stream_ << " " << src_name << " -> " << dst_name
<< " [style = \"dashed\"];" << std::endl;
}
}
}
