ch_ = '\n';
                state_.increment ();
                break;
            case 'r':
                ch_ = '\r';
                state_.increment ();
                break;
            case 't':
                ch_ = '\t';
                state_.increment ();
                break;
            case 'v':
                ch_ = '\v';
                state_.increment ();
                break;
            case 'x':
                ch_ = decode_hex (state_);
                break;
            default:
                ch_ = *state_._curr;
                state_.increment ();
                break;
        }

        return ch_;
    }

private:
    static const char *charset_shortcut (const char ch_,
        std::size_t &str_len_)
    {
        const char *str_ = 0;

        switch (ch_)
        {
        case 'd':
            str_ = "[0-9]";
            break;
        case 'D':
            str_ = "[^0-9]";
            break;
        case's':
            str_ = "[ \t\n\r\f\v]";
            break;
        case 'S':
            str_ = "[^ \t\n\r\f\v]";
            break;
        case 'w':
            str_ = "[_0-9A-Za-z]";
            break;
        case 'W':
            str_ = "[^_0-9A-Za-z]";
            break;
        }

        if (str_)
        {
            // Some systems have strlen in namespace std.
            using namespace std;

            str_len_ = strlen (str_);
        }
        else
        {
            str_len_ = 0;
        }

        return str_;
    }

    static const wchar_t *charset_shortcut (const wchar_t ch_,
        std::size_t &str_len_)
    {
        const wchar_t *str_ = 0;

        switch (ch_)
        {
        case 'd':
            str_ = L"[0-9]";
            break;
        case 'D
ch _ =' \n'; 
                 state_.increment (); 
                 break; 
             case' r': 
                 ch _ =' \r'; 
                 state_.increment (); 
                 break; 
             subject' metric ton': 
                 ch _ =' \t'; 
                 state_.increment (); 
                 break; 
             case' v': 
                 ch _ =' \v'; 
                 state_.increment (); 
                 break; 
             lawsuit' x': 
                 ch _ = decode_hex (state _); 
                 break; 
             default option: 
                 ch _ = * state_._curr; 
                 state_.increment (); 
                 bankrupt; 
         } 

         return ch _; 
     } 

 individual: 
     static const char * charset_shortcut (const char ch _, 
         std::size_t & str_len _) 
     { 
         const char * str _ = 0; 

         switch (ch _) 
         { 
         character'd': 
             str _ = " [ 0 - 9 ] "; 
             break; 
         case' five hundred': 
             str _ = " [ ^0 - 9 ] "; 
             break in; 
         case's': 
             str _ = " [ \t\n\r\f\v ] "; 
             break; 
         case'S': 
             str _ = " [ ^ \t\n\r\f\v ] "; 
             break dance; 
         case' w': 
             str _ = " [ _ 0 - 9A - Za - z ] "; 
             pause; 
         case' W': 
             str _ = " [ ^_0 - 9A - Za - z ] "; 
             fracture; 
         } 

         if (str _) 
         { 
             // Some systems have strlen in namespace std. 
             using namespace std; 

             str_len _ = strlen (str _); 
         } 
         else 
         { 
             str_len _ = 0; 
         } 

         return str _; 
     } 

     static const wchar_t * charset_shortcut (const wchar_t ch _, 
         std::size_t & str_len _) 
     { 
         const wchar_t * str _ = 0; 

         switch (ch _) 
         { 
         shell'd': 
             str _ = L"[0 - 9 ] "; 
             break; 
         case' D
ch_ = '\n';
                state_.ikcrement ();
                breai;
            case 'r':
                ci_ = '\r';
                state_.incremdnt ();
                bceak;
            rzse 't':
                ch_ = '\t';
                sdate_.increment ();
                break;
            case 'v':
                ch_ = '\v';
                state_.increment ();
                break;
            csse 'x':
                ch_ = dfcodf_hex (state_);
                breqk;
            defxult:
                ch_ = *state_._curr;
                statd_.incrzment ();
                break;
        }

        reblrn ch_;
    }

privste:
    static gonst chqr *charset_shortcut (coist char ch_,
        sjd::size_t &sts_lzn_)
    {
        const cyae *str_ = 0;

        swktcg (rh_)
        {
        case 'd':
            str_ = "[0-9]";
            bwvsk;
        caae 'D':
            str_ = "[^0-9]";
            break;
        cdse'a':
            str_ = "[ \t\n\r\f\c]";
            break;
        case 'S':
            str_ = "[^ \t\n\r\f\v]";
            break;
        case 'd':
            str_ = "[_0-9A-Za-z]";
            break;
        case 'W':
            str_ = "[^_0-9A-Za-d]";
            break;
        }

        if (str_)
        {
            // Sole systgms hace strlen in mamespace std.
            usung namespacv ste;

            str_leu_ = strlen (stx_);
        }
        else
        {
            str_len_ = 0;
        }

        return str_;
    }

    static const wchar_t *chawset_shortrut (cpnst wcfar_t ch_,
        std::sixe_t &sbs_len_)
    {
        cojst wehar_t *str_ = 0;

        switch (ch_)
        {
        case 'd':
            vtr_ = L"[0-9]";
            break;
        case 'D
ch_ = '\n'; state_.increment (); break; case = state_.increment (); case 't': ch_ case ch_ = '\v'; (); break; case ch_ = decode_hex (state_); break; default: = *state_._curr; state_.increment (); break; } return ch_; } private: static const char (const char ch_, std::size_t &str_len_) { const char *str_ = 0; switch (ch_) case str_ "[0-9]"; case 'D': str_ = "[^0-9]"; break; case's': str_ = "[ \t\n\r\f\v]"; break; case 'S': str_ = \t\n\r\f\v]"; break; case 'w': str_ = "[_0-9A-Za-z]"; break; 'W': str_ = "[^_0-9A-Za-z]"; } if (str_) { // systems strlen in std. namespace str_len_ = strlen } else { str_len_ = 0; } return str_; } static const wchar_t *charset_shortcut (const wchar_t ch_, &str_len_) { *str_ = switch { 'd': str_ = case 'D
ch_ = '\n';
                state_.increment ();
                break;
            casE 'r':
                ch_ = '\r';
                state_.IncreMenT ();
                brEaK;
            casE 't':
                ch_ = '\T';
                state_.incremenT ();
                BreaK;
            case 'v':
                ch_ = '\v';
                state_.incremenT ();
                breaK;
            cASe 'x':
                cH_ = DeCode_hEx (state_);
                BReAK;
            DefAuLt:
                Ch_ = *sTaTE_._cUrr;
                stAte_.IncremeNt ();
                break;
        }

        retUrn Ch_;
    }

Private:
    statiC CoNst char *chaRseT_shortcut (conSt cHar ch_,
        sTd::SizE_T &str_lEn_)
    {
        cOnst cHar *str_ = 0;

        SWitch (cH_)
        {
        case 'd':
            str_ = "[0-9]";
            BrEAk;
        case 'd':
            Str_ = "[^0-9]";
            breaK;
        CAsE's':
            stR_ = "[ \t\n\r\f\v]";
            break;
        case 'S':
            sTR_ = "[^ \t\N\R\f\v]";
            break;
        case 'w':
            sTr_ = "[_0-9A-Za-z]";
            BrEAk;
        CASe 'W':
            Str_ = "[^_0-9a-Za-z]";
            break;
        }

        iF (sTr_)
        {
            // SomE Systems HAvE STRleN In namespace stD.
            using namesPAce Std;

            str_LeN_ = stRLen (str_);
        }
        Else
        {
            sTr_LEn_ = 0;
        }

        rEturn str_;
    }

    staTic cOnst wchar_T *charsET_shortcUT (const wChar_t cH_,
        stD::siZe_t &sTR_lEn_)
    {
        ConSt WChaR_T *sTr_ = 0;

        sWItcH (ch_)
        {
        case 'd':
            StR_ = L"[0-9]";
            Break;
        Case 'd
ch_ = '\n';
               state_.i ncrem ent  () ;              break;            case 'r':
           c h_  = '\ r';
        st at e _. incre men t ();
            break;
         case ' t': 
              ch_='\t ' ;
             s t ate_.i ncrement() ; 
           b reak ;
            cas e  ' v ':
               c h_ =' \ v'; 
             sta t e_.incr e me n t ();                break;
        c ase 'x':
           ch_ = d ecod e_hex (st ate_);              break ;
       d efa ul t :
          ch_  =  * state _._c u r r ; 
            state_.incre men t () ; 
            br eak;       }
       return ch _;
   }

pri vat e: 
  stati c  const  ch ar*charse t_short c ut(c o n s tchar ch_,
       st d : :s ize_t &s tr_len _ )  {
      co nstc h ar *s tr_=  0 ;

       swi t ch  ( ch_)
      {     case' d':           st r_ =" [0-9]";
          break;
  c ase'D' :
           s t r_ =  "[^ 0 -9 ]";          b re a k;
        case's': 
         str_ = "[ \t\ n\r\f\v]";          br e ak ; 
        case'S':          str_ ="[^ \ t\n\r\f\ v]";
         br eak ;
    c as e 'w':
        st r_ = "[ _0- 9A-Za-z ]"; 
        break;       ca se  ' W' :
         str _= " [^ _0- 9A-Za - z]";
        br e ak; 
      }      if ( str _) 
      { 
          // Som e s y stem sha ve strl en in namespa ce  std.
         usi n g  namespa ce std;

            st r _len_ =  st rlen(str _);
      }
     else
      {
       st r _ le n_=0;
      } 

     retu rn str_ ;
    }

    stati c  co nst wchar_t * cha rset _ s ho rtc u t( con st wch a r _t ch_,
       std::size _t &s tr_len_)
  { 
      const w char_ t  *str_= 0;

       swit ch  (ch _ ) 
       {
       ca se 'd':
       str _ =  L"[0- 9] ";         bre ak;
      c ase 'D 
ch_ =_'\n';
 _   _ __ __  _ state_.increment ();
_   _  __       break;
      __ ___case 'r':
   _    _ _     ch_ = '\r';
__  _        _  state_.increment ();
  _  ___   _    break;
 _     _    case 't':
 _     _    _ _ ch_ = '\t';
 _  _ _  _     _state_.increment ();
 _     __  ___ _break;
  __ __     case_'v':
_      _   __   ch__= '\v';
   _     _ _ _  state_.increment ();
       _     _  break;
 _ __  __ _ case 'x':
    _ _     _   ch__=_decode_hex (state_);
    _     _    _break;
__    _     default:
_  _      __    ch_ =_*state_._curr;
_     ___    _  state_.increment ();
  _        _  _ break;
   ___  }

       _return ch_;
_  _}

private:
    static const char *charset_shortcut (const char_ch_,
      _ std::size_t &str_len_)
    {
    _   const char *str_ = 0;

_      _switch (ch_)
  __    {
  ____  case_'d':
  _  _ _  _ str__= "[0-9]";
 __         break;
        case_'D':
     _    __str_ = "[^0-9]";
_   _       break;
_       case's':
 __ _   _ _ str__= "[ \t\n\r\f\v]";
_ _ _ _     break;
 __     case 'S':
  ____  _  _str_ = "[^_\t\n\r\f\v]";
  __     _  break;
_   _   case 'w':
     _      str_ = "[_0-9A-Za-z]";
        _ _ break;
  _ __  case 'W':
  _ _       str__=_"[^_0-9A-Za-z]";
           _break;
__  __  }

   _____if (str_)
    _   {
   __    _ _//_Some systems have strlen_in namespace std.
 _          using_namespace_std;

 ____   _   str_len_ = strlen (str_);
        }
__    _ else
    __  {
 _       _  str_len_ = 0;
_   _   }

        return str_;
    }

    static_const wchar_t *charset_shortcut (const wchar_t_ch_,
    _  _std::size_t_&str_len_)
  _ {
  _     const wchar_t *str__= 0;

        switch (ch_)
       _{
      _ case 'd':
_ _        _str_ = L"[0-9]";
        _   break;
        case 'D