Reserved word

#if defined(__GNUG__) || defined(_GNUG_SYNTAX)
  { "_Bool",            RID_BOOL,       0 }, in C not C++ ??
  { "_Complex",         RID_COMPLEX,    0 },
  { "__FUNCTION__",     RID_FUNCTION_NAME, 0 },
  { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
  { "__alignof",        RID_ALIGNOF,    0 },
  my_keywords["__alignof__"] = Token::SIZEOF;
  { "__asm",            RID_ASM,        0 },
  my_keywords["__asm__"] = Token::ATTRIBUTE;
  { "__attribute",      RID_ATTRIBUTE,  0 },
  my_keywords["__attribute__"] = Token::ATTRIBUTE;
  { "__builtin_choose_expr", RID_CHOOSE_EXPR, 0 },
  { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, 0 },
  { "__builtin_va_arg", RID_VA_ARG,     0 },
  { "__complex",        RID_COMPLEX,    0 },
  my_keywords["__complex__"] = Token::Ignore;
  my_keywords["__const"] = Token::CONST;
  { "__const__",        RID_CONST,      0 },
  my_keywords["__extension__"] = Token::EXTENSION;
  { "__func__",         RID_C99_FUNCTION_NAME, 0 },
  { "__imag",           RID_IMAGPART,   0 },
  my_keywords["__imag__"] = Token::Ignore;
  my_keywords["__inline"] = Token::INLINE;
  my_keywords["__inline__"] = Token::INLINE;
  { "__null",           RID_NULL,       0 },
  { "__label__",        RID_LABEL,      0 },
  { "__offsetof",       RID_OFFSETOF,   0 },
  { "__offsetof__",     RID_OFFSETOF,   0 },
  { "__ptrbase",        RID_PTRBASE,    0 }, in C not C++ ??
  { "__ptrbase__",      RID_PTRBASE,    0 }, in C not C++ ??
  { "__ptrextent",      RID_PTREXTENT,  0 }, in C not C++ ??
  { "__ptrextent__",    RID_PTREXTENT,  0 }, in C not C++ ??
  { "__ptrvalue",       RID_PTRVALUE,   0 }, in C not C++ ??
  { "__ptrvalue__",     RID_PTRVALUE,   0 }, in C not C++ ??
  { "__real",           RID_REALPART,   0 },
  my_keywords["__real__"] = Token::Ignore;
  my_keywords["__restrict"] = Token::Ignore;
  my_keywords["__restrict__"] = Token::Ignore;
  my_keywords["__signed"] = Token::SIGNED;
  my_keywords["__signed__"] = Token::SIGNED;
 { "__thread",         RID_THREAD,     0 },
  my_keywords["__typeof"] = Token::TYPEOF;
  my_keywords["__typeof__"] = Token::TYPEOF;
  { "__volatile",       RID_VOLATILE,   0 },
  { "__volatile__",     RID_VOLATILE,   0 },
#endif
#if defined(_MSC_VER)
  my_keywords["cdecl"] = Token::Ignore;
  my_keywords["_cdecl"] = Token::Ignore;
  my_keywords["__cdecl"] = Token::Ignore;
  my_keywords["_fastcall"] = Token::Ignore;
  my_keywords["__fastcall"] = Token::Ignore;
  my_keywords["_based"] = Token::Ignore;
  my_keywords["__based"] = Token::Ignore;
  my_keywords["_asm"] = Token::ASM;
  my_keywords["__asm"] = Token::ASM;
  my_keywords["_inline"] = Token::INLINE;
  my_keywords["__inline"] = Token::INLINE;
  my_keywords["_stdcall"] = Token::Ignore;
  my_keywords["__stdcall"] = Token::Ignore;
  my_keywords["__declspec"] = Token::DECLSPEC;
  my_keywords["__int8"] = Token::CHAR;
  my_keywords["__int16"] = Token::SHORT;
  my_keywords["__int32"] = Token::INT;
  my_keywords["__int64"] = Token::INT64;
#endif
  my_keywords["asm"] = Token::ATTRIBUTE;
  my_keywords["auto"] = Token::AUTO;
  my_keywords["bool"] = Token::BOOLEAN;
  my_keywords["break"] = Token::BREAK;
  my_keywords["case"] = Token::CASE;
  my_keywords["catch"] = Token::CATCH;
  my_keywords["char"] = Token::CHAR;
  my_keywords["class"] = Token::CLASS;
  my_keywords["const"] = Token::CONST;
  { "const_cast",       RID_CONSTCAST,  0 },
  my_keywords["continue"] = Token::CONTINUE;
  my_keywords["default"] = Token::DEFAULT;
  my_keywords["delete"] = Token::DELETE;
  my_keywords["do"] = Token::DO;
  my_keywords["double"] = Token::DOUBLE;
  { "dynamic_cast",     RID_DYNCAST,    0 },
  my_keywords["else"] = Token::ELSE;
  my_keywords["enum"] = Token::ENUM;
lex.c:  { "explicit",           RID_EXPLICIT,   0 },
  { "export",           RID_EXPORT,     0 },
  my_keywords["extern"] = Token::EXTERN;
  { "false",            RID_FALSE,      0 },
  my_keywords["float"] = Token::FLOAT;
  my_keywords["for"] = Token::FOR;
  my_keywords["friend"] = Token::FRIEND;
  my_keywords["goto"] = Token::GOTO;
  my_keywords["if"] = Token::IF;
  my_keywords["inline"] = Token::INLINE;
  my_keywords["int"] = Token::INT;
  my_keywords["long"] = Token::LONG;
  my_keywords["mutable"] = Token::MUTABLE;
  my_keywords["namespace"] = Token::NAMESPACE;
  my_keywords["new"] = Token::NEW;
  my_keywords["operator"] = Token::OPERATOR;
  my_keywords["private"] = Token::PRIVATE;
  my_keywords["protected"] = Token::PROTECTED;
  my_keywords["public"] = Token::PUBLIC;
  my_keywords["register"] = Token::REGISTER;
  { "restrict",         RID_RESTRICT,   D_C89 }, in C not C++ ??
  { "reinterpret_cast", RID_REINTCAST,  0 },
  my_keywords["return"] = Token::RETURN;
  my_keywords["short"] = Token::SHORT;
  my_keywords["signed"] = Token::SIGNED;
  my_keywords["sizeof"] = Token::SIZEOF;
  my_keywords["static"] = Token::STATIC;
  { "static_cast",      RID_STATCAST,   0 },
  my_keywords["struct"] = Token::STRUCT;
  my_keywords["switch"] = Token::SWITCH;
  my_keywords["template"] = Token::TEMPLATE;
  my_keywords["this"] = Token::THIS;
  my_keywords["throw"] = Token::THROW;
  { "true",             RID_TRUE,       0 },
  my_keywords["try"] = Token::TRY;
  my_keywords["typedef"] = Token::TYPEDEF;
  my_keywords["typeid"] = Token::TYPEID;
  my_keywords["typename"] = Token::CLASS; // FIXME !!
  { "typeof",           RID_TYPEOF,     D_EXT },
  my_keywords["union"] = Token::UNION;
  my_keywords["unsigned"] = Token::UNSIGNED;
  my_keywords["using"] = Token::USING;
  my_keywords["virtual"] = Token::VIRTUAL;
  my_keywords["void"] = Token::VOID;
  my_keywords["volatile"] = Token::VOLATILE;
  my_keywords["wchar_t"] = Token::WCHAR;
  my_keywords["while"] = Token::WHILE;