libstdc++-v3/include/bits/regex_scanner.h

   1 // class template regex -*- C++ -*-
   2
   3 // Copyright (C) 2013 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 /**
  26  *  @file bits/regex_scanner.h
  27  *  This is an internal header file, included by other library headers.
  28  *  Do not attempt to use it directly. @headername{regex}
  29  */
  30
  31 namespace std _GLIBCXX_VISIBILITY(default)
  32 {
  33 namespace __detail
  34 {
  35 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  36
  37   /**
  38    * @addtogroup regex-detail
  39    * @{
  40    */
  41
  42   /**
  43    * @brief struct _Scanner. Scans an input range for regex tokens.
  44    *
  45    * The %_Scanner class interprets the regular expression pattern in
  46    * the input range passed to its constructor as a sequence of parse
  47    * tokens passed to the regular expression compiler.  The sequence
  48    * of tokens provided depends on the flag settings passed to the
  49    * constructor: different regular expression grammars will interpret
  50    * the same input pattern in syntactically different ways.
  51    */
  52   template<typename _FwdIter>
  53     class _Scanner
  54     {
  55     public:
  56       typedef typename std::iterator_traits<_FwdIter>::value_type _CharT;
  57       typedef std::basic_string<_CharT>                           _StringT;
  58       typedef regex_constants::syntax_option_type                 _FlagT;
  59       typedef const std::ctype<_CharT>                            _CtypeT;
  60
  61       /// Token types returned from the scanner.
  62       enum _TokenT
  63       {
  64         _S_token_anychar,
  65         _S_token_ord_char,
  66         _S_token_oct_num,
  67         _S_token_hex_num,
  68         _S_token_backref,
  69         _S_token_subexpr_begin,
  70         _S_token_subexpr_no_group_begin,
  71         _S_token_subexpr_lookahead_begin,
  72         _S_token_subexpr_neg_lookahead_begin,
  73         _S_token_subexpr_end,
  74         _S_token_bracket_begin,
  75         _S_token_bracket_neg_begin,
  76         _S_token_bracket_end,
  77         _S_token_interval_begin,
  78         _S_token_interval_end,
  79         _S_token_quoted_class,
  80         _S_token_char_class_name,
  81         _S_token_collsymbol,
  82         _S_token_equiv_class_name,
  83         _S_token_opt,
  84         _S_token_or,
  85         _S_token_closure0,
  86         _S_token_closure1,
  87         _S_token_line_begin,
  88         _S_token_line_end,
  89         _S_token_comma,
  90         _S_token_dup_count,
  91         _S_token_eof,
  92         _S_token_unknown
  93       };
  94
  95       _Scanner(_FwdIter __begin, _FwdIter __end,
  96                _FlagT __flags, std::locale __loc);
  97
  98       void
  99       _M_advance();
 100
 101       _TokenT
 102       _M_get_token() const
 103       { return _M_token; }
 104
 105       const _StringT&
 106       _M_get_value() const
 107       { return _M_value; }
 108
 109 #ifdef _GLIBCXX_DEBUG
 110       std::ostream&
 111       _M_print(std::ostream&);
 112 #endif
 113
 114     private:
 115       enum _StateT
 116       {
 117         _S_state_normal,
 118         _S_state_in_brace,
 119         _S_state_in_bracket,
 120       };
 121
 122       void
 123       _M_scan_normal();
 124
 125       void
 126       _M_scan_in_bracket();
 127
 128       void
 129       _M_scan_in_brace();
 130
 131       void
 132       _M_eat_escape_ecma();
 133
 134       void
 135       _M_eat_escape_posix();
 136
 137       void
 138       _M_eat_escape_awk();
 139
 140       void
 141       _M_eat_class(char);
 142
 143       constexpr bool
 144       _M_is_ecma()
 145       { return _M_flags & regex_constants::ECMAScript; }
 146
 147       constexpr bool
 148       _M_is_basic()
 149       { return _M_flags & (regex_constants::basic | regex_constants::grep); }
 150
 151       constexpr bool
 152       _M_is_extended()
 153       {
 154         return _M_flags & (regex_constants::extended
 155                            | regex_constants::egrep
 156                            | regex_constants::awk);
 157       }
 158
 159       constexpr bool
 160       _M_is_grep()
 161       { return _M_flags & (regex_constants::grep | regex_constants::egrep); }
 162
 163       constexpr bool
 164       _M_is_awk()
 165       { return _M_flags & regex_constants::awk; }
 166
 167       _StateT                       _M_state;
 168       _FwdIter                      _M_current;
 169       _FwdIter                      _M_end;
 170       _FlagT                        _M_flags;
 171       _CtypeT&                      _M_ctype;
 172       _TokenT                       _M_token;
 173       _StringT                      _M_value;
 174       bool                          _M_at_bracket_start;
 175     public:
 176       // TODO: make them static when this file is stable.
 177       const std::map<char, _TokenT> _M_token_map;
 178       const std::map<char, char>    _M_ecma_escape_map;
 179       const std::map<char, char>    _M_awk_escape_map;
 180       const std::set<char>          _M_ecma_spec_char;
 181       const std::set<char>          _M_basic_spec_char;
 182       const std::set<char>          _M_extended_spec_char;
 183
 184       const std::map<char, char>&   _M_escape_map;
 185       const std::set<char>&         _M_spec_char;
 186       void (_Scanner::* _M_eat_escape)();
 187     };
 188
 189  //@} regex-detail
 190 _GLIBCXX_END_NAMESPACE_VERSION
 191 } // namespace __detail
 192 } // namespace std
 193
 194 #include <bits/regex_scanner.tcc>