X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=tokens.inc;h=7f72fb0142f7f7f85587b34fa3ba537e345da0b2;hb=7c3e9800278cd3f36d1a9de106808625fc29767e;hp=d5626d4c6940be12e1ec624a6562494073edcc11;hpb=b4e35bf2387e9b22ae6a97bad28daa8a438483ed;p=cparser

diff --git a/tokens.inc b/tokens.inc
index d5626d4..7f72fb0 100644
--- a/tokens.inc
+++ b/tokens.inc
@@ -2,108 +2,164 @@
 #define TS(x,str,val)
 #endif
 
-TS(IDENTIFIER,     "identifier", = 256)
-TS(TYPENAME,       "typename",)
-TS(INTEGER,        "integer number",)
-TS(STRING_LITERAL, "string literal",)
+TS(IDENTIFIER,              "identifier", = 256)
+TS(INTEGER,                 "integer number",)
+TS(CHARACTER_CONSTANT,      "character constant",)
+TS(WIDE_CHARACTER_CONSTANT, "wide character constant",)
+TS(FLOATINGPOINT,           "floatingpoint number",)
+TS(STRING_LITERAL,          "string literal",)
+TS(WIDE_STRING_LITERAL,     "wide string literal",)
 
-#define S(x)   T(x,#x,)
-S(auto)
-S(break)
-S(case)
-S(char)
-S(const)
-S(continue)
-S(default)
-S(do)
-S(double)
-S(else)
-S(enum)
-S(extern)
-S(float)
-S(for)
-S(goto)
-S(if)
-S(inline)
-S(int)
-S(long)
-S(register)
-S(restrict)
-S(return)
-S(short)
-S(signed)
-S(sizeof)
-S(static)
-S(struct)
-S(switch)
-S(typedef)
-S(union)
-S(unsigned)
-S(void)
-S(volatile)
-S(while)
-S(_Bool)
-S(_Complex)
-S(_Imaginary)
+#define PUNCTUATOR(name,string,val)   T(_ALL,name,string,val)
+#include "tokens_punctuator.inc"
+#undef PUNCTUATOR
+
+#define S(mode,x)   T(mode,x,#x,)
+S(_ALL, auto)
+S(_ALL, break)
+S(_ALL, case)
+S(_ALL, char)
+S(_ALL, continue)
+S(_ALL, default)
+S(_ALL, do)
+S(_ALL, double)
+S(_ALL, else)
+S(_ALL, enum)
+S(_ALL, extern)
+S(_ALL, float)
+S(_ALL, for)
+S(_ALL, goto)
+S(_ALL, if)
+S(_ALL, int)
+S(_ALL, long)
+S(_ALL, register)
+S(_ALL, return)
+S(_ALL, short)
+S(_ALL, sizeof)
+S(_ALL, static)
+S(_ALL, struct)
+S(_ALL, switch)
+S(_ALL, typedef)
+S(_ALL, union)
+S(_ALL, unsigned)
+S(_ALL, void)
+S(_ALL, while)
+
+S(_C99|_GNUC, _Bool)
+S(_ALL, __thread)
+S(_ALL, __extension__)
+S(_ALL, __builtin_classify_type)
+S(_ALL, __builtin_va_list)
+S(_ALL, __builtin_expect)
+S(_ALL, __builtin_offsetof)
+S(_ALL, __builtin_va_arg)
+S(_ALL, __builtin_va_end)
+S(_ALL, __builtin_alloca)
+S(_ALL, __builtin_nanf)
+S(_ALL, __builtin_nan)
+S(_ALL, __builtin_nand)
+S(_ALL, __builtin_isgreater)
+S(_ALL, __builtin_isgreaterequal)
+S(_ALL, __builtin_isless)
+S(_ALL, __builtin_islessequal)
+S(_ALL, __builtin_islessgreater)
+S(_ALL, __builtin_isunordered)
+S(_ALL, __builtin_constant_p)
+S(_ALL, __builtin_prefetch)
+S(_ALL, __builtin_huge_val)
+S(_ALL, __PRETTY_FUNCTION__)
+S(_ALL, __FUNCTION__)
+S(_C99, __func__)
+S(_MS, __FUNCSIG__)
+S(_MS, __FUNCDNAME__)
 #undef S
 
-T(SELECT,                   "->",)
-T(PLUSPLUS,                 "++",)
-T(MINUSMINUS,               "--",)
-T(LESSLESS,                 "<<",)
-T(GREATERGREATER,           ">>",)
-T(LESSEQUAL,                "<=",)
-T(GREATEREQUAL,             ">=",)
-T(EQUALEQUAL,               "==",)
-T(EXCLAMATIONMARKEQUAL,     "!=",)
-T(ANDAND,                   "&&",)
-T(PIPEPIPE,                 "||",)
-T(DOTDOTDOT,                "...",)
-T(ASTERISKEQUAL,            "*=",)
-T(SLASHEQUAL,               "/=",)
-T(PERCENTEQUAL,             "%=",)
-T(PLUSEQUAL,                "+=",)
-T(MINUSEQUAL,               "-=",)
-T(LESSLESSEQUAL,            "<<=",)
-T(GREATERGREATEREQUAL,      ">>=",)
-T(ANDEQUAL,                 "&=",)
-T(CARETEQUAL,               "^=",)
-T(PIPEEQUAL,                "|=",)
-T(HASHHASH,                 "##",)
+T(_ANSI|_C99,   signed,       "signed",)
+T(_ALL,       __signed,       "__signed",               = T_signed)
+T(_ALL,       __signed__,     "__signed__",             = T_signed)
+T(_C99|_GNUC, _Complex,       "_Complex",)
+T(_ALL,       __complex__,    "__complex__",            = T__Complex)
+T(_ALL,       __complex,      "__complex",              = T__Complex)
+T(_C99|_GNUC, _Imaginary,     "_Imaginary",)
+T(_ALL,       __real__,       "__real__",)
+T(_ALL,       __real,         "__real",                 = T___real__)
+T(_ALL,       __imag__,       "__imag__",)
+T(_ALL,       __imag,         "__imag",                 = T___imag__)
+T(_ALL,       __alignof__,    "__alignof__",)
+T(_ALL,       __alignof,      "__alignof",              = T___alignof__)
+T(_MS,        _alignof,       "_alignof",               = T___alignof__)
+T(_ANSI|_C99, const,          "const",)
+T(_ALL,       __const,        "__const",                = T_const)
+T(_ALL,       __const__,      "__const__",              = T_const)
+T(_C99,       restrict,       "restrict",)
+T(_ALL,       __restrict__,   "__restrict__",           = T_restrict)
+T(_ALL,       __restrict,     "__restrict",             = T_restrict)
+T(_MS,        _restrict,      "_restrict",              = T_restrict)
+T(_ALL,       asm,            "asm",)
+T(_ALL,       __asm__,        "__asm__",                = T_asm)
+T(_MS,        _asm,           "_asm",                   = T_asm)
+T(_ALL,       __asm,          "__asm",                  = T_asm)
+T(_ANSI|_C99, volatile,       "volatile",)
+T(_ALL,       __volatile,     "__volatile",             = T_volatile)
+T(_ALL,       __volatile__,   "__volatile__",           = T_volatile)
+T(_C99,       inline,         "inline",)
+T(_ALL,       __inline,       "__inline",               = T_inline)
+T(_ALL,       __inline__,     "__inline__",             = T_inline)
+T(_GNUC,      typeof,         "typeof",)
+T(_ALL,       __typeof,       "__typeof",               = T_typeof)
+T(_ALL,       __typeof__,     "__typeof__",             = T_typeof)
+T(_ALL,       __attribute__,  "__attribute__",)
+
+T(_ALL,     __builtin_va_start,     "__builtin_va_start",)
+T(_ALL,     __builtin_stdarg_start, "__builtin_stdarg_start", = T___builtin_va_start)
 
-#define T_LAST_TOKEN  (T_HASHHASH+1)
+T(_MS,      _near,            "_near",)
+T(_MS,      __near,           "__near",                  = T__near)
+T(_MS,      _far,             "_far",)
+T(_MS,      __far,            "__far",                   = T__far)
+T(_MS,      cdecl,            "cdecl",)
+T(_MS,      _cdecl,           "_cdecl",                  = T_cdecl)
+T(_MS,      __cdecl,          "__cdecl",                 = T_cdecl)
+T(_MS,      _stdcall,         "_stdcall",)
+T(_MS,      __stdcall,        "__stdcall",               = T__stdcall)
+T(_MS,      _fastcall,        "_fastcall",)
+T(_MS,      __fastcall,       "__fastcall",              = T__fastcall)
+T(_MS,      __thiscall,       "__thiscall",)
+T(_MS,      _forceinline,     "_forceinline",)
+T(_MS,      __forceinline,    "__forceinline",           = T__forceinline)
+T(_MS,      __unaligned,      "__unaligned",)
+T(_MS,      _assume,          "_assume",)
+T(_MS,      __assume,         "__assume",                = T__assume)
+T(_MS,      _try,             "_try",)
+T(_MS,      __try,            "__try",                   = T__try)
+T(_MS,      _finally,         "_finally",)
+T(_MS,      __finally,        "__finally",               = T__finally)
+T(_MS,      _leave,           "_leave",)
+T(_MS,      __leave,          "__leave",                 = T__leave)
+T(_MS,      _except,          "_except",)
+T(_MS,      __except,         "__except",                = T__except)
+T(_MS,      _declspec,        "_declspec",)
+T(_MS,      __declspec,       "__declspec",              = T__declspec)
+T(_MS,      _based,            "_based",)
+T(_MS,      __based,          "__based",                 = T__based)
+T(_MS,      __noop,           "__noop",)
 
-T(RBRACK,          "[", = '[')
-T(LBRACK,          "]", = ']')
-T(LBRACE,          "(", = '(')
-T(RBRACE,          ")", = ')')
-T(RCURLY,          "{", = '{')
-T(LCURLY,          "}", = '}')
-T(DOT,             ".", = '.')
-T(AND,             "&", = '&')
-T(ASTERISK,        "*", = '*')
-T(PLUS,            "+", = '+')
-T(MINUS,           "-", = '-')
-T(TILDE,           "~", = '~')
-T(EXCLAMATIONMARK, "!", = '!')
-T(SLASH,           "/", = '/')
-T(PERCENT,         "%", = '%')
-T(LESS,            "<", = '<')
-T(GREATER,         ">", = '>')
-T(CARET,           "^", = '^')
-T(PIPE,            "|", = '|')
-T(QUESTIONMARK,    "?", = '?')
-T(COLON,           ":", = ':')
-T(SEMICOLON,       ";", = ';')
-T(EQUAL,           "=", = '=')
-T(COMMA,           ",", = ',')
-T(HASH,            "#", = '#')
+T(_MS,      __ptr32,          "__ptr32",)
+T(_MS,      __ptr64,          "__ptr64",)
+T(_MS,      __sptr,           "__sptr",)
+T(_MS,      __uptr,           "__uptr",)
+T(_MS,      _w64,             "_w64",)
+T(_MS,      __w64,            "__w64",                   = T__w64)
 
-T(LESSCOLON,                "<:",   = '[')
-T(COLONGREATER,             ":>",   = ']')
-T(LESSPERCENT,              "<%",   = '{')
-T(PERCENTGREATER,           "%>",   = '}')
-T(PERCENTCOLON,             "%:",   = '#')
-T(PERCENTCOLONPERCENTCOLON, "%:%:", = T_HASHHASH)
+T(_MS,      _int8,            "_int8",)
+T(_MS,      __int8,           "__int8",                  = T__int8)
+T(_MS,      _int16,           "_int16",)
+T(_MS,      __int16,          "__int16",                 = T__int16)
+T(_MS,      _int32,           "_int32",)
+T(_MS,      __int32,          "__int32",                 = T__int32)
+T(_MS,      _int64,           "_int64",)
+T(_MS,      __int64,          "__int64",                 = T__int64)
+T(_MS,      _int128,          "_int128",)
+T(_MS,      __int128,         "__int128",                = T__int128)
 
-TS(NEWLINE,        "newline", = '\n')
+#undef _T