git.sesse.net Git - casparcg/blob - dependencies/boost/boost/spirit/home/support/detail/lexer/debug.hpp

   1 // debug.hpp
   2 // Copyright (c) 2007-2009 Ben Hanson (http://www.benhanson.net/)
   3 //
   4 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   5 // file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   6 #ifndef BOOST_LEXER_DEBUG_HPP
   7 #define BOOST_LEXER_DEBUG_HPP
   8
   9 #include <map>
  10 #include <ostream>
  11 #include "rules.hpp"
  12 #include "size_t.hpp"
  13 #include "state_machine.hpp"
  14 #include "string_token.hpp"
  15 #include <vector>
  16
  17 namespace boost
  18 {
  19 namespace lexer
  20 {
  21 template<typename CharT>
  22 class basic_debug
  23 {
  24 public:
  25     typedef std::basic_ostream<CharT> ostream;
  26     typedef std::basic_string<CharT> string;
  27     typedef std::vector<std::size_t> size_t_vector;
  28
  29     static void escape_control_chars (const string &in_, string &out_)
  30     {
  31         const CharT *ptr_ = in_.c_str ();
  32         std::size_t size_ = in_.size ();
  33
  34 #if defined _MSC_VER && _MSC_VER <= 1200
  35         out_.erase ();
  36 #else
  37         out_.clear ();
  38 #endif
  39
  40         while (size_)
  41         {
  42             basic_string_token<CharT>::escape_char (*ptr_, out_);
  43             ++ptr_;
  44             --size_;
  45         }
  46     }
  47
  48     static void dump (const basic_state_machine<CharT> &state_machine_,
  49         basic_rules<CharT> &rules_, ostream &stream_)
  50     {
  51         typename basic_state_machine<CharT>::iterator iter_ =
  52             state_machine_.begin ();
  53         typename basic_state_machine<CharT>::iterator end_ =
  54             state_machine_.end ();
  55
  56         for (std::size_t dfa_ = 0, dfas_ = state_machine_.size ();
  57             dfa_ < dfas_; ++dfa_)
  58         {
  59             lexer_state (stream_);
  60             stream_ << rules_.state (dfa_) << std::endl << std::endl;
  61
  62             dump_ex (iter_, stream_);
  63         }
  64     }
  65
  66     static void dump (const basic_state_machine<CharT> &state_machine_,
  67         ostream &stream_)
  68     {
  69         typename basic_state_machine<CharT>::iterator iter_ =
  70             state_machine_.begin ();
  71         typename basic_state_machine<CharT>::iterator end_ =
  72             state_machine_.end ();
  73
  74         for (std::size_t dfa_ = 0, dfas_ = state_machine_.size ();
  75             dfa_ < dfas_; ++dfa_)
  76         {
  77             lexer_state (stream_);
  78             stream_ << dfa_ << std::endl << std::endl;
  79
  80             dump_ex (iter_, stream_);
  81         }
  82     }
  83
  84 protected:
  85     typedef std::basic_stringstream<CharT> stringstream;
  86
  87     static void dump_ex (typename basic_state_machine<CharT>::iterator &iter_,
  88         ostream &stream_)
  89     {
  90         const std::size_t states_ = iter_->states;
  91
  92         for (std::size_t i_ = 0; i_ < states_; ++i_)
  93         {
  94             state (stream_);
  95             stream_ << i_ << std::endl;
  96
  97             if (iter_->end_state)
  98             {
  99                 end_state (stream_);
 100                 stream_ << iter_->id;
 101                 unique_id (stream_);
 102                 stream_ << iter_->unique_id;
 103                 dfa (stream_);
 104                 stream_ << iter_->goto_dfa;
 105                 stream_ << std::endl;
 106             }
 107
 108             if (iter_->bol_index != npos)
 109             {
 110                 bol (stream_);
 111                 stream_ << iter_->bol_index << std::endl;
 112             }
 113
 114             if (iter_->eol_index != npos)
 115             {
 116                 eol (stream_);
 117                 stream_ << iter_->eol_index << std::endl;
 118             }
 119
 120             const std::size_t transitions_ = iter_->transitions;
 121
 122             if (transitions_ == 0)
 123             {
 124                 ++iter_;
 125             }
 126
 127             for (std::size_t t_ = 0; t_ < transitions_; ++t_)
 128             {
 129                 std::size_t goto_state_ = iter_->goto_state;
 130
 131                 if (iter_->token.any ())
 132                 {
 133                     any (stream_);
 134                 }
 135                 else
 136                 {
 137                     open_bracket (stream_);
 138
 139                     if (iter_->token._negated)
 140                     {
 141                         negated (stream_);
 142                     }
 143
 144                     string charset_;
 145                     CharT c_ = 0;
 146
 147                     escape_control_chars (iter_->token._charset,
 148                         charset_);
 149                     c_ = *charset_.c_str ();
 150
 151                     if (!iter_->token._negated &&
 152                         (c_ == '^' || c_ == ']'))
 153                     {
 154                         stream_ << '\\';
 155                     }
 156
 157                     stream_ << charset_;
 158                     close_bracket (stream_);
 159                 }
 160
 161                 stream_ << goto_state_ << std::endl;
 162                 ++iter_;
 163             }
 164
 165             stream_ << std::endl;
 166         }
 167     }
 168
 169     static void lexer_state (std::ostream &stream_)
 170     {
 171         stream_ << "Lexer state: ";
 172     }
 173
 174     static void lexer_state (std::wostream &stream_)
 175     {
 176         stream_ << L"Lexer state: ";
 177     }
 178
 179     static void state (std::ostream &stream_)
 180     {
 181         stream_ << "State: ";
 182     }
 183
 184     static void state (std::wostream &stream_)
 185     {
 186         stream_ << L"State: ";
 187     }
 188
 189     static void bol (std::ostream &stream_)
 190     {
 191         stream_ << "  BOL -> ";
 192     }
 193
 194     static void bol (std::wostream &stream_)
 195     {
 196         stream_ << L"  BOL -> ";
 197     }
 198
 199     static void eol (std::ostream &stream_)
 200     {
 201         stream_ << "  EOL -> ";
 202     }
 203
 204     static void eol (std::wostream &stream_)
 205     {
 206         stream_ << L"  EOL -> ";
 207     }
 208
 209     static void end_state (std::ostream &stream_)
 210     {
 211         stream_ << "  END STATE, Id = ";
 212     }
 213
 214     static void end_state (std::wostream &stream_)
 215     {
 216         stream_ << L"  END STATE, Id = ";
 217     }
 218
 219     static void unique_id (std::ostream &stream_)
 220     {
 221         stream_ << ", Unique Id = ";
 222     }
 223
 224     static void unique_id (std::wostream &stream_)
 225     {
 226         stream_ << L", Unique Id = ";
 227     }
 228
 229     static void any (std::ostream &stream_)
 230     {
 231         stream_ << "  . -> ";
 232     }
 233
 234     static void any (std::wostream &stream_)
 235     {
 236         stream_ << L"  . -> ";
 237     }
 238
 239     static void open_bracket (std::ostream &stream_)
 240     {
 241         stream_ << "  [";
 242     }
 243
 244     static void open_bracket (std::wostream &stream_)
 245     {
 246         stream_ << L"  [";
 247     }
 248
 249     static void negated (std::ostream &stream_)
 250     {
 251         stream_ << "^";
 252     }
 253
 254     static void negated (std::wostream &stream_)
 255     {
 256         stream_ << L"^";
 257     }
 258
 259     static void close_bracket (std::ostream &stream_)
 260     {
 261         stream_ << "] -> ";
 262     }
 263
 264     static void close_bracket (std::wostream &stream_)
 265     {
 266         stream_ << L"] -> ";
 267     }
 268
 269     static void dfa (std::ostream &stream_)
 270     {
 271         stream_ << ", dfa = ";
 272     }
 273
 274     static void dfa (std::wostream &stream_)
 275     {
 276         stream_ << L", dfa = ";
 277     }
 278 };
 279
 280 typedef basic_debug<char> debug;
 281 typedef basic_debug<wchar_t> wdebug;
 282 }
 283 }
 284
 285 #endif