开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
syntax2.h
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：31k
源码类别：

模拟服务器

开发平台：

C/C++

syntax2.h：源码内容
  1. //+---------------------------------------------------------------------------
  2. //
  3. //  Copyright ( C ) Microsoft Corporation, 1994 - 2002.
  4. //
  5. //  File:       syntax2.h
  6. //
  7. //  Contents:   syntax modules for regexpr
  8. //
  9. //  Classes:    perl_syntax, posix_syntax
  10. //
  11. //  Author:     Eric Niebler ( ericne@microsoft.com )
  12. //
  13. //  History:    3-29-00   ericne   Created
  14. //
  15. //----------------------------------------------------------------------------
  17. #ifndef SYNTAX_H
  18. #define SYNTAX_H
  20. #ifdef _MSC_VER
  21. #pragma warning( push )
  22. // warning C4514: '' unreferenced inline function has been removed
  23. // warning C4786: identifier was truncated to '255' characters in the debug information
  24. #pragma warning( disable : 4514 4786 )
  25. #endif
  27. #include <map>
  28. #include <iosfwd>
  29. #include <string>
  30. #include <cctype>
  31. #include <cwctype>
  32. #include <cassert>
  33. #include <iterator>
  34. #include <stdexcept>
  36. #ifndef ARRAYSIZE
  37. # define ARRAYSIZE( a ) (sizeof(a)/sizeof((a)[0]))
  38. #endif
  40. #ifndef UCHAR_MAX
  41. # define UCHAR_MAX 0xff
  42. #endif
  44. #ifndef WCHAR_MAX
  45. # define WCHAR_MAX ( (wchar_t )-1 )
  46. #endif
  48. #if defined(_MSC_VER) & _MSC_VER >= 1300
  49. # define REGEX_DEPRECATED  __declspec(deprecated)
  50. # define REGEX_NOINLINE    __declspec(noinline)
  51. # define REGEX_FORCEINLINE __forceinline
  52. # define REGEX_SELECTANY   __declspec(selectany)
  53. # define REGEX_CDECL       __cdecl
  54. #elif defined(_MSC_VER) & _MSC_VER < 1300
  55. # define REGEX_DEPRECATED
  56. # define REGEX_NOINLINE
  57. # define REGEX_FORCEINLINE __forceinline
  58. # define REGEX_SELECTANY   __declspec(selectany)
  59. # define REGEX_CDECL       __cdecl
  60. #else
  61. # define REGEX_DEPRECATED
  62. # define REGEX_NOINLINE
  63. # define REGEX_FORCEINLINE inline
  64. # define REGEX_SELECTANY
  65. # define REGEX_CDECL
  66. #endif
  68. #define REGEX_STRING(CH,sz) (::regex::detail::literal<CH>::string( sz, L##sz ))
  69. #define REGEX_CHAR(CH,ch) (static_cast<CH>(::regex::detail::literal<CH>::template character<ch,L##ch>::value))
  71. #ifdef _MSC_VER
  72. namespace std
  73. {
  74. template<>
  75. struct iterator_traits< char * >
  76. {    // get traits from iterator _Iter
  77.     typedef random_access_iterator_tag iterator_category;
  78.     typedef char value_type;
  79.     typedef ptrdiff_t difference_type;
  80.     typedef difference_type distance_type;    // retained
  81.     typedef char * pointer;
  82.     typedef char & reference;
  83. };
  84. template<>
  85. struct iterator_traits< char const * >
  86. {    // get traits from iterator _Iter
  87.     typedef random_access_iterator_tag iterator_category;
  88.     typedef char value_type;
  89.     typedef ptrdiff_t difference_type;
  90.     typedef difference_type distance_type;    // retained
  91.     typedef char * pointer;
  92.     typedef char & reference;
  93. };
  95. template<>
  96. struct iterator_traits< wchar_t * >
  97. {    // get traits from iterator _Iter
  98.     typedef random_access_iterator_tag iterator_category;
  99.     typedef wchar_t value_type;
  100.     typedef ptrdiff_t difference_type;
  101.     typedef difference_type distance_type;    // retained
  102.     typedef wchar_t * pointer;
  103.     typedef wchar_t & reference;
  104. };
  105. template<>
  106. struct iterator_traits< wchar_t const * >
  107. {    // get traits from iterator _Iter
  108.     typedef random_access_iterator_tag iterator_category;
  109.     typedef wchar_t value_type;
  110.     typedef ptrdiff_t difference_type;
  111.     typedef difference_type distance_type;    // retained
  112.     typedef wchar_t * pointer;
  113.     typedef wchar_t & reference;
  114. };
  116. #if _MSC_VER < 1300 & ( !defined(_CPPLIB_VER) | _CPPLIB_VER < 308 )
  117. #pragma warning( push )
  118. #pragma warning( disable : 4601 )
  119. #pragma push_macro("max")
  120. #pragma push_macro("min")
  121. #undef max
  122. #undef min
  124. template< typename T >
  125. T const & max( T const & l, T const & r )
  126. {
  127.     return _cpp_max( l, r );
  128. }
  129. template< typename T >
  130. T const & min( T const & l, T const & r )
  131. {
  132.     return _cpp_min( l, r );
  133. }
  135. #pragma pop_macro("min")
  136. #pragma pop_macro("max")
  137. #pragma warning( pop )
  138. #endif
  140. }
  141. #endif
  143. namespace regex
  144. {
  146. class bad_regexpr : public std::invalid_argument
  147. {
  148. public:
  149.     explicit bad_regexpr( std::string const & s )
  150.         : std::invalid_argument( s ) {}
  151.     virtual ~bad_regexpr() throw() {}
  152. };
  154. //
  155. // Flags to control how matching occurs
  156. //
  157. enum REGEX_FLAGS
  158. {
  159.     NOFLAGS       = 0x0000,
  160.     NOCASE        = 0x0001, // ignore case
  161.     GLOBAL        = 0x0002, // match everywhere in the string
  162.     MULTILINE     = 0x0004, // ^ and $ can match internal line breaks
  163.     SINGLELINE    = 0x0008, // . can match newline character
  164.     RIGHTMOST     = 0x0010, // start matching at the right of the string
  165.     NOBACKREFS    = 0x0020, // only meaningful when used with GLOBAL and substitute
  166.     FIRSTBACKREFS = 0x0040, // only meaningful when used with GLOBAL
  167.     ALLBACKREFS   = 0x0080, // only meaningful when used with GLOBAL
  168.     NORMALIZE     = 0x0100, // Preprocess patterns: "\n" => "n", etc.
  169.     EXTENDED      = 0x0200, // ignore whitespace in pattern
  170. };
  172. // For backwards compatibility
  173. REGEX_FLAGS const noflags = NOFLAGS;
  175. // helper functions to make it easier to combine
  176. // the regex flags.
  177. inline REGEX_FLAGS operator|( REGEX_FLAGS f1, REGEX_FLAGS f2 )
  178. {
  179.     return ( REGEX_FLAGS ) ( ( unsigned )f1 | ( unsigned )f2 );
  180. }
  181. inline REGEX_FLAGS & operator|=( REGEX_FLAGS & f1, REGEX_FLAGS f2 )
  182. {
  183.     return f1 = ( f1 | f2 );
  184. }
  185. inline REGEX_FLAGS operator&( REGEX_FLAGS f1, REGEX_FLAGS f2 )
  186. {
  187.     return ( REGEX_FLAGS ) ( ( unsigned )f1 & ( unsigned )f2 );
  188. }
  189. inline REGEX_FLAGS & operator&=( REGEX_FLAGS & f1, REGEX_FLAGS f2 )
  190. {
  191.     return f1 = ( f1 & f2 );
  192. }
  193. #if !defined(_MSC_VER) | _MSC_VER >= 1300
  194. inline REGEX_FLAGS operator~( REGEX_FLAGS f )
  195. {
  196.     return ( REGEX_FLAGS ) ~( unsigned )f;
  197. }
  198. #endif
  200. //
  201. // The following are the tokens that can be emitted by the syntax module.
  202. // Don't reorder this list!!!
  203. //
  204. enum TOKEN
  205. {
  206.     NO_TOKEN = 0,
  208.     // REGULAR TOKENS
  209.     BEGIN_GROUP,
  210.     END_GROUP,
  211.     ALTERNATION,
  212.     BEGIN_LINE,
  213.     END_LINE,
  214.     BEGIN_CHARSET,
  215.     MATCH_ANY,
  216.     ESCAPE,
  218.     // QUANTIFICATION TOKENS
  219.     ONE_OR_MORE,
  220.     ZERO_OR_MORE,
  221.     ZERO_OR_ONE,
  222.     ONE_OR_MORE_MIN,
  223.     ZERO_OR_MORE_MIN,
  224.     ZERO_OR_ONE_MIN,
  225.     BEGIN_RANGE,
  226.     RANGE_SEPARATOR,
  227.     END_RANGE,
  228.     END_RANGE_MIN,
  230.     // ESCAPE SEQUENCES
  231.     ESC_DIGIT,
  232.     ESC_NOT_DIGIT,
  233.     ESC_SPACE,
  234.     ESC_NOT_SPACE,
  235.     ESC_WORD,
  236.     ESC_NOT_WORD,
  237.     ESC_BEGIN_STRING,
  238.     ESC_END_STRING,
  239.     ESC_END_STRING_z,
  240.     ESC_WORD_BOUNDARY,
  241.     ESC_NOT_WORD_BOUNDARY,
  242.     ESC_WORD_START,
  243.     ESC_WORD_STOP,
  244.     ESC_QUOTE_META_ON,
  245.     ESC_QUOTE_META_OFF,
  247.     // SUBSTITUTION TOKENS
  248.     SUBST_BACKREF,
  249.     SUBST_PREMATCH,
  250.     SUBST_POSTMATCH,
  251.     SUBST_MATCH,
  252.     SUBST_ESCAPE,
  253.     SUBST_QUOTE_META_ON,
  254.     SUBST_UPPER_ON,
  255.     SUBST_UPPER_NEXT,
  256.     SUBST_LOWER_ON,
  257.     SUBST_LOWER_NEXT,
  258.     SUBST_ALL_OFF,
  260.     // CHARSET TOKENS
  261.     CHARSET_NEGATE,
  262.     CHARSET_ESCAPE,
  263.     CHARSET_RANGE,
  264.     CHARSET_BACKSPACE,
  265.     CHARSET_END,
  266.     CHARSET_ALNUM,
  267.     CHARSET_NOT_ALNUM,
  268.     CHARSET_ALPHA,
  269.     CHARSET_NOT_ALPHA,
  270.     CHARSET_BLANK,
  271.     CHARSET_NOT_BLANK,
  272.     CHARSET_CNTRL,
  273.     CHARSET_NOT_CNTRL,
  274.     CHARSET_DIGIT,
  275.     CHARSET_NOT_DIGIT,
  276.     CHARSET_GRAPH,
  277.     CHARSET_NOT_GRAPH,
  278.     CHARSET_LOWER,
  279.     CHARSET_NOT_LOWER,
  280.     CHARSET_PRINT,
  281.     CHARSET_NOT_PRINT,
  282.     CHARSET_PUNCT,
  283.     CHARSET_NOT_PUNCT,
  284.     CHARSET_SPACE,
  285.     CHARSET_NOT_SPACE,
  286.     CHARSET_UPPER,
  287.     CHARSET_NOT_UPPER,
  288.     CHARSET_XDIGIT,
  289.     CHARSET_NOT_XDIGIT,
  291.     // EXTENSION TOKENS
  292.     EXT_NOBACKREF,
  293.     EXT_POS_LOOKAHEAD,
  294.     EXT_NEG_LOOKAHEAD,
  295.     EXT_POS_LOOKBEHIND,
  296.     EXT_NEG_LOOKBEHIND,
  297.     EXT_INDEPENDENT,
  298.     EXT_COMMENT,
  299.     EXT_CONDITION,
  300.     EXT_RECURSE,
  301.     EXT_UNKNOWN
  302. };
  305. namespace detail
  306. {
  308. template< typename CH > struct literal;
  310. template<> struct literal<char>
  311. {
  312.     static char const * string( char const * sz, wchar_t const * ) { return sz; }
  313.     template<char ch,wchar_t> struct character { enum { value = ch }; };
  314. };
  316. template<> struct literal<wchar_t>
  317. {
  318.     static wchar_t const * string( char const *, wchar_t const * sz ) { return sz; }
  319.     template<char,wchar_t ch> struct character { enum { value = ch }; };
  320. };
  322. struct posix_charset_type
  323. {
  324.     char const * szcharset;
  325.     size_t       cchars;
  326. };
  328. extern posix_charset_type const g_rgposix_charsets[];
  329. extern size_t const g_cposix_charsets;
  331. template< typename CI >
  332. bool is_posix_charset( CI icur, CI iend, char const * szcharset )
  333. {
  334.     for( ; iend != icur && '' != *szcharset; ++icur, ++szcharset )
  335.     {
  336.         if( *icur != *szcharset )
  337.             return false;
  338.     }
  339.     return '' == *szcharset;
  340. }
  342. // Forward-declare the class that holds all the information
  343. // about the set of characters that can be matched by a charset
  344. struct charset;
  345. void free_charset( charset const * );
  347. template< typename CH >
  348. struct charset_map_node
  349. {
  350.     std::basic_string<CH> m_str;
  351.     charset const * m_rgcharsets[2]; // 0==case, 1==nocase
  353.     charset_map_node()
  354.     {
  355.         m_rgcharsets[0] = m_rgcharsets[1] = NULL;
  356.     }
  358.     charset_map_node( charset_map_node const & node )
  359.     {
  360.         *this = node;
  361.     }
  363.     charset_map_node & operator=( charset_map_node const & node )
  364.     {
  365.         m_str = node.m_str;
  366.         m_rgcharsets[0] = node.m_rgcharsets[0];
  367.         m_rgcharsets[1] = node.m_rgcharsets[1];
  368.         return *this;
  369.     }
  371.     void set( std::basic_string<CH> const & str )
  372.     {
  373.         clear();
  374.         m_str = str;
  375.     }
  377.     void clear()
  378.     {
  379.         std::basic_string<CH>().swap( m_str );
  380.         free_charset( m_rgcharsets[0] );
  381.         free_charset( m_rgcharsets[1] );
  382.         m_rgcharsets[0] = m_rgcharsets[1] = NULL;
  383.     }
  384. };
  386. template< typename CH >
  387. class charset_map
  388. {
  389.     std::map<CH, charset_map_node<CH> > m_map;
  390. public:
  391.     typedef typename std::map<CH, charset_map_node<CH> >::iterator iterator;
  392.     ~charset_map()
  393.     {
  394.         for( iterator iter = m_map.begin(); m_map.end() != iter; ++iter )
  395.             iter->second.clear();
  396.     }
  397.     charset_map_node<CH> & operator[]( CH ch ) { return m_map[ ch ]; }
  398.     iterator begin() { return m_map.begin(); }
  399.     iterator end() { return m_map.end(); }
  400.     iterator find( CH ch ) { return m_map.find( ch ); }
  401.     void erase( iterator iter ) { m_map.erase( iter ); }
  402. };
  404. inline bool regex_isspace( char ch )
  405. {
  406.     return 0 != isspace( ch );
  407. }
  409. inline bool regex_isspace( wchar_t wch )
  410. {
  411.     return 0 != iswspace( wch );
  412. }
  414. } // namespace detail
  416. //
  417. // The perl_syntax class encapsulates the Perl 5 regular expression syntax. It is
  418. // used as a template parameter to basic_rpattern.  To customize regex syntax, create
  419. // your own syntax class and use it as a template parameter instead.
  420. //
  422. class perl_syntax_base
  423. {
  424. protected:
  425.     perl_syntax_base()
  426.     {
  427.     }
  429.     static TOKEN const s_rgreg[ UCHAR_MAX + 1 ];
  430.     static TOKEN const s_rgescape[ UCHAR_MAX + 1 ];
  432.     static TOKEN look_up(  char   ch, TOKEN const rg[] )
  433.     {
  434.         return rg[ static_cast<unsigned char>( ch ) ];
  435.     }
  436.     
  437.     static TOKEN look_up( wchar_t ch, TOKEN const rg[] )
  438.     {
  439.         return UCHAR_MAX < ch ? NO_TOKEN : rg[ static_cast<unsigned char>( ch ) ];
  440.     }
  441. };
  443. // --------------------------------------------------------------------------
  444. //
  445. // Class:       perl_syntax
  446. //
  447. // Description: Module that encapsulates the Perl syntax
  448. //
  449. // Methods:     eat_whitespace             -
  450. //              min_quant                  -
  451. //              perl_syntax                -
  452. //              perl_syntax                -
  453. //              set_flags                  -
  454. //              get_flags                  -
  455. //              reg_token                  -
  456. //              quant_token                -
  457. //              charset_token              -
  458. //              subst_token                -
  459. //              ext_token                  -
  460. //              invalid_charset            -
  461. //              register_intrinsic_charset -
  462. //              _invalid_charset           -
  463. //              _invalid_charset           -
  464. //
  465. // Members:     m_flags                    -
  466. //              s_charset_map              -
  467. //
  468. // Typedefs:    iterator                   -
  469. //              const_iterator             -
  470. //              char_type                  -
  471. //
  472. // History:     11/16/2001 - ericne - Created
  473. //
  474. // --------------------------------------------------------------------------
  475. template< typename CH >
  476. class perl_syntax : protected perl_syntax_base
  477. {
  478. public:
  479.     typedef typename std::basic_string<CH>::iterator iterator;
  480.     typedef typename std::basic_string<CH>::const_iterator const_iterator;
  481.     typedef CH char_type;
  482.     template< typename CH2 > struct rebind { typedef perl_syntax<CH2> other; };
  484. private:
  485.     REGEX_FLAGS m_flags;
  487.     const_iterator eat_whitespace( iterator & icur, const_iterator iend )
  488.     {
  489.         if( m_flags & EXTENDED )
  490.         {
  491.             while( iend != icur && ( REGEX_CHAR(CH,'#') == *icur || detail::regex_isspace( *icur ) ) )
  492.             {
  493.                 if( REGEX_CHAR(CH,'#') == *icur++ )
  494.                 {
  495.                     while( iend != icur && REGEX_CHAR(CH,'n') != *icur++ );
  496.                 }
  497.                 else
  498.                 {
  499.                     for( ; iend != icur && detail::regex_isspace( *icur ); ++icur );
  500.                 }
  501.             }
  502.         }
  503.         return icur;
  504.     }
  506.     bool min_quant( iterator & icur, const_iterator iend )
  507.     {
  508.         return ( iend != eat_whitespace( ++icur, iend ) && REGEX_CHAR(CH,'?') == *icur ? ( ++icur, true ) : false );
  509.     }
  511. public:
  513.     perl_syntax( REGEX_FLAGS flags )
  514.         : m_flags( flags )
  515.     {
  516.     }
  518.     perl_syntax( perl_syntax<CH> const & sy )
  519.         : m_flags( sy.m_flags )
  520.     {
  521.     }
  523.     void set_flags( REGEX_FLAGS flags )
  524.     {
  525.         m_flags = flags;
  526.     }
  528.     REGEX_FLAGS get_flags() const
  529.     {
  530.         return m_flags;
  531.     }
  533.     TOKEN reg_token( iterator & icur, const_iterator iend )
  534.     {
  535.         assert( iend != icur );
  536.         if( iend == eat_whitespace( icur, iend ) )
  537.             return NO_TOKEN;
  538.         TOKEN tok = look_up( *icur, s_rgreg );
  539.         if( tok )
  540.             ++icur;
  541.         if( ESCAPE == tok && iend != icur )
  542.         {
  543.             tok = look_up( *icur, s_rgescape );
  544.             if( tok )
  545.                 ++icur;
  546.             else
  547.                 tok = ESCAPE;
  548.         }
  549.         return tok;
  550.     }
  551.     TOKEN quant_token( iterator & icur, const_iterator iend )
  552.     {
  553.         assert( iend != icur );
  554.         if( iend == eat_whitespace( icur, iend ) )
  555.             return NO_TOKEN;
  556.         TOKEN tok = NO_TOKEN;
  557.         switch( *icur )
  558.         {
  559.         case REGEX_CHAR(CH,'*'):
  560.             tok = min_quant( icur, iend ) ? ZERO_OR_MORE_MIN : ZERO_OR_MORE;
  561.             break;
  562.         case REGEX_CHAR(CH,'+'):
  563.             tok = min_quant( icur, iend ) ? ONE_OR_MORE_MIN : ONE_OR_MORE;
  564.             break;
  565.         case REGEX_CHAR(CH,'?'):
  566.             tok = min_quant( icur, iend ) ? ZERO_OR_ONE_MIN : ZERO_OR_ONE;
  567.             break;
  568.         case REGEX_CHAR(CH,'}'):
  569.             tok = min_quant( icur, iend ) ? END_RANGE_MIN : END_RANGE;
  570.             break;
  571.         case REGEX_CHAR(CH,'{'):
  572.             tok = BEGIN_RANGE;
  573.             ++icur;
  574.             break;
  575.         case REGEX_CHAR(CH,','):
  576.             tok = RANGE_SEPARATOR;
  577.             ++icur;
  578.             break;
  579.         }
  580.         return tok;
  581.     }
  582.     TOKEN charset_token( iterator & icur, const_iterator iend )
  583.     {
  584.         assert( iend != icur );
  585.         TOKEN tok = NO_TOKEN;
  586.         switch( *icur )
  587.         {
  588.         case REGEX_CHAR(CH,'-'):
  589.             tok = CHARSET_RANGE;
  590.             ++icur;
  591.             break;
  592.         case REGEX_CHAR(CH,'^'):
  593.             tok = CHARSET_NEGATE;
  594.             ++icur;
  595.             break;
  596.         case REGEX_CHAR(CH,']'):
  597.             tok = CHARSET_END;
  598.             ++icur;
  599.             break;
  600.         case REGEX_CHAR(CH,'\'):
  601.             tok = CHARSET_ESCAPE;
  602.             if( iend == ++icur )
  603.                 break;
  604.             switch( *icur )
  605.             {
  606.             case REGEX_CHAR(CH,'b'):
  607.                 tok = CHARSET_BACKSPACE;
  608.                 ++icur;
  609.                 break;
  610.             case REGEX_CHAR(CH,'d'):
  611.                 tok = ESC_DIGIT;
  612.                 ++icur;
  613.                 break;
  614.             case REGEX_CHAR(CH,'D'):
  615.                 tok = ESC_NOT_DIGIT;
  616.                 ++icur;
  617.                 break;
  618.             case REGEX_CHAR(CH,'s'):
  619.                 tok = ESC_SPACE;
  620.                 ++icur;
  621.                 break;
  622.             case REGEX_CHAR(CH,'S'):
  623.                 tok = ESC_NOT_SPACE;
  624.                 ++icur;
  625.                 break;
  626.             case REGEX_CHAR(CH,'w'):
  627.                 tok = ESC_WORD;
  628.                 ++icur;
  629.                 break;
  630.             case REGEX_CHAR(CH,'W'):
  631.                 tok = ESC_NOT_WORD;
  632.                 ++icur;
  633.                 break;
  634.             }
  635.             break;
  636.         case REGEX_CHAR(CH,'['):
  637.             if( REGEX_CHAR(CH,':') == *( ++icur )-- )
  638.             {
  639.                 for( size_t i=0; !tok && i < detail::g_cposix_charsets; ++i )
  640.                 {
  641.                     if( detail::is_posix_charset<const_iterator>( icur, iend, detail::g_rgposix_charsets[i].szcharset ) )
  642.                     {
  643.                         tok = TOKEN( CHARSET_ALNUM + i );
  644.                         std::advance( icur, detail::g_rgposix_charsets[i].cchars );
  645.                     }
  646.                 }
  647.             }
  648.             break;
  649.         }
  650.         return tok;
  651.     }
  652.     TOKEN subst_token( iterator & icur, const_iterator iend )
  653.     {
  654.         assert( iend != icur );
  655.         TOKEN tok = NO_TOKEN;
  656.         switch( *icur )
  657.         {
  658.         case REGEX_CHAR(CH,'\'):
  659.             tok = SUBST_ESCAPE;
  660.             if( iend != ++icur )
  661.                 switch( *icur )
  662.                 {
  663.                 case REGEX_CHAR(CH,'Q'):
  664.                     tok = SUBST_QUOTE_META_ON;
  665.                     ++icur;
  666.                     break;
  667.                 case REGEX_CHAR(CH,'U'):
  668.                     tok = SUBST_UPPER_ON;
  669.                     ++icur;
  670.                     break;
  671.                 case REGEX_CHAR(CH,'u'):
  672.                     tok = SUBST_UPPER_NEXT;
  673.                     ++icur;
  674.                     break;
  675.                 case REGEX_CHAR(CH,'L'):
  676.                     tok = SUBST_LOWER_ON;
  677.                     ++icur;
  678.                     break;
  679.                 case REGEX_CHAR(CH,'l'):
  680.                     tok = SUBST_LOWER_NEXT;
  681.                     ++icur;
  682.                     break;
  683.                 case REGEX_CHAR(CH,'E'):
  684.                     tok = SUBST_ALL_OFF;
  685.                     ++icur;
  686.                     break;
  687.                 }
  688.             break;
  689.         case REGEX_CHAR(CH,'$'):
  690.             tok = SUBST_BACKREF;
  691.             if( iend != ++icur )
  692.                 switch( *icur )
  693.                 {
  694.                 case REGEX_CHAR(CH,'&'):
  695.                     tok = SUBST_MATCH;
  696.                     ++icur;
  697.                     break;
  698.                 case REGEX_CHAR(CH,'`'):
  699.                     tok = SUBST_PREMATCH;
  700.                     ++icur;
  701.                     break;
  702.                 case REGEX_CHAR(CH,'''):
  703.                     tok = SUBST_POSTMATCH;
  704.                     ++icur;
  705.                     break;
  706.                 }
  707.             break;
  708.         }
  709.         return tok;
  710.     }
  711.     TOKEN ext_token( iterator & icur, const_iterator iend )
  712.     {
  713.         assert( iend != icur );
  714.         if( iend == eat_whitespace( icur, iend ) )
  715.             return NO_TOKEN;
  716.         bool finclude;
  717.         TOKEN tok = NO_TOKEN;
  718.         if( REGEX_CHAR(CH,'?') == *icur )
  719.         {
  720.             tok = EXT_UNKNOWN;
  721.             ++icur;
  722.             if( m_flags & EXTENDED )
  723.                 for( ; iend != icur && detail::regex_isspace( *icur ); ++icur );
  724.             if( iend != icur )
  725.             {
  726.                 switch( *icur )
  727.                 {
  728.                 case REGEX_CHAR(CH,':'):
  729.                     tok = EXT_NOBACKREF;
  730.                     ++icur;
  731.                     break;
  732.                 case REGEX_CHAR(CH,'='):
  733.                     tok = EXT_POS_LOOKAHEAD;
  734.                     ++icur;
  735.                     break;
  736.                 case REGEX_CHAR(CH,'!'):
  737.                     tok = EXT_NEG_LOOKAHEAD;
  738.                     ++icur;
  739.                     break;
  740.                 case REGEX_CHAR(CH,'#'):
  741.                     tok = EXT_COMMENT;
  742.                     ++icur;
  743.                     break;
  744.                 case REGEX_CHAR(CH,'('):
  745.                     tok = EXT_CONDITION;
  746.                     ++icur;
  747.                     break;
  748.                 case REGEX_CHAR(CH,'R'):
  749.                     tok = EXT_RECURSE;
  750.                     ++icur;
  751.                     break;
  752.                 case REGEX_CHAR(CH,'<'):
  753.                     if( iend == eat_whitespace( ++icur, iend ) )
  754.                         break;
  755.                     switch( *icur )
  756.                     {
  757.                     case REGEX_CHAR(CH,'='):
  758.                         tok = EXT_POS_LOOKBEHIND;
  759.                         ++icur;
  760.                         break;
  761.                     case REGEX_CHAR(CH,'!'):
  762.                         tok = EXT_NEG_LOOKBEHIND;
  763.                         ++icur;
  764.                         break;
  765.                     }
  766.                     break;
  767.                 case REGEX_CHAR(CH,'>'):
  768.                     tok = EXT_INDEPENDENT;
  769.                     ++icur;
  770.                     break;
  771.                 default:
  772.                     finclude = true;
  773.                     do
  774.                     {
  775.                         if( REGEX_CHAR(CH,':') == *icur )
  776.                         {
  777.                             tok = EXT_NOBACKREF;
  778.                             ++icur;
  779.                             break;
  780.                         }
  781.                         if( REGEX_CHAR(CH,')') == *icur )
  782.                         {
  783.                             tok = EXT_NOBACKREF;
  784.                             break;
  785.                         }
  786.                         if( REGEX_CHAR(CH,'-') == *icur && finclude )
  787.                             finclude = false;
  788.                         else if( REGEX_CHAR(CH,'i') == *icur )
  789.                             m_flags = ( REGEX_FLAGS ) ( finclude ? ( m_flags | NOCASE )     : ( m_flags & ~NOCASE ) );
  790.                         else if( REGEX_CHAR(CH,'m') == *icur )
  791.                             m_flags = ( REGEX_FLAGS ) ( finclude ? ( m_flags | MULTILINE )  : ( m_flags & ~MULTILINE ) );
  792.                         else if( REGEX_CHAR(CH,'s') == *icur )
  793.                             m_flags = ( REGEX_FLAGS ) ( finclude ? ( m_flags | SINGLELINE ) : ( m_flags & ~SINGLELINE ) );
  794.                         else if( REGEX_CHAR(CH,'x') == *icur )
  795.                             m_flags = ( REGEX_FLAGS ) ( finclude ? ( m_flags | EXTENDED )   : ( m_flags & ~EXTENDED ) );
  796.                         else
  797.                             break;
  798.                     } while( iend != eat_whitespace( ++icur, iend ) );
  799.                     break;
  800.                 }
  801.             }
  802.         }
  803.         return tok;
  804.     }
  806.     // Functions used for making user-defined intrinsic character sets
  807.     static detail::charset_map<CH> s_charset_map;
  809.     static bool invalid_charset( CH ch )
  810.     {
  811.         return _invalid_charset( ch );
  812.     }
  813.     static void register_intrinsic_charset( CH ch, std::basic_string<CH> const & str ) //throw( bad_regexpr, std::bad_alloc )
  814.     {
  815.         perl_syntax sy( NOFLAGS );
  816.         if( invalid_charset( ch ) )
  817.             throw bad_regexpr( "invalid character specified to register_intrinsic_charset" );
  818.         std::basic_string<CH> pat = str;
  819.         typename std::basic_string<CH>::iterator istart = pat.begin();
  820.         if( BEGIN_CHARSET != sy.reg_token( istart, pat.end() ) )
  821.             throw bad_regexpr( "expecting beginning of charset" );
  822.         regex::detail::charset_map<CH> & charset_map = s_charset_map;
  823.         regex::detail::charset_map_node<CH> & map_node = charset_map[ ch ];
  824.         map_node.set( std::basic_string<CH>( istart, pat.end() ) );
  825.     }
  826.  private:
  827.     static bool _invalid_charset( char ch )
  828.     {
  829.         return NO_TOKEN != s_rgescape[ static_cast<unsigned char>( ch ) ]
  830.             || isdigit( ch ) || 'e' == ch || 'x' == ch || 'c' == ch;
  831.     }
  832.     static bool _invalid_charset( wchar_t ch )
  833.     {
  834.         return UCHAR_MAX >= ch && _invalid_charset( static_cast<char>( ch ) );
  835.     }
  836. };
  838. template< typename CH >
  839. detail::charset_map<CH> perl_syntax<CH>::s_charset_map;
  841. // --------------------------------------------------------------------------
  842. //
  843. // Class:       posix_syntax
  844. //
  845. // Description: Implements the basic POSIX regular expression syntax
  846. //
  847. // Methods:     posix_syntax               -
  848. //              posix_syntax               -
  849. //              get_flags                  -
  850. //              set_flags                  -
  851. //              reg_token                  -
  852. //              quant_token                -
  853. //              charset_token              -
  854. //              subst_token                -
  855. //              ext_token                  -
  856. //              invalid_charset            -
  857. //              register_intrinsic_charset -
  858. //
  859. // Members:     m_flags                    -
  860. //              s_charset_map              -
  861. //
  862. // Typedefs:    iterator                   -
  863. //              const_iterator             -
  864. //              char_type                  -
  865. //
  866. // History:     11/16/2001 - ericne - Created
  867. //
  868. // --------------------------------------------------------------------------
  869. template< typename CH >
  870. class posix_syntax
  871. {
  872.     REGEX_FLAGS m_flags;
  874. public:
  875.     typedef typename std::basic_string<CH>::iterator iterator;
  876.     typedef typename std::basic_string<CH>::const_iterator const_iterator;
  877.     typedef CH char_type;
  878.     template< typename CH2 > struct rebind { typedef posix_syntax<CH2> other; };
  880.     posix_syntax( REGEX_FLAGS flags )
  881.         : m_flags( flags )
  882.     {
  883.     }
  885.     posix_syntax( posix_syntax<CH> const & sy )
  886.         : m_flags( sy.m_flags )
  887.     {
  888.     }
  890.     REGEX_FLAGS get_flags() const
  891.     {
  892.         return m_flags;
  893.     }
  895.     void set_flags( REGEX_FLAGS flags )
  896.     {
  897.         m_flags = flags;
  898.     }
  900.     TOKEN reg_token( iterator & icur, const_iterator iend )
  901.     {
  902.         TOKEN tok = NO_TOKEN;
  903.         switch( *icur )
  904.         {
  905.         case REGEX_CHAR(CH,'.'):
  906.             tok = MATCH_ANY;
  907.             ++icur;
  908.             break;
  909.         case REGEX_CHAR(CH,'^'):
  910.             tok = BEGIN_LINE;
  911.             ++icur;
  912.             break;
  913.         case REGEX_CHAR(CH,'$'):
  914.             tok = END_LINE;
  915.             ++icur;
  916.             break;
  917.         case REGEX_CHAR(CH,'['):
  918.             tok = BEGIN_CHARSET;
  919.             ++icur;
  920.             break;
  921.         case REGEX_CHAR(CH,'\'):
  922.             tok = ESCAPE;
  923.             ++icur;
  924.             if( iend != icur )
  925.             {
  926.                 switch( *icur )
  927.                 {
  928.                 case REGEX_CHAR(CH,'('):
  929.                     tok = BEGIN_GROUP;
  930.                     ++icur;
  931.                     break;
  932.                 case REGEX_CHAR(CH,')'):
  933.                     tok = END_GROUP;
  934.                     ++icur;
  935.                     break;
  936.                 case REGEX_CHAR(CH,'|'):
  937.                     tok = ALTERNATION;
  938.                     ++icur;
  939.                     break;
  940.                 }
  941.             }
  942.             break;
  943.         }
  944.         return tok;
  945.     }
  946.     TOKEN quant_token( iterator & icur, const_iterator iend )
  947.     {
  948.         TOKEN tok = NO_TOKEN;
  949.         switch( *icur )
  950.         {
  951.         case REGEX_CHAR(CH,'*'):
  952.             tok = ZERO_OR_MORE;
  953.             ++icur;
  954.             break;
  955.         case REGEX_CHAR(CH,','):
  956.             tok = RANGE_SEPARATOR;
  957.             ++icur;
  958.             break;
  959.         case REGEX_CHAR(CH,'\'):
  960.             ++icur;
  961.             if( iend != icur )
  962.             {
  963.                 switch( *icur )
  964.                 {
  965.                 case REGEX_CHAR(CH,'?'):
  966.                     tok = ZERO_OR_ONE;
  967.                     ++icur;
  968.                     break;
  969.                 case REGEX_CHAR(CH,'+'):
  970.                     tok = ONE_OR_MORE;
  971.                     ++icur;
  972.                     break;
  973.                 case REGEX_CHAR(CH,'{'):
  974.                     tok = BEGIN_RANGE;
  975.                     ++icur;
  976.                     break;
  977.                 case REGEX_CHAR(CH,'}'):
  978.                     tok = END_RANGE;
  979.                     ++icur;
  980.                     break;
  981.                 default:
  982.                     --icur;
  983.                     break;
  984.                 }
  985.             }
  986.             else
  987.             {
  988.                 --icur;
  989.             }
  990.         }
  991.         return tok;
  992.     }
  993.     TOKEN charset_token( iterator & icur, const_iterator iend )
  994.     {
  995.         TOKEN tok = NO_TOKEN;
  996.         switch( *icur )
  997.         {
  998.         case REGEX_CHAR(CH,'^'):
  999.             tok = CHARSET_NEGATE;
  1000.             ++icur;
  1001.             break;
  1002.         case REGEX_CHAR(CH,'-'):
  1003.             tok = CHARSET_RANGE;
  1004.             ++icur;
  1005.             break;
  1006.         case REGEX_CHAR(CH,']'):
  1007.             tok = CHARSET_END;
  1008.             ++icur;
  1009.             break;
  1010.         case REGEX_CHAR(CH,'['):
  1011.             if( REGEX_CHAR(CH,':') == *( ++icur )-- )
  1012.             {
  1013.                 for( size_t i=0; !tok && i < detail::g_cposix_charsets; ++i )
  1014.                 {
  1015.                     if( detail::is_posix_charset<const_iterator>( icur, iend, detail::g_rgposix_charsets[i].szcharset ) )
  1016.                     {
  1017.                         tok = TOKEN( CHARSET_ALNUM + i );
  1018.                         std::advance( icur, detail::g_rgposix_charsets[i].cchars );
  1019.                     }
  1020.                 }
  1021.             }
  1022.             break;
  1023.         }
  1024.         return tok;
  1025.     }
  1026.     TOKEN subst_token( iterator & icur, const_iterator iend )
  1027.     {
  1028.         TOKEN tok = NO_TOKEN;
  1029.         if( REGEX_CHAR(CH,'\') == *icur )
  1030.         {
  1031.             tok = SUBST_ESCAPE;
  1032.             ++icur;
  1033.             if( iend != icur && REGEX_CHAR(CH,'0') <= *icur && REGEX_CHAR(CH,'9') >= *icur )
  1034.             {
  1035.                 tok = SUBST_BACKREF;
  1036.             }
  1037.         }
  1038.         return tok;
  1039.     }
  1040.     TOKEN ext_token( iterator &, const_iterator )
  1041.     {
  1042.         return NO_TOKEN;
  1043.     }
  1045.     // Functions for making user-defined intrinsic character sets
  1046.     static detail::charset_map<CH> s_charset_map;
  1048.     static bool invalid_charset( CH ch )
  1049.     {
  1050.         return _invalid_charset( ch );
  1051.     }
  1052.     static void register_intrinsic_charset( CH ch, std::basic_string<CH> const & str ) //throw( bad_regexpr, std::bad_alloc )
  1053.     {
  1054.         posix_syntax sy( NOFLAGS );
  1055.         if( invalid_charset( ch ) )
  1056.             throw bad_regexpr( "invalid character specified to register_intrinsic_charset" );
  1057.         std::basic_string<CH> pat = str;
  1058.         typename std::basic_string<CH>::iterator istart = pat.begin();
  1059.         if( BEGIN_CHARSET != sy.reg_token( istart, pat.end() ) )
  1060.             throw bad_regexpr( "expecting beginning of charset" );
  1061.         regex::detail::charset_map<CH> & charset_map = s_charset_map;
  1062.         regex::detail::charset_map_node<CH> & map_node = charset_map[ ch ];
  1063.         map_node.set( std::basic_string<CH>( istart, pat.end() ) );
  1064.     }
  1065.  private:
  1066.     static bool _invalid_charset( char ch )
  1067.     {
  1068.         static char const s_invalid[] = "0123456789()|?+{}\exc";
  1069.         return NULL != std::char_traits<CH>::find( s_invalid, ARRAYSIZE( s_invalid ) - 1, ch );
  1070.     }
  1071.     static bool _invalid_charset( wchar_t ch )
  1072.     {
  1073.         return UCHAR_MAX >= ch && _invalid_charset( static_cast<char>( ch ) );
  1074.     }
  1075. };
  1077. template< typename CH >
  1078. detail::charset_map<CH> posix_syntax<CH>::s_charset_map;
  1080. } // namespace regex
  1082. #ifdef _MSC_VER
  1083. #pragma warning( pop )
  1084. #endif
  1086. #endif