Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-01-30 10:02:23 

0001 /*=============================================================================
0002     Boost.Wave: A Standard compliant C++ preprocessor library
0003     The definition of a default set of token identifiers and related
0004     functions.
0005 
0006     http://www.boost.org/
0007 
0008     Copyright (c) 2001-2012 Hartmut Kaiser. Distributed under the Boost
0009     Software License, Version 1.0. (See accompanying file
0010     LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0011 =============================================================================*/
0012 
0013 #if !defined(BOOST_TOKEN_IDS_HPP_414E9A58_F079_4789_8AFF_513815CE475B_INCLUDED)
0014 #define BOOST_TOKEN_IDS_HPP_414E9A58_F079_4789_8AFF_513815CE475B_INCLUDED
0015 
0016 #include <string>
0017 #include <cstdint>
0018 
0019 #include <boost/wave/wave_config.hpp>
0020 
0021 // this must occur after all of the includes and before any code appears
0022 #ifdef BOOST_HAS_ABI_HEADERS
0023 #include BOOST_ABI_PREFIX
0024 #endif
0025 
0026 ///////////////////////////////////////////////////////////////////////////////
0027 //  Allow external redefinition of the token identifiers to use
0028 #if !defined(BOOST_WAVE_TOKEN_IDS_DEFINED)
0029 #define BOOST_WAVE_TOKEN_IDS_DEFINED
0030 
0031 #if (defined (__FreeBSD__) || defined (__DragonFly__) || defined (__OpenBSD__)) && defined (T_DIVIDE)
0032 #undef T_DIVIDE
0033 #endif
0034 
0035 ///////////////////////////////////////////////////////////////////////////////
0036 namespace boost {
0037 namespace wave {
0038 
0039 ///////////////////////////////////////////////////////////////////////////////
0040 //  assemble tokenids
0041 #define TOKEN_FROM_ID(id, cat)   ((id) | (cat))
0042 #define ID_FROM_TOKEN(tok)       ((tok) & ~TokenTypeMask)
0043 #define BASEID_FROM_TOKEN(tok)   ((tok) & ~ExtTokenTypeMask)
0044 
0045 ///////////////////////////////////////////////////////////////////////////////
0046 //  the token_category helps to classify the different token types
0047 enum token_category : std::uint32_t {
0048     IdentifierTokenType         = 0x08040000,
0049     ParameterTokenType          = 0x08840000,
0050     ExtParameterTokenType       = 0x088C0000,
0051     OptParameterTokenType       = 0x08940000,
0052     KeywordTokenType            = 0x10040000,
0053     OperatorTokenType           = 0x18040000,
0054     LiteralTokenType            = 0x20040000,
0055     IntegerLiteralTokenType     = 0x20840000,
0056     FloatingLiteralTokenType    = 0x21040000,
0057     StringLiteralTokenType      = 0x21840000,
0058     CharacterLiteralTokenType   = 0x22040000,
0059     BoolLiteralTokenType        = 0x22840000,
0060     PPTokenType                 = 0x28040000,
0061     PPConditionalTokenType      = 0x28440000,
0062 
0063     UnknownTokenType            = 0x50000000,
0064     EOLTokenType                = 0x58000000,
0065     EOFTokenType                = 0x60000000,
0066     WhiteSpaceTokenType         = 0x68000000,
0067     InternalTokenType           = 0x70040000,
0068 
0069     TokenTypeMask               = 0x7F800000,
0070     AltTokenType                = 0x00080000,
0071     TriGraphTokenType           = 0x00100000,
0072     AltExtTokenType             = 0x00280000,   // and, bit_and etc.
0073     PPTokenFlag                 = 0x00040000,   // these are 'real' pp-tokens
0074     ExtTokenTypeMask            = 0x7FF80000,
0075     ExtTokenOnlyMask            = 0x00780000,
0076     TokenValueMask              = 0x0007FFFF,
0077     MainTokenMask               = 0x7F87FFFF    // TokenTypeMask|TokenValueMask
0078 };
0079 
0080 ///////////////////////////////////////////////////////////////////////////////
0081 //  the token_id assigns unique numbers to the different C++ lexemes
0082 enum token_id : std::uint32_t {
0083     T_UNKNOWN      = 0,
0084     T_FIRST_TOKEN  = 256,
0085     T_AND          = TOKEN_FROM_ID(T_FIRST_TOKEN, OperatorTokenType),
0086     T_AND_ALT      = TOKEN_FROM_ID(T_FIRST_TOKEN, OperatorTokenType|AltExtTokenType),
0087     T_ANDAND       = TOKEN_FROM_ID(257, OperatorTokenType),
0088     T_ANDAND_ALT   = TOKEN_FROM_ID(257, OperatorTokenType|AltExtTokenType),
0089     T_ASSIGN       = TOKEN_FROM_ID(258, OperatorTokenType),
0090     T_ANDASSIGN    = TOKEN_FROM_ID(259, OperatorTokenType),
0091     T_ANDASSIGN_ALT     = TOKEN_FROM_ID(259, OperatorTokenType|AltExtTokenType),
0092     T_OR           = TOKEN_FROM_ID(260, OperatorTokenType),
0093     T_OR_ALT       = TOKEN_FROM_ID(260, OperatorTokenType|AltExtTokenType),
0094     T_OR_TRIGRAPH  = TOKEN_FROM_ID(260, OperatorTokenType|TriGraphTokenType),
0095     T_ORASSIGN     = TOKEN_FROM_ID(261, OperatorTokenType),
0096     T_ORASSIGN_ALT          = TOKEN_FROM_ID(261, OperatorTokenType|AltExtTokenType),
0097     T_ORASSIGN_TRIGRAPH     = TOKEN_FROM_ID(261, OperatorTokenType|TriGraphTokenType),
0098     T_XOR          = TOKEN_FROM_ID(262, OperatorTokenType),
0099     T_XOR_ALT      = TOKEN_FROM_ID(262, OperatorTokenType|AltExtTokenType),
0100     T_XOR_TRIGRAPH = TOKEN_FROM_ID(262, OperatorTokenType|TriGraphTokenType),
0101     T_XORASSIGN    = TOKEN_FROM_ID(263, OperatorTokenType),
0102     T_XORASSIGN_ALT         = TOKEN_FROM_ID(263, OperatorTokenType|AltExtTokenType),
0103     T_XORASSIGN_TRIGRAPH    = TOKEN_FROM_ID(263, OperatorTokenType|TriGraphTokenType),
0104     T_COMMA        = TOKEN_FROM_ID(264, OperatorTokenType),
0105     T_COLON        = TOKEN_FROM_ID(265, OperatorTokenType),
0106     T_DIVIDE       = TOKEN_FROM_ID(266, OperatorTokenType),
0107     T_DIVIDEASSIGN = TOKEN_FROM_ID(267, OperatorTokenType),
0108     T_DOT          = TOKEN_FROM_ID(268, OperatorTokenType),
0109     T_DOTSTAR      = TOKEN_FROM_ID(269, OperatorTokenType),
0110     T_ELLIPSIS     = TOKEN_FROM_ID(270, OperatorTokenType),
0111     T_EQUAL        = TOKEN_FROM_ID(271, OperatorTokenType),
0112     T_GREATER      = TOKEN_FROM_ID(272, OperatorTokenType),
0113     T_GREATEREQUAL = TOKEN_FROM_ID(273, OperatorTokenType),
0114     T_LEFTBRACE    = TOKEN_FROM_ID(274, OperatorTokenType),
0115     T_LEFTBRACE_ALT         = TOKEN_FROM_ID(274, OperatorTokenType|AltTokenType),
0116     T_LEFTBRACE_TRIGRAPH    = TOKEN_FROM_ID(274, OperatorTokenType|TriGraphTokenType),
0117     T_LESS         = TOKEN_FROM_ID(275, OperatorTokenType),
0118     T_LESSEQUAL    = TOKEN_FROM_ID(276, OperatorTokenType),
0119     T_LEFTPAREN    = TOKEN_FROM_ID(277, OperatorTokenType),
0120     T_LEFTBRACKET  = TOKEN_FROM_ID(278, OperatorTokenType),
0121     T_LEFTBRACKET_ALT       = TOKEN_FROM_ID(278, OperatorTokenType|AltTokenType),
0122     T_LEFTBRACKET_TRIGRAPH  = TOKEN_FROM_ID(278, OperatorTokenType|TriGraphTokenType),
0123     T_MINUS        = TOKEN_FROM_ID(279, OperatorTokenType),
0124     T_MINUSASSIGN  = TOKEN_FROM_ID(280, OperatorTokenType),
0125     T_MINUSMINUS   = TOKEN_FROM_ID(281, OperatorTokenType),
0126     T_PERCENT      = TOKEN_FROM_ID(282, OperatorTokenType),
0127     T_PERCENTASSIGN = TOKEN_FROM_ID(283, OperatorTokenType),
0128     T_NOT          = TOKEN_FROM_ID(284, OperatorTokenType),
0129     T_NOT_ALT      = TOKEN_FROM_ID(284, OperatorTokenType|AltExtTokenType),
0130     T_NOTEQUAL     = TOKEN_FROM_ID(285, OperatorTokenType),
0131     T_NOTEQUAL_ALT      = TOKEN_FROM_ID(285, OperatorTokenType|AltExtTokenType),
0132     T_OROR         = TOKEN_FROM_ID(286, OperatorTokenType),
0133     T_OROR_ALT     = TOKEN_FROM_ID(286, OperatorTokenType|AltExtTokenType),
0134     T_OROR_TRIGRAPH     = TOKEN_FROM_ID(286, OperatorTokenType|TriGraphTokenType),
0135     T_PLUS         = TOKEN_FROM_ID(287, OperatorTokenType),
0136     T_PLUSASSIGN   = TOKEN_FROM_ID(288, OperatorTokenType),
0137     T_PLUSPLUS     = TOKEN_FROM_ID(289, OperatorTokenType),
0138     T_ARROW        = TOKEN_FROM_ID(290, OperatorTokenType),
0139     T_ARROWSTAR    = TOKEN_FROM_ID(291, OperatorTokenType),
0140     T_QUESTION_MARK = TOKEN_FROM_ID(292, OperatorTokenType),
0141     T_RIGHTBRACE   = TOKEN_FROM_ID(293, OperatorTokenType),
0142     T_RIGHTBRACE_ALT        = TOKEN_FROM_ID(293, OperatorTokenType|AltTokenType),
0143     T_RIGHTBRACE_TRIGRAPH   = TOKEN_FROM_ID(293, OperatorTokenType|TriGraphTokenType),
0144     T_RIGHTPAREN   = TOKEN_FROM_ID(294, OperatorTokenType),
0145     T_RIGHTBRACKET = TOKEN_FROM_ID(295, OperatorTokenType),
0146     T_RIGHTBRACKET_ALT      = TOKEN_FROM_ID(295, OperatorTokenType|AltTokenType),
0147     T_RIGHTBRACKET_TRIGRAPH = TOKEN_FROM_ID(295, OperatorTokenType|TriGraphTokenType),
0148     T_COLON_COLON  = TOKEN_FROM_ID(296, OperatorTokenType),
0149     T_SEMICOLON    = TOKEN_FROM_ID(297, OperatorTokenType),
0150     T_SHIFTLEFT    = TOKEN_FROM_ID(298, OperatorTokenType),
0151     T_SHIFTLEFTASSIGN = TOKEN_FROM_ID(299, OperatorTokenType),
0152     T_SHIFTRIGHT   = TOKEN_FROM_ID(300, OperatorTokenType),
0153     T_SHIFTRIGHTASSIGN = TOKEN_FROM_ID(301, OperatorTokenType),
0154     T_STAR         = TOKEN_FROM_ID(302, OperatorTokenType),
0155     T_COMPL        = TOKEN_FROM_ID(303, OperatorTokenType),
0156     T_COMPL_ALT         = TOKEN_FROM_ID(303, OperatorTokenType|AltExtTokenType),
0157     T_COMPL_TRIGRAPH    = TOKEN_FROM_ID(303, OperatorTokenType|TriGraphTokenType),
0158     T_STARASSIGN   = TOKEN_FROM_ID(304, OperatorTokenType),
0159     T_ASM          = TOKEN_FROM_ID(305, KeywordTokenType),
0160     T_AUTO         = TOKEN_FROM_ID(306, KeywordTokenType),
0161     T_BOOL         = TOKEN_FROM_ID(307, KeywordTokenType),
0162     T_FALSE        = TOKEN_FROM_ID(308, BoolLiteralTokenType),
0163     T_TRUE         = TOKEN_FROM_ID(309, BoolLiteralTokenType),
0164     T_BREAK        = TOKEN_FROM_ID(310, KeywordTokenType),
0165     T_CASE         = TOKEN_FROM_ID(311, KeywordTokenType),
0166     T_CATCH        = TOKEN_FROM_ID(312, KeywordTokenType),
0167     T_CHAR         = TOKEN_FROM_ID(313, KeywordTokenType),
0168     T_CLASS        = TOKEN_FROM_ID(314, KeywordTokenType),
0169     T_CONST        = TOKEN_FROM_ID(315, KeywordTokenType),
0170     T_CONSTCAST    = TOKEN_FROM_ID(316, KeywordTokenType),
0171     T_CONTINUE     = TOKEN_FROM_ID(317, KeywordTokenType),
0172     T_DEFAULT      = TOKEN_FROM_ID(318, KeywordTokenType),
0173     T_DELETE       = TOKEN_FROM_ID(319, KeywordTokenType),
0174     T_DO           = TOKEN_FROM_ID(320, KeywordTokenType),
0175     T_DOUBLE       = TOKEN_FROM_ID(321, KeywordTokenType),
0176     T_DYNAMICCAST  = TOKEN_FROM_ID(322, KeywordTokenType),
0177     T_ELSE         = TOKEN_FROM_ID(323, KeywordTokenType),
0178     T_ENUM         = TOKEN_FROM_ID(324, KeywordTokenType),
0179     T_EXPLICIT     = TOKEN_FROM_ID(325, KeywordTokenType),
0180     T_EXPORT       = TOKEN_FROM_ID(326, KeywordTokenType),
0181     T_EXTERN       = TOKEN_FROM_ID(327, KeywordTokenType),
0182     T_FLOAT        = TOKEN_FROM_ID(328, KeywordTokenType),
0183     T_FOR          = TOKEN_FROM_ID(329, KeywordTokenType),
0184     T_FRIEND       = TOKEN_FROM_ID(330, KeywordTokenType),
0185     T_GOTO         = TOKEN_FROM_ID(331, KeywordTokenType),
0186     T_IF           = TOKEN_FROM_ID(332, KeywordTokenType),
0187     T_INLINE       = TOKEN_FROM_ID(333, KeywordTokenType),
0188     T_INT          = TOKEN_FROM_ID(334, KeywordTokenType),
0189     T_LONG         = TOKEN_FROM_ID(335, KeywordTokenType),
0190     T_MUTABLE      = TOKEN_FROM_ID(336, KeywordTokenType),
0191     T_NAMESPACE    = TOKEN_FROM_ID(337, KeywordTokenType),
0192     T_NEW          = TOKEN_FROM_ID(338, KeywordTokenType),
0193     T_OPERATOR     = TOKEN_FROM_ID(339, KeywordTokenType),
0194     T_PRIVATE      = TOKEN_FROM_ID(340, KeywordTokenType),
0195     T_PROTECTED    = TOKEN_FROM_ID(341, KeywordTokenType),
0196     T_PUBLIC       = TOKEN_FROM_ID(342, KeywordTokenType),
0197     T_REGISTER     = TOKEN_FROM_ID(343, KeywordTokenType),
0198     T_REINTERPRETCAST = TOKEN_FROM_ID(344, KeywordTokenType),
0199     T_RETURN       = TOKEN_FROM_ID(345, KeywordTokenType),
0200     T_SHORT        = TOKEN_FROM_ID(346, KeywordTokenType),
0201     T_SIGNED       = TOKEN_FROM_ID(347, KeywordTokenType),
0202     T_SIZEOF       = TOKEN_FROM_ID(348, KeywordTokenType),
0203     T_STATIC       = TOKEN_FROM_ID(349, KeywordTokenType),
0204     T_STATICCAST   = TOKEN_FROM_ID(350, KeywordTokenType),
0205     T_STRUCT       = TOKEN_FROM_ID(351, KeywordTokenType),
0206     T_SWITCH       = TOKEN_FROM_ID(352, KeywordTokenType),
0207     T_TEMPLATE     = TOKEN_FROM_ID(353, KeywordTokenType),
0208     T_THIS         = TOKEN_FROM_ID(354, KeywordTokenType),
0209     T_THROW        = TOKEN_FROM_ID(355, KeywordTokenType),
0210     T_TRY          = TOKEN_FROM_ID(356, KeywordTokenType),
0211     T_TYPEDEF      = TOKEN_FROM_ID(357, KeywordTokenType),
0212     T_TYPEID       = TOKEN_FROM_ID(358, KeywordTokenType),
0213     T_TYPENAME     = TOKEN_FROM_ID(359, KeywordTokenType),
0214     T_UNION        = TOKEN_FROM_ID(360, KeywordTokenType),
0215     T_UNSIGNED     = TOKEN_FROM_ID(361, KeywordTokenType),
0216     T_USING        = TOKEN_FROM_ID(362, KeywordTokenType),
0217     T_VIRTUAL      = TOKEN_FROM_ID(363, KeywordTokenType),
0218     T_VOID         = TOKEN_FROM_ID(364, KeywordTokenType),
0219     T_VOLATILE     = TOKEN_FROM_ID(365, KeywordTokenType),
0220     T_WCHART       = TOKEN_FROM_ID(366, KeywordTokenType),
0221     T_WHILE        = TOKEN_FROM_ID(367, KeywordTokenType),
0222     T_PP_DEFINE    = TOKEN_FROM_ID(368, PPTokenType),
0223     T_PP_IF        = TOKEN_FROM_ID(369, PPConditionalTokenType),
0224     T_PP_IFDEF     = TOKEN_FROM_ID(370, PPConditionalTokenType),
0225     T_PP_IFNDEF    = TOKEN_FROM_ID(371, PPConditionalTokenType),
0226     T_PP_ELSE      = TOKEN_FROM_ID(372, PPConditionalTokenType),
0227     T_PP_ELIF      = TOKEN_FROM_ID(373, PPConditionalTokenType),
0228     T_PP_ENDIF     = TOKEN_FROM_ID(374, PPConditionalTokenType),
0229     T_PP_ERROR     = TOKEN_FROM_ID(375, PPTokenType),
0230     T_PP_LINE      = TOKEN_FROM_ID(376, PPTokenType),
0231     T_PP_PRAGMA    = TOKEN_FROM_ID(377, PPTokenType),
0232     T_PP_UNDEF     = TOKEN_FROM_ID(378, PPTokenType),
0233     T_PP_WARNING   = TOKEN_FROM_ID(379, PPTokenType),
0234     T_IDENTIFIER   = TOKEN_FROM_ID(380, IdentifierTokenType),
0235     T_OCTALINT     = TOKEN_FROM_ID(381, IntegerLiteralTokenType),
0236     T_DECIMALINT   = TOKEN_FROM_ID(382, IntegerLiteralTokenType),
0237     T_HEXAINT      = TOKEN_FROM_ID(383, IntegerLiteralTokenType),
0238     T_INTLIT       = TOKEN_FROM_ID(384, IntegerLiteralTokenType),
0239     T_LONGINTLIT   = TOKEN_FROM_ID(385, IntegerLiteralTokenType),
0240     T_FLOATLIT     = TOKEN_FROM_ID(386, FloatingLiteralTokenType),
0241     T_FIXEDPOINTLIT = TOKEN_FROM_ID(386, FloatingLiteralTokenType|AltTokenType),  // IDL specific
0242     T_CCOMMENT     = TOKEN_FROM_ID(387, WhiteSpaceTokenType|AltTokenType),
0243     T_CPPCOMMENT   = TOKEN_FROM_ID(388, WhiteSpaceTokenType|AltTokenType),
0244     T_CHARLIT      = TOKEN_FROM_ID(389, CharacterLiteralTokenType),
0245     T_STRINGLIT    = TOKEN_FROM_ID(390, StringLiteralTokenType),
0246     T_CONTLINE     = TOKEN_FROM_ID(391, EOLTokenType),
0247     T_SPACE        = TOKEN_FROM_ID(392, WhiteSpaceTokenType),
0248     T_SPACE2       = TOKEN_FROM_ID(393, WhiteSpaceTokenType),
0249     T_NEWLINE      = TOKEN_FROM_ID(394, EOLTokenType),
0250     T_GENERATEDNEWLINE      = TOKEN_FROM_ID(394, EOLTokenType|AltTokenType),
0251     T_POUND_POUND           = TOKEN_FROM_ID(395, OperatorTokenType),
0252     T_POUND_POUND_ALT       = TOKEN_FROM_ID(395, OperatorTokenType|AltTokenType),
0253     T_POUND_POUND_TRIGRAPH  = TOKEN_FROM_ID(395, OperatorTokenType|TriGraphTokenType),
0254     T_POUND                 = TOKEN_FROM_ID(396, OperatorTokenType),
0255     T_POUND_ALT             = TOKEN_FROM_ID(396, OperatorTokenType|AltTokenType),
0256     T_POUND_TRIGRAPH        = TOKEN_FROM_ID(396, OperatorTokenType|TriGraphTokenType),
0257     T_ANY          = TOKEN_FROM_ID(397, UnknownTokenType),
0258     T_ANY_TRIGRAPH = TOKEN_FROM_ID(397, UnknownTokenType|TriGraphTokenType),
0259     T_PP_INCLUDE   = TOKEN_FROM_ID(398, PPTokenType),
0260     T_PP_QHEADER   = TOKEN_FROM_ID(399, PPTokenType),
0261     T_PP_HHEADER   = TOKEN_FROM_ID(400, PPTokenType),
0262     T_PP_INCLUDE_NEXT   = TOKEN_FROM_ID(398, PPTokenType|AltTokenType),
0263     T_PP_QHEADER_NEXT   = TOKEN_FROM_ID(399, PPTokenType|AltTokenType),
0264     T_PP_HHEADER_NEXT   = TOKEN_FROM_ID(400, PPTokenType|AltTokenType),
0265     T_EOF          = TOKEN_FROM_ID(401, EOFTokenType),      // end of file reached
0266     T_EOI          = TOKEN_FROM_ID(402, EOFTokenType),      // end of input reached
0267     T_PP_NUMBER    = TOKEN_FROM_ID(403, InternalTokenType),
0268 
0269 // MS extensions
0270     T_MSEXT_INT8   = TOKEN_FROM_ID(404, KeywordTokenType),
0271     T_MSEXT_INT16  = TOKEN_FROM_ID(405, KeywordTokenType),
0272     T_MSEXT_INT32  = TOKEN_FROM_ID(406, KeywordTokenType),
0273     T_MSEXT_INT64  = TOKEN_FROM_ID(407, KeywordTokenType),
0274     T_MSEXT_BASED  = TOKEN_FROM_ID(408, KeywordTokenType),
0275     T_MSEXT_DECLSPEC = TOKEN_FROM_ID(409, KeywordTokenType),
0276     T_MSEXT_CDECL  = TOKEN_FROM_ID(410, KeywordTokenType),
0277     T_MSEXT_FASTCALL = TOKEN_FROM_ID(411, KeywordTokenType),
0278     T_MSEXT_STDCALL = TOKEN_FROM_ID(412, KeywordTokenType),
0279     T_MSEXT_TRY    = TOKEN_FROM_ID(413, KeywordTokenType),
0280     T_MSEXT_EXCEPT = TOKEN_FROM_ID(414, KeywordTokenType),
0281     T_MSEXT_FINALLY = TOKEN_FROM_ID(415, KeywordTokenType),
0282     T_MSEXT_LEAVE  = TOKEN_FROM_ID(416, KeywordTokenType),
0283     T_MSEXT_INLINE = TOKEN_FROM_ID(417, KeywordTokenType),
0284     T_MSEXT_ASM    = TOKEN_FROM_ID(418, KeywordTokenType),
0285 
0286     T_MSEXT_PP_REGION    = TOKEN_FROM_ID(419, PPTokenType),
0287     T_MSEXT_PP_ENDREGION = TOKEN_FROM_ID(420, PPTokenType),
0288 
0289 // import is needed to be a keyword for the C++ module Standards proposal
0290     T_IMPORT       = TOKEN_FROM_ID(421, KeywordTokenType),
0291 
0292 // C++11 keywords
0293     T_ALIGNAS      = TOKEN_FROM_ID(422, KeywordTokenType),
0294     T_ALIGNOF      = TOKEN_FROM_ID(423, KeywordTokenType),
0295     T_CHAR16_T     = TOKEN_FROM_ID(424, KeywordTokenType),
0296     T_CHAR32_T     = TOKEN_FROM_ID(425, KeywordTokenType),
0297     T_CONSTEXPR    = TOKEN_FROM_ID(426, KeywordTokenType),
0298     T_DECLTYPE     = TOKEN_FROM_ID(427, KeywordTokenType),
0299     T_NOEXCEPT     = TOKEN_FROM_ID(428, KeywordTokenType),
0300     T_NULLPTR      = TOKEN_FROM_ID(429, KeywordTokenType),
0301     T_STATICASSERT = TOKEN_FROM_ID(430, KeywordTokenType),
0302     T_THREADLOCAL  = TOKEN_FROM_ID(431, KeywordTokenType),
0303     T_RAWSTRINGLIT = TOKEN_FROM_ID(432, StringLiteralTokenType),
0304 
0305 // C++20 keywords
0306     T_CHAR8_T      = TOKEN_FROM_ID(433, KeywordTokenType),
0307     T_CONCEPT      = TOKEN_FROM_ID(434, KeywordTokenType),
0308     T_CONSTEVAL    = TOKEN_FROM_ID(435, KeywordTokenType),
0309     T_CONSTINIT    = TOKEN_FROM_ID(436, KeywordTokenType),
0310     T_CO_AWAIT     = TOKEN_FROM_ID(437, KeywordTokenType),
0311     T_CO_RETURN    = TOKEN_FROM_ID(438, KeywordTokenType),
0312     T_CO_YIELD     = TOKEN_FROM_ID(439, KeywordTokenType),
0313     T_REQUIRES     = TOKEN_FROM_ID(440, KeywordTokenType),
0314 
0315 // C++20 operators
0316     T_SPACESHIP    = TOKEN_FROM_ID(441, OperatorTokenType),
0317 
0318     T_LAST_TOKEN_ID,
0319     T_LAST_TOKEN = ID_FROM_TOKEN(T_LAST_TOKEN_ID & ~PPTokenFlag),
0320 
0321     T_UNKNOWN_UNIVERSALCHAR = TOKEN_FROM_ID('\\', UnknownTokenType),
0322 
0323 // pseudo tokens to help streamlining macro replacement, these should not
0324 // returned from the lexer nor should these be returned from the pp-iterator
0325     T_NONREPLACABLE_IDENTIFIER = TOKEN_FROM_ID(T_LAST_TOKEN+1, IdentifierTokenType),
0326     T_PLACEHOLDER = TOKEN_FROM_ID(T_LAST_TOKEN+2, WhiteSpaceTokenType),
0327     T_PLACEMARKER = TOKEN_FROM_ID(T_LAST_TOKEN+3, InternalTokenType),
0328     T_PARAMETERBASE = TOKEN_FROM_ID(T_LAST_TOKEN+4, ParameterTokenType),
0329     T_EXTPARAMETERBASE = TOKEN_FROM_ID(T_LAST_TOKEN+4, ExtParameterTokenType),
0330     T_OPTPARAMETERBASE = TOKEN_FROM_ID(T_LAST_TOKEN+4, OptParameterTokenType)
0331 };
0332 
0333 ///////////////////////////////////////////////////////////////////////////////
0334 //  token_category and token_id may be used together
0335 constexpr token_id operator&(token_id a, token_category b)
0336 {
0337     return static_cast<token_id>(
0338         static_cast<std::uint32_t>(a) & static_cast<std::uint32_t>(b));
0339 }
0340 
0341 constexpr token_id operator|(token_id a, token_category b)
0342 {
0343     return static_cast<token_id>(
0344         static_cast<std::uint32_t>(a) | static_cast<std::uint32_t>(b));
0345 }
0346 
0347 constexpr bool operator==(token_category a, token_id b)
0348 {
0349     return static_cast<std::uint32_t>(a) == static_cast<std::uint32_t>(b);
0350 }
0351 
0352 
0353 ///////////////////////////////////////////////////////////////////////////////
0354 //  redefine the TOKEN_FROM_ID macro to be more type safe
0355 #undef TOKEN_FROM_ID
0356 #define TOKEN_FROM_ID(id, cat)   boost::wave::token_id((id) | (cat))
0357 
0358 #undef ID_FROM_TOKEN
0359 #define ID_FROM_TOKEN(tok)                                                    \
0360     boost::wave::token_id((tok) &                                             \
0361         ~(boost::wave::TokenTypeMask|boost::wave::PPTokenFlag))               \
0362     /**/
0363 
0364 #undef BASEID_FROM_TOKEN
0365 #define BASEID_FROM_TOKEN(tok)                                                \
0366     boost::wave::token_id((tok) &                                             \
0367          ~(boost::wave::ExtTokenTypeMask|boost::wave::PPTokenFlag))           \
0368     /**/
0369 #define BASE_TOKEN(tok)                                                       \
0370     boost::wave::token_id((tok) & boost::wave::MainTokenMask)                 \
0371     /**/
0372 #define CATEGORY_FROM_TOKEN(tok) ((tok) & boost::wave::TokenTypeMask)
0373 #define EXTCATEGORY_FROM_TOKEN(tok) ((tok) & boost::wave::ExtTokenTypeMask)
0374 #define IS_CATEGORY(tok, cat)                                                 \
0375     ((CATEGORY_FROM_TOKEN(tok) == CATEGORY_FROM_TOKEN(cat)) ? true : false)   \
0376     /**/
0377 #define IS_EXTCATEGORY(tok, cat)                                              \
0378     ((EXTCATEGORY_FROM_TOKEN(tok) == EXTCATEGORY_FROM_TOKEN(cat)) ? true : false) \
0379     /**/
0380 
0381 ///////////////////////////////////////////////////////////////////////////////
0382 // verify whether the given token(-id) represents a valid pp_token
0383 inline bool is_pp_token(boost::wave::token_id id)
0384 {
0385     return (id & boost::wave::PPTokenFlag) ? true : false;
0386 }
0387 
0388 template <typename TokenT>
0389 inline bool is_pp_token(TokenT const& tok)
0390 {
0391     return is_pp_token(boost::wave::token_id(tok));
0392 }
0393 
0394 ///////////////////////////////////////////////////////////////////////////////
0395 //  return a token name
0396 BOOST_WAVE_DECL
0397 BOOST_WAVE_STRINGTYPE get_token_name(token_id tokid);
0398 
0399 ///////////////////////////////////////////////////////////////////////////////
0400 //  return a token name
0401 BOOST_WAVE_DECL
0402 char const *get_token_value(token_id tokid);
0403 
0404 ///////////////////////////////////////////////////////////////////////////////
0405 }   // namespace wave
0406 }   // namespace boost
0407 
0408 #endif // #if !defined(BOOST_WAVE_TOKEN_IDS_DEFINED)
0409 
0410 // the suffix header occurs after all of the code
0411 #ifdef BOOST_HAS_ABI_HEADERS
0412 #include BOOST_ABI_SUFFIX
0413 #endif
0414 
0415 #endif // !defined(BOOST_TOKEN_IDS_HPP_414E9A58_F079_4789_8AFF_513815CE475B_INCLUDED)
0416
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!