1 
  
    2 
  
    3 
  
    4 #include <sngcm/cmlexer/TokenLexerKeywords.hpp>
  
    5 #include <sngcm/cmlexer/TokenLexerTokens.hpp>
  
    6 
  
    7 namespace TokenLexerKeywords
  
    8 {
  
    9     using namespace TokenLexerTokens;
  
   10 
  
   11     Keyword keywords[] =
  
   12     {
  
   13         {U"assert", ASSERT}
  
   14         {U"elif", ELIF}
  
   15         {U"endif", ENDIF}
  
   16         {U"bool", BOOL}
  
   17         {U"true", TRUE}
  
   18         {U"false", FALSE}
  
   19         {U"sbyte", SBYTE}
  
   20         {U"byte", BYTE}
  
   21         {U"short", SHORT}
  
   22         {U"ushort", USHORT}
  
   23         {U"int", INT}
  
   24         {U"uint", UINT}
  
   25         {U"long", LONG}
  
   26         {U"ulong", ULONG}
  
   27         {U"float", FLOAT}
  
   28         {U"double", DOUBLE}
  
   29         {U"char", CHAR}
  
   30         {U"wchar", WCHAR}
  
   31         {U"uchar", UCHAR}
  
   32         {U"void", VOID}
  
   33         {U"enum", ENUM}
  
   34         {U"cast", CAST}
  
   35         {U"interface", INTERFACE}
  
   36         {U"namespace", NAMESPACE}
  
   37         {U"using", USING}
  
   38         {U"static", STATIC}
  
   39         {U"extern", EXTERN}
  
   40         {U"as", AS}
  
   41         {U"is", IS}
  
   42         {U"explicit", EXPLICIT}
  
   43         {U"delegate", DELEGATE}
  
   44         {U"inline", INLINE}
  
   45         {U"cdecl", CDECL}
  
   46         {U"nothrow", NOTHROW}
  
   47         {U"public", PUBLIC}
  
   48         {U"protected", PROTECTED}
  
   49         {U"private", PRIVATE}
  
   50         {U"internal", INTERNAL}
  
   51         {U"virtual", VIRTUAL}
  
   52         {U"abstract", ABSTRACT}
  
   53         {U"override", OVERRIDE}
  
   54         {U"suppress", SUPPRESS}
  
   55         {U"operator", OPERATOR}
  
   56         {U"class", CLASS}
  
   57         {U"return", RETURN}
  
   58         {U"if", IF}
  
   59         {U"else", ELSE}
  
   60         {U"switch", SWITCH}
  
   61         {U"case", CASE}
  
   62         {U"default", DEFAULT}
  
   63         {U"while", WHILE}
  
   64         {U"do", DO}
  
   65         {U"for", FOR}
  
   66         {U"break", BREAK}
  
   67         {U"continue", CONTINUE}
  
   68         {U"goto", GOTO}
  
   69         {U"typedef", TYPEDEF}
  
   70         {U"typename", TYPENAME}
  
   71         {U"typeid", TYPEID}
  
   72         {U"const", CONST}
  
   73         {U"constexpr", CONSTEXPR}
  
   74         {U"null", NULLLIT}
  
   75         {U"this", THIS}
  
   76         {U"base", BASE}
  
   77         {U"construct", CONSTRUCT}
  
   78         {U"destroy", DESTROY}
  
   79         {U"new", NEW}
  
   80         {U"delete", DELETE}
  
   81         {U"sizeof", SIZEOF}
  
   82         {U"try", TRY}
  
   83         {U"catch", CATCH}
  
   84         {U"throw", THROW}
  
   85         {U"concept", CONCEPT}
  
   86         {U"where", WHERE}
  
   87         {U"axiom", AXIOM}
  
   88         {U"and", AND}
  
   89         {U"or", OR}
  
   90         {U"unit_test", UNIT_TEST}
  
   91         {nullptr, -1}
  
   92     };
  
   93 
  
   94     KeywordMap keywordMap(keywords);
  
   95 
  
   96     KeywordMap* GetKeywordMap()
  
   97     {
  
   98         return &keywordMap;
  
   99     }
  
  100 }