regex_compiler.h

Go to the documentation of this file.

// class template regex -*- C++ -*-

// Copyright (C) 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/**
 *  @file bits/regex_compiler.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{regex}
 */

namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __regex
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  struct _Scanner_base
  {
    typedef unsigned int _StateT;

    static constexpr _StateT _S_state_at_start    = 1 << 0;
    static constexpr _StateT _S_state_in_brace    = 1 << 2;
    static constexpr _StateT _S_state_in_bracket  = 1 << 3;

    virtual ~_Scanner_base() { };
  };

  //
  // @brief Scans an input range for regex tokens.
  //
  // The %_Scanner class interprets the regular expression pattern in the input
  // range passed to its constructor as a sequence of parse tokens passed to
  // the regular expression compiler.  The sequence of tokens provided depends
  // on the flag settings passed to the constructor:  different regular
  // expression grammars will interpret the same input pattern in
  // syntactically different ways.
  //
  template<typename _InputIterator>
    class _Scanner: public _Scanner_base
    {
    public:
      typedef _InputIterator                                        _IteratorT;
      typedef typename std::iterator_traits<_IteratorT>::value_type _CharT;
      typedef std::basic_string<_CharT>                             _StringT;
      typedef regex_constants::syntax_option_type                   _FlagT;
      typedef const std::ctype<_CharT>                              _CtypeT;

      // Token types returned from the scanner.
      enum _TokenT
      {
    _S_token_anychar,
    _S_token_backref,
    _S_token_bracket_begin,
    _S_token_bracket_end,
    _S_token_inverse_class,
    _S_token_char_class_name,
    _S_token_closure0,
    _S_token_closure1,
    _S_token_collelem_multi,
    _S_token_collelem_single,
    _S_token_collsymbol,
    _S_token_comma,
    _S_token_dash,
    _S_token_dup_count,
    _S_token_eof,
    _S_token_equiv_class_name,
    _S_token_interval_begin,
    _S_token_interval_end,
    _S_token_line_begin,
    _S_token_line_end,
    _S_token_opt,
    _S_token_or,
    _S_token_ord_char,
    _S_token_quoted_char,
    _S_token_subexpr_begin,
    _S_token_subexpr_end,
    _S_token_word_begin,
    _S_token_word_end,
    _S_token_unknown
      };

    public:
      _Scanner(_IteratorT __begin, _IteratorT __end, _FlagT __flags,
           std::locale __loc)
      : _M_current(__begin) , _M_end(__end) , _M_flags(__flags),
        _M_ctype(std::use_facet<_CtypeT>(__loc)), _M_state(_S_state_at_start)
      { _M_advance(); }

      void
      _M_advance();

      _TokenT
      _M_token() const
      { return _M_curToken; }

      const _StringT&
      _M_value() const
      { return _M_curValue; }

#ifdef _GLIBCXX_DEBUG
      std::ostream&
      _M_print(std::ostream&);
#endif

    private:
      void
      _M_eat_escape();

      void
      _M_scan_in_brace();

      void
      _M_scan_in_bracket();

      void
      _M_eat_charclass();

      void
      _M_eat_equivclass();

      void
      _M_eat_collsymbol();

    private:
      _IteratorT  _M_current;
      _IteratorT  _M_end;
      _FlagT      _M_flags;
      _CtypeT&    _M_ctype;
      _TokenT     _M_curToken;
      _StringT    _M_curValue;
      _StateT     _M_state;
    };

  template<typename _InputIterator>
    void
    _Scanner<_InputIterator>::
    _M_advance()
    {
      if (_M_current == _M_end)
    {
      _M_curToken = _S_token_eof;
      return;
    }

      _CharT __c = *_M_current;
      if (_M_state & _S_state_in_bracket)
    {
      _M_scan_in_bracket();
      return;
    }
      if (_M_state & _S_state_in_brace)
    {
      _M_scan_in_brace();
      return;
    }
#if 0
      // TODO: re-enable line anchors when _M_assertion is implemented.
      // See PR libstdc++/47724
      else if (_M_state & _S_state_at_start && __c == _M_ctype.widen('^'))
    {
      _M_curToken = _S_token_line_begin;
      ++_M_current;
      return;
    }
      else if (__c == _M_ctype.widen('$'))
    {
      _M_curToken = _S_token_line_end;
      ++_M_current;
      return;
    }
#endif
      else if (__c == _M_ctype.widen('.'))
    {
      _M_curToken = _S_token_anychar;
      ++_M_current;
      return;
    }
      else if (__c == _M_ctype.widen('*'))
    {
      _M_curToken = _S_token_closure0;
      ++_M_current;
      return;
    }
      else if (__c == _M_ctype.widen('+'))
    {
      _M_curToken = _S_token_closure1;
      ++_M_current;
      return;
    }
      else if (__c == _M_ctype.widen('|'))
    {
      _M_curToken = _S_token_or;
      ++_M_current;
      return;
    }
      else if (__c == _M_ctype.widen('['))
    {
      _M_curToken = _S_token_bracket_begin;
      _M_state |= (_S_state_in_bracket | _S_state_at_start);
      ++_M_current;
      return;
    }
      else if (__c == _M_ctype.widen('\\'))
    {
      _M_eat_escape();
      return;
    }
      else if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
    {
      if (__c == _M_ctype.widen('('))
        {
          _M_curToken = _S_token_subexpr_begin;
          ++_M_current;
          return;
        }
      else if (__c == _M_ctype.widen(')'))
        {
          _M_curToken = _S_token_subexpr_end;
          ++_M_current;
          return;
        }
      else if (__c == _M_ctype.widen('{'))
        {
          _M_curToken = _S_token_interval_begin;
          _M_state |= _S_state_in_brace;
          ++_M_current;
          return;
        }
    }

      _M_curToken = _S_token_ord_char;
      _M_curValue.assign(1, __c);
      ++_M_current;
    }


  template<typename _InputIterator>
    void
    _Scanner<_InputIterator>::
    _M_scan_in_brace()
    {
      if (_M_ctype.is(_CtypeT::digit, *_M_current))
    {
      _M_curToken = _S_token_dup_count;
      _M_curValue.assign(1, *_M_current);
      ++_M_current;
      while (_M_current != _M_end
         && _M_ctype.is(_CtypeT::digit, *_M_current))
        {
          _M_curValue += *_M_current;
          ++_M_current;
        }
      return;
    }
      else if (*_M_current == _M_ctype.widen(','))
    {
      _M_curToken = _S_token_comma;
      ++_M_current;
      return;
    }
      if (_M_flags & (regex_constants::basic | regex_constants::grep))
    {
      if (*_M_current == _M_ctype.widen('\\'))
        _M_eat_escape();
    }
      else 
    {
      if (*_M_current == _M_ctype.widen('}'))
        {
          _M_curToken = _S_token_interval_end;
          _M_state &= ~_S_state_in_brace;
          ++_M_current;
          return;
        }
    }
    }

  template<typename _InputIterator>
    void
    _Scanner<_InputIterator>::
    _M_scan_in_bracket()
    {
      if (_M_state & _S_state_at_start && *_M_current == _M_ctype.widen('^'))
    {
      _M_curToken = _S_token_inverse_class;
      _M_state &= ~_S_state_at_start;
      ++_M_current;
      return;
    }
      else if (*_M_current == _M_ctype.widen('['))
    {
      ++_M_current;
      if (_M_current == _M_end)
        {
          _M_curToken = _S_token_eof;
          return;
        }

      if (*_M_current == _M_ctype.widen('.'))
        {
          _M_curToken = _S_token_collsymbol;
          _M_eat_collsymbol();
          return;
        }
      else if (*_M_current == _M_ctype.widen(':'))
        {
          _M_curToken = _S_token_char_class_name;
          _M_eat_charclass();
          return;
        }
      else if (*_M_current == _M_ctype.widen('='))
        {
          _M_curToken = _S_token_equiv_class_name;
          _M_eat_equivclass();
          return;
        }
    }
      else if (*_M_current == _M_ctype.widen('-'))
    {
      _M_curToken = _S_token_dash;
      ++_M_current;
      return;
    }
      else if (*_M_current == _M_ctype.widen(']'))
    {
      if (!(_M_flags & regex_constants::ECMAScript)
          || !(_M_state & _S_state_at_start))
        {
          // special case: only if  _not_ chr first after
          // '[' or '[^' and if not ECMAscript
          _M_curToken = _S_token_bracket_end;
          ++_M_current;
          return;
        }
    }
      _M_curToken = _S_token_collelem_single;
      _M_curValue.assign(1, *_M_current);
      ++_M_current;
    }

  template<typename _InputIterator>
    void
    _Scanner<_InputIterator>::
    _M_eat_escape()
    {
      ++_M_current;
      if (_M_current == _M_end)
    {
      _M_curToken = _S_token_eof;
      return;
    }
      _CharT __c = *_M_current;
      ++_M_current;

      if (__c == _M_ctype.widen('('))
    {
      if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
        {
          _M_curToken = _S_token_ord_char;
          _M_curValue.assign(1, __c);
        }
      else
        _M_curToken = _S_token_subexpr_begin;
    }
      else if (__c == _M_ctype.widen(')'))
    {
      if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
        {
          _M_curToken = _S_token_ord_char;
          _M_curValue.assign(1, __c);
        }
      else
        _M_curToken = _S_token_subexpr_end;
    }
      else if (__c == _M_ctype.widen('{'))
    {
      if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
        {
          _M_curToken = _S_token_ord_char;
          _M_curValue.assign(1, __c);
        }
      else
        {
          _M_curToken = _S_token_interval_begin;
          _M_state |= _S_state_in_brace;
        }
    }
      else if (__c == _M_ctype.widen('}'))
    {
      if (!(_M_flags & (regex_constants::basic | regex_constants::grep)))
        {
          _M_curToken = _S_token_ord_char;
          _M_curValue.assign(1, __c);
        }
      else
        {
          if (!(_M_state && _S_state_in_brace))
        __throw_regex_error(regex_constants::error_badbrace);
          _M_state &= ~_S_state_in_brace;
          _M_curToken = _S_token_interval_end;
        }
    }
      else if (__c == _M_ctype.widen('x'))
    {
      ++_M_current;
      if (_M_current == _M_end)
        {
          _M_curToken = _S_token_eof;
          return;
        }
      if (_M_ctype.is(_CtypeT::digit, *_M_current))
        {
          _M_curValue.assign(1, *_M_current);
          ++_M_current;
          if (_M_current == _M_end)
        {
          _M_curToken = _S_token_eof;
          return;
        }
          if (_M_ctype.is(_CtypeT::digit, *_M_current))
        {
          _M_curValue += *_M_current;
          ++_M_current;
          return;
        }
        }
    }
      else if (__c == _M_ctype.widen('^')
           || __c == _M_ctype.widen('.')
           || __c == _M_ctype.widen('*')
           || __c == _M_ctype.widen('$')
           || __c == _M_ctype.widen('\\'))
    {
      _M_curToken = _S_token_ord_char;
      _M_curValue.assign(1, __c);
    }
      else if (_M_ctype.is(_CtypeT::digit, __c))
    {
      _M_curToken = _S_token_backref;
      _M_curValue.assign(1, __c);
    }
      else
    __throw_regex_error(regex_constants::error_escape);
    }


  // Eats a character class or throwns an exception.
  // current point to ':' delimiter on entry, char after ']' on return
  template<typename _InputIterator>
    void
    _Scanner<_InputIterator>::
    _M_eat_charclass()
    {
      ++_M_current; // skip ':'
      if (_M_current == _M_end)
    __throw_regex_error(regex_constants::error_ctype);
      for (_M_curValue.clear();
       _M_current != _M_end && *_M_current != _M_ctype.widen(':');
       ++_M_current)
    _M_curValue += *_M_current;
      if (_M_current == _M_end)
    __throw_regex_error(regex_constants::error_ctype);
      ++_M_current; // skip ':'
      if (*_M_current != _M_ctype.widen(']'))
    __throw_regex_error(regex_constants::error_ctype);
      ++_M_current; // skip ']'
    }


  template<typename _InputIterator>
    void
    _Scanner<_InputIterator>::
    _M_eat_equivclass()
    {
      ++_M_current; // skip '='
      if (_M_current == _M_end)
    __throw_regex_error(regex_constants::error_collate);
      for (_M_curValue.clear();
       _M_current != _M_end && *_M_current != _M_ctype.widen('=');
       ++_M_current)
    _M_curValue += *_M_current;
      if (_M_current == _M_end)
    __throw_regex_error(regex_constants::error_collate);
      ++_M_current; // skip '='
      if (*_M_current != _M_ctype.widen(']'))
    __throw_regex_error(regex_constants::error_collate);
      ++_M_current; // skip ']'
    }


  template<typename _InputIterator>
    void
    _Scanner<_InputIterator>::
    _M_eat_collsymbol()
    {
      ++_M_current; // skip '.'
      if (_M_current == _M_end)
    __throw_regex_error(regex_constants::error_collate);
      for (_M_curValue.clear();
       _M_current != _M_end && *_M_current != _M_ctype.widen('.');
       ++_M_current)
    _M_curValue += *_M_current;
      if (_M_current == _M_end)
    __throw_regex_error(regex_constants::error_collate);
      ++_M_current; // skip '.'
      if (*_M_current != _M_ctype.widen(']'))
    __throw_regex_error(regex_constants::error_collate);
      ++_M_current; // skip ']'
    }

#ifdef _GLIBCXX_DEBUG
  template<typename _InputIterator>
    std::ostream&
    _Scanner<_InputIterator>::
    _M_print(std::ostream& ostr)
    {
      switch (_M_curToken)
      {
    case _S_token_anychar:
      ostr << "any-character\n";
      break;
    case _S_token_backref:
      ostr << "backref\n";
      break;
    case _S_token_bracket_begin:
      ostr << "bracket-begin\n";
      break;
    case _S_token_bracket_end:
      ostr << "bracket-end\n";
      break;
    case _S_token_char_class_name:
      ostr << "char-class-name \"" << _M_curValue << "\"\n";
      break;
    case _S_token_closure0:
      ostr << "closure0\n";
      break;
    case _S_token_closure1:
      ostr << "closure1\n";
      break;
    case _S_token_collelem_multi:
      ostr << "coll-elem-multi \"" << _M_curValue << "\"\n";
      break;
    case _S_token_collelem_single:
      ostr << "coll-elem-single \"" << _M_curValue << "\"\n";
      break;
    case _S_token_collsymbol:
      ostr << "collsymbol \"" << _M_curValue << "\"\n";
      break;
    case _S_token_comma:
      ostr << "comma\n";
      break;
    case _S_token_dash:
      ostr << "dash\n";
      break;
    case _S_token_dup_count:
      ostr << "dup count: " << _M_curValue << "\n";
      break;
    case _S_token_eof:
      ostr << "EOF\n";
      break;
    case _S_token_equiv_class_name:
      ostr << "equiv-class-name \"" << _M_curValue << "\"\n";
      break;
    case _S_token_interval_begin:
      ostr << "interval begin\n";
      break;
    case _S_token_interval_end:
      ostr << "interval end\n";
      break;
    case _S_token_line_begin:
      ostr << "line begin\n";
      break;
    case _S_token_line_end:
      ostr << "line end\n";
      break;
    case _S_token_opt:
      ostr << "opt\n";
      break;
    case _S_token_or:
      ostr << "or\n";
      break;
    case _S_token_ord_char:
      ostr << "ordinary character: \"" << _M_value() << "\"\n";
      break;
    case _S_token_quoted_char:
      ostr << "quoted char\n";
      break;
    case _S_token_subexpr_begin:
      ostr << "subexpr begin\n";
      break;
    case _S_token_subexpr_end:
      ostr << "subexpr end\n";
      break;
    case _S_token_word_begin:
      ostr << "word begin\n";
      break;
    case _S_token_word_end:
      ostr << "word end\n";
      break;
    case _S_token_unknown:
      ostr << "-- unknown token --\n";
      break;
      }
      return ostr;
    }
#endif

  // Builds an NFA from an input iterator interval.
  template<typename _InIter, typename _TraitsT>
    class _Compiler
    {
    public:
      typedef _InIter                                            _IterT;
      typedef typename std::iterator_traits<_InIter>::value_type _CharT;
      typedef std::basic_string<_CharT>                          _StringT;
      typedef regex_constants::syntax_option_type                _FlagT;

    public:
      _Compiler(const _InIter& __b, const _InIter& __e,
        _TraitsT& __traits, _FlagT __flags);

      const _Nfa&
      _M_nfa() const
      { return _M_state_store; }

    private:
      typedef _Scanner<_InIter>                              _ScannerT;
      typedef typename _ScannerT::_TokenT                    _TokenT;
      typedef std::stack<_StateSeq, std::vector<_StateSeq> > _StackT;
      typedef _RangeMatcher<_InIter, _TraitsT>               _RMatcherT;

      // accepts a specific token or returns false.
      bool
      _M_match_token(_TokenT __token);

      void
      _M_disjunction();

      bool
      _M_alternative();

      bool
      _M_term();

      bool
      _M_assertion();

      bool
      _M_quantifier();

      bool
      _M_atom();

      bool
      _M_bracket_expression();

      bool
      _M_bracket_list(_RMatcherT& __matcher);

      bool
      _M_follow_list(_RMatcherT& __matcher);

      bool
      _M_follow_list2(_RMatcherT& __matcher);

      bool
      _M_expression_term(_RMatcherT& __matcher);

      bool
      _M_range_expression(_RMatcherT& __matcher);

      bool
      _M_start_range(_RMatcherT& __matcher);

      bool
      _M_collating_symbol(_RMatcherT& __matcher);

      bool
      _M_equivalence_class(_RMatcherT& __matcher);

      bool
      _M_character_class(_RMatcherT& __matcher);

      int
      _M_cur_int_value(int __radix);

    private:
      _TraitsT&      _M_traits;
      _ScannerT      _M_scanner;
      _StringT       _M_cur_value;
      _Nfa           _M_state_store;
      _StackT        _M_stack;
    };

  template<typename _InIter, typename _TraitsT>
    _Compiler<_InIter, _TraitsT>::
    _Compiler(const _InIter& __b, const _InIter& __e, _TraitsT& __traits,
          _Compiler<_InIter, _TraitsT>::_FlagT __flags)
    : _M_traits(__traits), _M_scanner(__b, __e, __flags, _M_traits.getloc()),
      _M_state_store(__flags)
    {
      typedef _StartTagger<_InIter, _TraitsT> _Start;
      typedef _EndTagger<_InIter, _TraitsT> _End;

      _StateSeq __r(_M_state_store,
                _M_state_store._M_insert_subexpr_begin(_Start(0)));
      _M_disjunction();
      if (!_M_stack.empty())
    {
      __r._M_append(_M_stack.top());
      _M_stack.pop();
    }
      __r._M_append(_M_state_store._M_insert_subexpr_end(0, _End(0)));
      __r._M_append(_M_state_store._M_insert_accept());
    }

  template<typename _InIter, typename _TraitsT>
    bool
    _Compiler<_InIter, _TraitsT>::
    _M_match_token(_Compiler<_InIter, _TraitsT>::_TokenT token)
    { 
      if (token == _M_scanner._M_token())
    {
      _M_cur_value = _M_scanner._M_value();
      _M_scanner._M_advance();
      return true;
    }
      return false;
    }

  template<typename _InIter, typename _TraitsT>
    void
    _Compiler<_InIter, _TraitsT>::
    _M_disjunction()
    {
      this->_M_alternative();
      if (_M_match_token(_ScannerT::_S_token_or))
    {
      _StateSeq __alt1 = _M_stack.top(); _M_stack.pop();
      this->_M_disjunction();
      _StateSeq __alt2 = _M_stack.top(); _M_stack.pop();
      _M_stack.push(_StateSeq(__alt1, __alt2));
    }
    }

  template<typename _InIter, typename _TraitsT>
    bool
    _Compiler<_InIter, _TraitsT>::
    _M_alternative()
    {
      if (this->_M_term())
    {
      _StateSeq __re = _M_stack.top(); _M_stack.pop();
      this->_M_alternative();
      if (!_M_stack.empty())
        {
          __re._M_append(_M_stack.top());
          _M_stack.pop();
        }
      _M_stack.push(__re);
      return true;
    }
      return false;
    }

  template<typename _InIter, typename _TraitsT>
    bool
    _Compiler<_InIter, _TraitsT>::
    _M_term()
    {
      if (this->_M_assertion())
    return true;
      if (this->_M_atom())
    {
      this->_M_quantifier();
      return true;
    }
      return false;
    }

  template<typename _InIter, typename _TraitsT>
    bool
    _Compiler<_InIter, _TraitsT>::
    _M_assertion()
    {
      if (_M_match_token(_ScannerT::_S_token_line_begin))
    {
      // __m.push(_Matcher::_S_opcode_line_begin);
      return true;
    }
      if (_M_match_token(_ScannerT::_S_token_line_end))
    {
      // __m.push(_Matcher::_S_opcode_line_end);
      return true;
    }
      if (_M_match_token(_ScannerT::_S_token_word_begin))
    {
      // __m.push(_Matcher::_S_opcode_word_begin);
      return true;
    }
      if (_M_match_token(_ScannerT::_S_token_word_end))
    {
      // __m.push(_Matcher::_S_opcode_word_end);
      return true;
    }
      return false;
    }

  template<typename _InIter, typename _TraitsT>
    bool
    _Compiler<_InIter, _TraitsT>::
    _M_quantifier()
    {
      if (_M_match_token(_ScannerT::_S_token_closure0))
    {
      if (_M_stack.empty())
        __throw_regex_error(regex_constants::error_badrepeat);
      _StateSeq __r(_M_stack.top(), -1);
      __r._M_append(__r._M_front());
      _M_stack.pop();
      _M_stack.push(__r);
      return true;
    }
      if (_M_match_token(_ScannerT::_S_token_closure1))
    {
      if (_M_stack.empty())
        __throw_regex_error(regex_constants::error_badrepeat);
      _StateSeq __r(_M_state_store,
            _M_state_store.
            _M_insert_alt(_S_invalid_state_id,
                      _M_stack.top()._M_front()));
      _M_stack.top()._M_append(__r);
      return true;
    }
      if (_M_match_token(_ScannerT::_S_token_opt))
    {
      if (_M_stack.empty())
      __throw_regex_error(regex_constants::error_badrepeat);
      _StateSeq __r(_M_stack.top(), -1);
      _M_stack.pop();
      _M_stack.push(__r);
      return true;
    }
      if (_M_match_token(_ScannerT::_S_token_interval_begin))
    {
      if (_M_stack.empty())
        __throw_regex_error(regex_constants::error_badrepeat);
      if (!_M_match_token(_ScannerT::_S_token_dup_count))
        __throw_regex_error(regex_constants::error_badbrace);
      _StateSeq __r(_M_stack.top());
      int __min_rep = _M_cur_int_value(10);
      for (int __i = 1; __i < __min_rep; ++__i)
        _M_stack.top()._M_append(__r._M_clone()); 
      if (_M_match_token(_ScannerT::_S_token_comma))
        if (_M_match_token(_ScannerT::_S_token_dup_count))
          {
        int __n = _M_cur_int_value(10) - __min_rep;
        if (__n < 0)
          __throw_regex_error(regex_constants::error_badbrace);
        for (int __i = 0; __i < __n; ++__i)
          {
            _StateSeq __r(_M_state_store,
                  _M_state_store.
                  _M_insert_alt(_S_invalid_state_id,
                        _M_stack.top()._M_front()));
            _M_stack.top()._M_append(__r);
          }
          }
        else
          {
        _StateSeq __r(_M_stack.top(), -1);
        __r._M_push_back(__r._M_front());
        _M_stack.pop();
        _M_stack.push(__r);
          }
      if (!_M_match_token(_ScannerT::_S_token_interval_end))
        __throw_regex_error(regex_constants::error_brace);
      return true;
    }
      return false;
    }

  template<typename _InIter, typename _TraitsT>
    bool
    _Compiler<_InIter, _TraitsT>::
    _M_atom()
    {
      typedef _CharMatcher<_InIter, _TraitsT> _CMatcher;
      typedef _StartTagger<_InIter, _TraitsT> _Start;
      typedef _EndTagger<_InIter, _TraitsT> _End;

      if (_M_match_token(_ScannerT::_S_token_anychar))
    {
      _M_stack.push(_StateSeq(_M_state_store,
                                  _M_state_store._M_insert_matcher
                                  (_AnyMatcher)));
      return true;
    }
      if (_M_match_token(_ScannerT::_S_token_ord_char))
    {
      _M_stack.push(_StateSeq(_M_state_store,
                                  _M_state_store._M_insert_matcher
                                  (_CMatcher(_M_cur_value[0], _M_traits))));
      return true;
    }
      if (_M_match_token(_ScannerT::_S_token_quoted_char))
    {
      // note that in the ECMA grammar, this case covers backrefs.
      _M_stack.push(_StateSeq(_M_state_store,
                  _M_state_store._M_insert_matcher
                  (_CMatcher(_M_cur_value[0], _M_traits))));
      return true;
    }
      if (_M_match_token(_ScannerT::_S_token_backref))
    {
      // __m.push(_Matcher::_S_opcode_ordchar, _M_cur_value);
      return true;
    }
      if (_M_match_token(_ScannerT::_S_token_subexpr_begin))
    {
      int __mark = _M_state_store._M_sub_count();
      _StateSeq __r(_M_state_store,
            _M_state_store.
            _M_insert_subexpr_begin(_Start(__mark)));
      this->_M_disjunction();
      if (!_M_match_token(_ScannerT::_S_token_subexpr_end))
        __throw_regex_error(regex_constants::error_paren);
      if (!_M_stack.empty())
        {
          __r._M_append(_M_stack.top());
          _M_stack.pop();
        }
      __r._M_append(_M_state_store._M_insert_subexpr_end
            (__mark, _End(__mark)));
      _M_stack.push(__r);
      return true;
    }
      return _M_bracket_expression();
    }

  template<typename _InIter, typename _TraitsT>
    bool
    _Compiler<_InIter, _TraitsT>::
    _M_bracket_expression()
    {
      if (_M_match_token(_ScannerT::_S_token_bracket_begin))
    {
      _RMatcherT __matcher(_M_match_token(_ScannerT::_S_token_line_begin),
                   _M_traits);
      if (!_M_bracket_list(__matcher)
          || !_M_match_token(_ScannerT::_S_token_bracket_end))
        __throw_regex_error(regex_constants::error_brack);
      _M_stack.push(_StateSeq(_M_state_store,
                  _M_state_store._M_insert_matcher(__matcher)));
      return true;
    }
      return false;
    }

  // If the dash is the last character in the bracket expression, it is not
  // special.
  template<typename _InIter, typename _TraitsT>
    bool
    _Compiler<_InIter, _TraitsT>::
    _M_bracket_list(_RMatcherT& __matcher)
    {
      if (_M_follow_list(__matcher))
    {
      if (_M_match_token(_ScannerT::_S_token_dash))
        __matcher._M_add_char(_M_cur_value[0]);
      return true;
    }
      return false;
    }

  template<typename _InIter, typename _TraitsT>
    bool
    _Compiler<_InIter, _TraitsT>::
    _M_follow_list(_RMatcherT& __matcher)
    { return _M_expression_term(__matcher) && _M_follow_list2(__matcher); }

  template<typename _InIter, typename _TraitsT>
    bool
    _Compiler<_InIter, _TraitsT>::
    _M_follow_list2(_RMatcherT& __matcher)
    {
      if (_M_expression_term(__matcher))
    return _M_follow_list2(__matcher);
      return true;
    }

  template<typename _InIter, typename _TraitsT>
    bool
    _Compiler<_InIter, _TraitsT>::
    _M_expression_term(_RMatcherT& __matcher)
    {
      return (_M_collating_symbol(__matcher)
          || _M_character_class(__matcher)
          || _M_equivalence_class(__matcher)
          || (_M_start_range(__matcher)
          && _M_range_expression(__matcher)));
    }

  template<typename _InIter, typename _TraitsT>
    bool
    _Compiler<_InIter, _TraitsT>::
    _M_range_expression(_RMatcherT& __matcher)
    {
      if (!_M_collating_symbol(__matcher))
    if (!_M_match_token(_ScannerT::_S_token_dash))
      __throw_regex_error(regex_constants::error_range);
      __matcher._M_make_range();
      return true;
    }

  template<typename _InIter, typename _TraitsT>
    bool
    _Compiler<_InIter, _TraitsT>::
    _M_start_range(_RMatcherT& __matcher)
    { return _M_match_token(_ScannerT::_S_token_dash); }

  template<typename _InIter, typename _TraitsT>
    bool
    _Compiler<_InIter, _TraitsT>::
    _M_collating_symbol(_RMatcherT& __matcher)
    {
      if (_M_match_token(_ScannerT::_S_token_collelem_single))
    {
      __matcher._M_add_char(_M_cur_value[0]);
      return true;
    }
      if (_M_match_token(_ScannerT::_S_token_collsymbol))
    {
      __matcher._M_add_collating_element(_M_cur_value);
      return true;
    }
      return false;
    }

  template<typename _InIter, typename _TraitsT>
    bool
    _Compiler<_InIter, _TraitsT>::
    _M_equivalence_class(_RMatcherT& __matcher)
    {
      if (_M_match_token(_ScannerT::_S_token_equiv_class_name))
    {
      __matcher._M_add_equivalence_class(_M_cur_value);
      return true;
    }
      return false;
    }

  template<typename _InIter, typename _TraitsT>
    bool
    _Compiler<_InIter, _TraitsT>::
    _M_character_class(_RMatcherT& __matcher)
    {
      if (_M_match_token(_ScannerT::_S_token_char_class_name))
    {
      __matcher._M_add_character_class(_M_cur_value);
      return true;
    }
      return false;
    }

  template<typename _InIter, typename _TraitsT>
    int
    _Compiler<_InIter, _TraitsT>::
    _M_cur_int_value(int __radix)
    {
      int __v = 0;
      for (typename _StringT::size_type __i = 0;
       __i < _M_cur_value.length(); ++__i)
    __v =__v * __radix + _M_traits.value(_M_cur_value[__i], __radix);
      return __v;
    }

  template<typename _InIter, typename _TraitsT>
    _AutomatonPtr
    __compile(const _InIter& __b, const _InIter& __e, _TraitsT& __t,
          regex_constants::syntax_option_type __f)
    { return _AutomatonPtr(new _Nfa(_Compiler<_InIter, _TraitsT>(__b, __e, __t,
                                        __f)._M_nfa())); }

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __regex
} // namespace std

/* vim: set ts=8 sw=2 sts=2: */