FPC关键字

 

先看下词法分析所有命令字.
       (str:''              ;special:true ;keyword:m_none;op:NOTOKEN),            
    { Operators which can be overloaded }    以下这些操作符可以被重载
      (str:'+'             ;special:true ;keyword:m_none;op:NOTOKEN),           _PLUS,  加

      (str:'-'             ;special:true ;keyword:m_none;op:NOTOKEN),           _MINUS,    减

      (str:'*'             ;special:true ;keyword:m_none;op:NOTOKEN),           _STAR,    乘

      (str:'/'             ;special:true ;keyword:m_none;op:NOTOKEN),           _SLASH, 除

      (str:'='             ;special:true ;keyword:m_none;op:NOTOKEN),           _EQ,    等

      (str:'>'             ;special:true ;keyword:m_none;op:NOTOKEN),           _GT,    大于

      (str:'<'             ;special:true ;keyword:m_none;op:NOTOKEN),           _LT,    小于

      (str:'>='            ;special:true ;keyword:m_none;op:NOTOKEN),           _GTE,    大于等于

      (str:'<='            ;special:true ;keyword:m_none;op:NOTOKEN),           _LTE,    小于等于

      (str:'<>'            ;special:true ;keyword:m_none;op:NOTOKEN),           _NE,    不等于

      (str:'><'            ;special:true ;keyword:m_none;op:NOTOKEN),           _SYMDIF,    集合并集    

      (str:'**'            ;special:true ;keyword:m_none;op:NOTOKEN),           _STARSTAR,    幂

      (str:'as'            ;special:true ;keyword:m_none;op:NOTOKEN),           _OP_AS,        as
      (str:'in'            ;special:true ;keyword:m_none;op:NOTOKEN),           _OP_IN,        in
      (str:'is'            ;special:true ;keyword:m_none;op:NOTOKEN),           _OP_IS,        is
      (str:'or'            ;special:true ;keyword:m_none;op:NOTOKEN),           _OP_OR,        os
      (str:'and'           ;special:true ;keyword:m_none;op:NOTOKEN),           _OP_AND,    and     
      (str:'div'           ;special:true ;keyword:m_none;op:NOTOKEN),           _OP_DIV,    div
      (str:'mod'           ;special:true ;keyword:m_none;op:NOTOKEN),           _OP_MOD,    mod    
      (str:'not'           ;special:true ;keyword:m_none;op:NOTOKEN),           _OP_NOT,    not
      (str:'shl'           ;special:true ;keyword:m_none;op:NOTOKEN),           _OP_SHL,    shl
      (str:'shr'           ;special:true ;keyword:m_none;op:NOTOKEN),           _OP_SHR,    shr
      (str:'xor'           ;special:true ;keyword:m_none;op:NOTOKEN),           _OP_XOR,    xor
      (str:':='            ;special:true ;keyword:m_none;op:NOTOKEN),           _ASSIGNMENT,    赋值
      (str:'explicit'      ;special:true ;keyword:m_none;op:NOTOKEN),           _OP_EXPLICIT,    显式
      (str:'enumerator'    ;special:true ;keyword:m_none;op:NOTOKEN),           _OP_ENUMERATOR,    枚举
      (str:'inc'           ;special:true ;keyword:m_none;op:NOTOKEN),           _OP_INC,    累加
      (str:'dec'           ;special:true ;keyword:m_none;op:NOTOKEN),           _OP_DEC,    累减

    { Special chars }特定命令字
      (str:'^'             ;special:true ;keyword:m_none;op:NOTOKEN),           _CARET,        异或

      (str:'['             ;special:true ;keyword:m_none;op:NOTOKEN),           _LECKKLAMMER,    左方括号

      (str:']'             ;special:true ;keyword:m_none;op:NOTOKEN),           _RECKKLAMMER,    右方括号

      (str:'.'             ;special:true ;keyword:m_none;op:NOTOKEN),           _POINT,        点

      (str:','             ;special:true ;keyword:m_none;op:NOTOKEN),           _COMMA,        逗号

      (str:'('             ;special:true ;keyword:m_none;op:NOTOKEN),           _LKLAMMER,    左括号

      (str:')'             ;special:true ;keyword:m_none;op:NOTOKEN),           _RKLAMMER,    右括号

      (str:':'             ;special:true ;keyword:m_none;op:NOTOKEN),           _COLON,        冒号

      (str:';'             ;special:true ;keyword:m_none;op:NOTOKEN),           _SEMICOLON,    分号

      (str:'@'             ;special:true ;keyword:m_none;op:NOTOKEN),           _KLAMMERAFFE,    at号

      (str:'..'            ;special:true ;keyword:m_none;op:NOTOKEN),           _POINTPOINT,    双点号

      (str:'...'           ;special:true ;keyword:m_none;op:NOTOKEN),           _POINTPOINTPOINT,    三点号

      (str:'|'             ;special:true ;keyword:m_none;op:NOTOKEN),           _PIPE,        或
    
      (str:'&'             ;special:true ;keyword:m_none;op:NOTOKEN),           _AMPERSAND,    且

      (str:'end of file'   ;special:true ;keyword:m_none;op:NOTOKEN),           _EOF,    文件结束
      (str:'identifier'    ;special:true ;keyword:m_none;op:NOTOKEN),           _ID,    ID
      (str:'non identifier';special:true ;keyword:m_none;op:NOTOKEN),           _NOID,    nodeID
      (str:'const real'    ;special:true ;keyword:m_none;op:NOTOKEN),           _REALNUMBER,    浮点常量
      (str:'ordinal const' ;special:true ;keyword:m_none;op:NOTOKEN),           _INTCONST,    整形常量
      (str:'const string'  ;special:true ;keyword:m_none;op:NOTOKEN),           _CSTRING,    字符串常量
      (str:'const char'    ;special:true ;keyword:m_none;op:NOTOKEN),           _CCHAR,        字符常量
      (str:'const wstring' ;special:true ;keyword:m_none;op:NOTOKEN),           _CWSTRING,    宽字符串常量
      (str:'const wchar'   ;special:true ;keyword:m_none;op:NOTOKEN),           _CWCHAR,    宽字符常量
      (str:'<'             ;special:true ;keyword:m_none;op:NOTOKEN),           _LSHARPBRACKET,    左尖括号
      (str:'>'             ;special:true ;keyword:m_none;op:NOTOKEN),           _RSHARPBRACKET,    右尖括号


    { C like operators }
      (str:'+='            ;special:true ;keyword:m_none;op:NOTOKEN),           _PLUSASN,    加等于
      (str:'-='            ;special:true ;keyword:m_none;op:NOTOKEN),           _MINUSASN,    减等于
      (str:'&='            ;special:true ;keyword:m_none;op:NOTOKEN),           _ANDASN,    且等于
      (str:'|='            ;special:true ;keyword:m_none;op:NOTOKEN),           _ORASN,        或等于
      (str:'*='            ;special:true ;keyword:m_none;op:NOTOKEN),           _STARASN,    乘等于
      (str:'/='            ;special:true ;keyword:m_none;op:NOTOKEN),           _SLASHASN,    除等于

      (str:''              ;special:true ;keyword:m_none;op:NOTOKEN),           _MODASN,    
      (str:''              ;special:true ;keyword:m_none;op:NOTOKEN),           _DIVASN,    
      (str:''              ;special:true ;keyword:m_none;op:NOTOKEN),           _NOTASN,    
      (str:''              ;special:true ;keyword:m_none;op:NOTOKEN),           _XORASN,
      (str:'gen. spec.'    ;special:true ;keyword:m_none;op:NOTOKEN),           _GENERICSPECIALTOKEN,




    { Normal words -- ATTENTION: These words must be sorted: }    保留字，这些保留字必须要被存储
    { first in length order, then in alphabetical order.     }        以下这保留字，被存储在一个二维数组中，长度及开头字符为下标，必须遵行长度小的在前面相同开头字符在一起
      (str:'C'             ;special:false;keyword:m_none;op:NOTOKEN),                                                           _C,    
      (str:'AS'            ;special:false;keyword:m_class;op:_OP_AS),                                                           _AS,    
      (str:'AT'            ;special:false;keyword:m_none;op:NOTOKEN),                                                           _AT,
      (str:'DO'            ;special:false;keyword:m_all;op:NOTOKEN),                                                            _DO,
      (str:'IF'            ;special:false;keyword:m_all;op:NOTOKEN),                                                            _IF,
      (str:'IN'            ;special:false;keyword:m_all;op:_OP_IN),                                                             _IN,
      (str:'IS'            ;special:false;keyword:m_class;op:_OP_IS),                                                           _IS,
      (str:'OF'            ;special:false;keyword:m_all;op:NOTOKEN),                                                            _OF,
      (str:'ON'            ;special:false;keyword:m_none;op:NOTOKEN),                                                           _ON,
      (str:'OR'            ;special:false;keyword:m_all;op:_OP_OR),                                                             _OR,
      (str:'TO'            ;special:false;keyword:m_all;op:NOTOKEN),                                                            _TO,
      (str:'ADD'           ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _ADD,
      (str:'AND'           ;special:false;keyword:m_all;op:_OP_AND),                                                            _AND,
      (str:'ASM'           ;special:false;keyword:m_all;op:NOTOKEN),                                                            _ASM,
      (str:'DEC'           ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _DEC,
      (str:'DIV'           ;special:false;keyword:m_all;op:_OP_DIV),                                                            _DIV,
      (str:'END'           ;special:false;keyword:m_all;op:NOTOKEN),                                                            _END,
      (str:'FAR'           ;special:false;keyword:m_none;op:NOTOKEN),                                                           _FAR,
      (str:'FOR'           ;special:false;keyword:m_all;op:NOTOKEN),                                                            _FOR,
      (str:'INC'           ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _INC,
      (str:'MOD'           ;special:false;keyword:m_all;op:_OP_MOD),                                                            _MOD,
      (str:'NIL'           ;special:false;keyword:m_all;op:NOTOKEN),                                                            _NIL,
      (str:'NOT'           ;special:false;keyword:m_all;op:_OP_NOT),                                                            _NOT,
      (str:'OUT'           ;special:false;keyword:m_none;op:NOTOKEN),                                                           _OUT,
      (str:'SET'           ;special:false;keyword:m_all;op:NOTOKEN),                                                            _SET,
      (str:'SHL'           ;special:false;keyword:m_all;op:_OP_SHL),                                                            _SHL,
      (str:'SHR'           ;special:false;keyword:m_all;op:_OP_SHR),                                                            _SHR,
      (str:'TRY'           ;special:false;keyword:m_except;op:NOTOKEN),                                                         _TRY,
      (str:'VAR'           ;special:false;keyword:m_all;op:NOTOKEN),                                                            _VAR,
      (str:'XOR'           ;special:false;keyword:m_all;op:_OP_XOR),                                                            _XOR,
      (str:'CASE'          ;special:false;keyword:m_all;op:NOTOKEN),                                                            _CASE,
      (str:'CVAR'          ;special:false;keyword:m_none;op:NOTOKEN),                                                           _CVAR,
      (str:'ELSE'          ;special:false;keyword:m_all;op:NOTOKEN),                                                            _ELSE,
      (str:'EXIT'          ;special:false;keyword:m_none;op:NOTOKEN),                                                           _EXIT,
      (str:'FAIL'          ;special:false;keyword:m_none;op:NOTOKEN), { only set within constructors PM }                       _FAIL,
      (str:'FILE'          ;special:false;keyword:m_all;op:NOTOKEN),                                                            _FILE,
      (str:'GOTO'          ;special:false;keyword:m_all;op:NOTOKEN),                                                            _GOTO,
      (str:'NAME'          ;special:false;keyword:m_none;op:NOTOKEN),                                                           _NAME,
      (str:'NEAR'          ;special:false;keyword:m_none;op:NOTOKEN),                                                           _NEAR,
      (str:'READ'          ;special:false;keyword:m_none;op:NOTOKEN),                                                           _READ,
      (str:'SELF'          ;special:false;keyword:m_none;op:NOTOKEN), {set inside methods only PM }                             _SELF,
      (str:'SYSV'          ;special:false;keyword:m_none;op:NOTOKEN),   { Syscall variation on MorphOS }                        _SYSV,
      (str:'THEN'          ;special:false;keyword:m_all;op:NOTOKEN),                                                            _THEN,
      (str:'TRUE'          ;special:false;keyword:m_all;op:NOTOKEN),                                                            _TRUE,
      (str:'TYPE'          ;special:false;keyword:m_all;op:NOTOKEN),                                                            _TYPE,
      (str:'UNIT'          ;special:false;keyword:m_all;op:NOTOKEN),                                                            _UNIT,
      (str:'UNIV'          ;special:false;keyword:m_mac;op:NOTOKEN),                                                            _UNIV,
      (str:'USES'          ;special:false;keyword:m_all;op:NOTOKEN),                                                            _USES,
      (str:'WITH'          ;special:false;keyword:m_all;op:NOTOKEN),                                                            _WITH,
      (str:'ALIAS'         ;special:false;keyword:m_none;op:NOTOKEN),                                                           _ALIAS,
      (str:'ARRAY'         ;special:false;keyword:m_all;op:NOTOKEN),                                                            _ARRAY,
      (str:'BEGIN'         ;special:false;keyword:m_all;op:NOTOKEN),                                                            _BEGIN,
      (str:'BREAK'         ;special:false;keyword:m_none;op:NOTOKEN),                                                           _BREAK,
      (str:'CDECL'         ;special:false;keyword:m_none;op:NOTOKEN),                                                           _CDECL,
      (str:'CLASS'         ;special:false;keyword:m_class;op:NOTOKEN),                                                          _CLASS,
      (str:'CONST'         ;special:false;keyword:m_all;op:NOTOKEN),                                                            _CONST,
      (str:'EQUAL'         ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _EQUAL,
      (str:'FALSE'         ;special:false;keyword:m_all;op:NOTOKEN),                                                            _FALSE,
      (str:'FAR16'         ;special:false;keyword:m_none;op:NOTOKEN),                                                           _FAR16,
      (str:'FINAL'         ;special:false;keyword:m_none;op:NOTOKEN),                                                           _FINAL,
      (str:'INDEX'         ;special:false;keyword:m_none;op:NOTOKEN),                                                           _INDEX,
      (str:'LABEL'         ;special:false;keyword:m_all;op:NOTOKEN),                                                            _LABEL,
      (str:'LOCAL'         ;special:false;keyword:m_none;op:NOTOKEN),                                                           _LOCAL,
      (str:'RAISE'         ;special:false;keyword:m_except;op:NOTOKEN),                                                         _RAISE,
      (str:'UNTIL'         ;special:false;keyword:m_all;op:NOTOKEN),                                                            _UNTIL,
      (str:'WHILE'         ;special:false;keyword:m_all;op:NOTOKEN),                                                            _WHILE,
      (str:'WRITE'         ;special:false;keyword:m_none;op:NOTOKEN),                                                           _WRITE,
      (str:'DISPID'        ;special:false;keyword:m_none;op:NOTOKEN),                                                           _DISPID,
      (str:'DIVIDE'        ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _DIVIDE,
      (str:'DOWNTO'        ;special:false;keyword:m_all;op:NOTOKEN),                                                            _DOWNTO,
      (str:'EXCEPT'        ;special:false;keyword:m_except;op:NOTOKEN),                                                         _EXCEPT,
      (str:'EXPORT'        ;special:false;keyword:m_none;op:NOTOKEN),                                                           _EXPORT,
      (str:'HELPER'        ;special:false;keyword:m_none;op:NOTOKEN),                                                           _HELPER,
      (str:'INLINE'        ;special:false;keyword:m_none;op:NOTOKEN),                                                           _INLINE,
      (str:'LEGACY'        ;special:false;keyword:m_none;op:NOTOKEN),   { Syscall variation on MorphOS }                        _LEGACY,
      (str:'NESTED'        ;special:false;keyword:m_none;op:NOTOKEN),                                                           _NESTED,
      (str:'OBJECT'        ;special:false;keyword:m_all;op:NOTOKEN),                                                            _OBJECT,
      (str:'PACKED'        ;special:false;keyword:m_all;op:NOTOKEN),                                                            _PACKED,
      (str:'PASCAL'        ;special:false;keyword:m_none;op:NOTOKEN),                                                           _PASCAL,
      (str:'PUBLIC'        ;special:false;keyword:m_none;op:NOTOKEN),                                                           _PUBLIC,
      (str:'RECORD'        ;special:false;keyword:m_all;op:NOTOKEN),                                                            _RECORD,
      (str:'REPEAT'        ;special:false;keyword:m_all;op:NOTOKEN),                                                            _REPEAT,
      (str:'RESULT'        ;special:false;keyword:m_none;op:NOTOKEN),                                                           _RESULT,
      (str:'RETURN'        ;special:false;keyword:m_mac;op:NOTOKEN),                                                            _RETURN,
      (str:'SEALED'        ;special:false;keyword:m_none;op:NOTOKEN),                                                           _SEALED,
      (str:'STATIC'        ;special:false;keyword:m_none;op:NOTOKEN),                                                           _STATIC,
      (str:'STORED'        ;special:false;keyword:m_none;op:NOTOKEN),                                                           _STORED,
      (str:'STRICT'        ;special:false;keyword:m_none;op:NOTOKEN),                                                           _STRICT,
      (str:'STRING'        ;special:false;keyword:m_all;op:NOTOKEN),                                                            _STRING,
      (str:'SYSTEM'        ;special:false;keyword:m_none;op:NOTOKEN),                                                           _SYSTEM,
      (str:'ASMNAME'       ;special:false;keyword:m_none;op:NOTOKEN),                                                           _ASMNAME,
      (str:'CPPDECL'       ;special:false;keyword:m_none;op:NOTOKEN),                                                           _CPPDECL,
      (str:'DEFAULT'       ;special:false;keyword:m_none;op:NOTOKEN),                                                           _DEFAULT,
      (str:'DYNAMIC'       ;special:false;keyword:m_none;op:NOTOKEN),                                                           _DYNAMIC,
      (str:'EXPORTS'       ;special:false;keyword:m_all;op:NOTOKEN),                                                            _EXPORTS,
      (str:'FINALLY'       ;special:false;keyword:m_except;op:NOTOKEN),                                                         _FINALLY,
      (str:'FORWARD'       ;special:false;keyword:m_none;op:NOTOKEN),                                                           _FORWARD,
      (str:'GENERIC'       ;special:false;keyword:m_none;op:NOTOKEN),                                                           _GENERIC,
      (str:'IOCHECK'       ;special:false;keyword:m_none;op:NOTOKEN),                                                           _IOCHECK,
      (str:'LIBRARY'       ;special:false;keyword:m_all;op:NOTOKEN),                                                            _LIBRARY,
      (str:'MESSAGE'       ;special:false;keyword:m_none;op:NOTOKEN),                                                           _MESSAGE,
      (str:'MODULUS'       ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _MODULUS,
      (str:'PACKAGE'       ;special:false;keyword:m_none;op:NOTOKEN),                                                           _PACKAGE,
      (str:'PRIVATE'       ;special:false;keyword:m_none;op:NOTOKEN),                                                           _PRIVATE,
      (str:'PROGRAM'       ;special:false;keyword:m_all;op:NOTOKEN),                                                            _PROGRAM,
      (str:'R12BASE'       ;special:false;keyword:m_none;op:NOTOKEN),   { Syscall variation on MorphOS }                        _R12BASE,
      (str:'SECTION'       ;special:false;keyword:m_none;op:NOTOKEN),                                                           _SECTION,
      (str:'STDCALL'       ;special:false;keyword:m_none;op:NOTOKEN),                                                           _STDCALL,
      (str:'SYSCALL'       ;special:false;keyword:m_none;op:NOTOKEN),                                                           _SYSCALL,
      (str:'VARARGS'       ;special:false;keyword:m_none;op:NOTOKEN),                                                           _VARARGS,
      (str:'VIRTUAL'       ;special:false;keyword:m_none;op:NOTOKEN),                                                           _VIRTUAL,
      (str:'ABSOLUTE'      ;special:false;keyword:m_none;op:NOTOKEN),                                                           _ABSOLUTE,
      (str:'ABSTRACT'      ;special:false;keyword:m_none;op:NOTOKEN),                                                           _ABSTRACT,
      (str:'BASESYSV'      ;special:false;keyword:m_none;op:NOTOKEN),   { Syscall variation on MorphOS }                        _BASESYSV,
      (str:'CONSTREF'      ;special:false;keyword:m_none;op:NOTOKEN),                                                           _CONSTREF,
      (str:'CONTAINS'      ;special:false;keyword:m_none;op:NOTOKEN),                                                           _CONTAINS,
      (str:'CONTINUE'      ;special:false;keyword:m_none;op:NOTOKEN),                                                           _CONTINUE,
      (str:'CPPCLASS'      ;special:false;keyword:m_fpc;op:NOTOKEN),                                                            _CPPCLASS,
      (str:'EXPLICIT'      ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _EXPLICIT,
      (str:'EXTERNAL'      ;special:false;keyword:m_none;op:NOTOKEN),                                                           _EXTERNAL,
      (str:'FUNCTION'      ;special:false;keyword:m_all;op:NOTOKEN),                                                            _FUNCTION,
      (str:'IMPLICIT'      ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _IMPLICIT,
      (str:'LESSTHAN'      ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _LESSTHAN,
      (str:'LOCATION'      ;special:false;keyword:m_none;op:NOTOKEN),                                                           _LOCATION,
      (str:'MULTIPLY'      ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _MULTIPLY,
      (str:'MWPASCAL'      ;special:false;keyword:m_none;op:NOTOKEN),                                                           _MWPASCAL,
      (str:'NEGATIVE'      ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _NEGATIVE,
      (str:'NOTEQUAL'      ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _NOTEQUAL,
      (str:'OPERATOR'      ;special:false;keyword:m_fpc;op:NOTOKEN),                                                            _OPERATOR,
      (str:'OPTIONAL'      ;special:false;keyword:m_none;op:NOTOKEN), { optional methods in an Objective-C protocol }           _OPTIONAL,
      (str:'OVERLOAD'      ;special:false;keyword:m_none;op:NOTOKEN),                                                           _OVERLOAD,
      (str:'OVERRIDE'      ;special:false;keyword:m_none;op:NOTOKEN),                                                           _OVERRIDE,
      (str:'PLATFORM'      ;special:false;keyword:m_none;op:NOTOKEN),                                                           _PLATFORM,
      (str:'POSITIVE'      ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _POSITIVE,
      (str:'PROPERTY'      ;special:false;keyword:m_property;op:NOTOKEN),                                                       _PROPERTY,
      (str:'READONLY'      ;special:false;keyword:m_none;op:NOTOKEN),                                                           _READONLY,
      (str:'REGISTER'      ;special:false;keyword:m_none;op:NOTOKEN),                                                           _REGISTER,
      (str:'REQUIRED'      ;special:false;keyword:m_none;op:NOTOKEN), { required methods in an Objective-C protocol }           _REQUIRED,
      (str:'REQUIRES'      ;special:false;keyword:m_none;op:NOTOKEN),                                                           _REQUIRES,
      (str:'RESIDENT'      ;special:false;keyword:m_none;op:NOTOKEN),                                                           _RESIDENT,
      (str:'SAFECALL'      ;special:false;keyword:m_none;op:NOTOKEN),                                                           _SAFECALL,
      (str:'SUBTRACT'      ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _SUBTRACT,
      (str:'SYSVBASE'      ;special:false;keyword:m_none;op:NOTOKEN),   { Syscall variation on MorphOS }                        _SYSVBASE,
      (str:'ASSEMBLER'     ;special:false;keyword:m_none;op:NOTOKEN),                                                           _ASSEMBLER,
      (str:'BITPACKED'     ;special:false;keyword:m_all;op:NOTOKEN),                                                            _BITPACKED,
      (str:'BITWISEOR'     ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _BITWISEOR,
      (str:'INHERITED'     ;special:false;keyword:m_all;op:NOTOKEN),                                                            _INHERITED,
      (str:'INTDIVIDE'     ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _INTDIVIDE,
      (str:'INTERFACE'     ;special:false;keyword:m_all;op:NOTOKEN),                                                            _INTERFACE,
      (str:'INTERRUPT'     ;special:false;keyword:m_none;op:NOTOKEN),                                                           _INTERRUPT,
      (str:'LEFTSHIFT'     ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _LEFTSHIFT,
      (str:'LOGICALOR'     ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _LOGICALOR,
      (str:'NODEFAULT'     ;special:false;keyword:m_none;op:NOTOKEN),                                                           _NODEFAULT,
      (str:'OBJCCLASS'     ;special:false;keyword:m_objectivec1;op:NOTOKEN),                                                    _OBJCCLASS,
      (str:'OTHERWISE'     ;special:false;keyword:m_all;op:NOTOKEN),                                                            _OTHERWISE,
      (str:'PROCEDURE'     ;special:false;keyword:m_all;op:NOTOKEN),                                                            _PROCEDURE,
      (str:'PROTECTED'     ;special:false;keyword:m_none;op:NOTOKEN),                                                           _PROTECTED,
      (str:'PUBLISHED'     ;special:false;keyword:m_none;op:NOTOKEN),                                                           _PUBLISHED,
      (str:'SOFTFLOAT'     ;special:false;keyword:m_none;op:NOTOKEN),                                                           _SOFTFLOAT,
      (str:'THREADVAR'     ;special:false;keyword:m_all;op:NOTOKEN),                                                            _THREADVAR,
      (str:'WRITEONLY'     ;special:false;keyword:m_none;op:NOTOKEN),                                                           _WRITEONLY,
      (str:'BITWISEAND'    ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _BITWISEAND,
      (str:'BITWISEXOR'    ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _BITWISEXOR,
      (str:'DEPRECATED'    ;special:false;keyword:m_none;op:NOTOKEN),                                                           _DEPRECATED,
      (str:'DESTRUCTOR'    ;special:false;keyword:m_all;op:NOTOKEN),                                                            _DESTRUCTOR,
      (str:'ENUMERATOR'    ;special:false;keyword:m_none;op:_OP_ENUMERATOR),                                                    _ENUMERATOR,
      (str:'IMPLEMENTS'    ;special:false;keyword:m_none;op:NOTOKEN),                                                           _IMPLEMENTS,
      (str:'INTERNPROC'    ;special:false;keyword:m_none;op:NOTOKEN),                                                           _INTERNPROC,
      (str:'LOGICALAND'    ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _LOGICALAND,
      (str:'LOGICALNOT'    ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _LOGICALNOT,
      (str:'LOGICALXOR'    ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _LOGICALXOR,
      (str:'OLDFPCCALL'    ;special:false;keyword:m_none;op:NOTOKEN),                                                           _OLDFPCCALL,
      (str:'OPENSTRING'    ;special:false;keyword:m_none;op:NOTOKEN),                                                           _OPENSTRING,
      (str:'RIGHTSHIFT'    ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _RIGHTSHIFT,
      (str:'SPECIALIZE'    ;special:false;keyword:m_none;op:NOTOKEN),                                                           _SPECIALIZE,
      (str:'CONSTRUCTOR'   ;special:false;keyword:m_all;op:NOTOKEN),                                                            _CONSTRUCTOR,
      (str:'GREATERTHAN'   ;special:false;keyword:m_none;op:NOTOKEN), { delphi operator name }                                  _GREATERTHAN,
      (str:'INTERNCONST'   ;special:false;keyword:m_none;op:NOTOKEN),                                                           _INTERNCONST,
      (str:'REINTRODUCE'   ;special:false;keyword:m_none;op:NOTOKEN),                                                           _REINTRODUCE,
      (str:'SHORTSTRING'   ;special:false;keyword:m_none;op:NOTOKEN),                                                           _SHORTSTRING,
      (str:'COMPILERPROC'  ;special:false;keyword:m_none;op:NOTOKEN),                                                           _COMPILERPROC,
      (str:'EXPERIMENTAL'  ;special:false;keyword:m_none;op:NOTOKEN),                                                           _EXPERIMENTAL,
      (str:'FINALIZATION'  ;special:false;keyword:m_initfinal;op:NOTOKEN),                                                      _FINALIZATION,
      (str:'NOSTACKFRAME'  ;special:false;keyword:m_none;op:NOTOKEN),                                                           _NOSTACKFRAME,
      (str:'OBJCCATEGORY'  ;special:false;keyword:m_objectivec1;op:NOTOKEN), { Objective-C category }                           _OBJCCATEGORY,
      (str:'OBJCPROTOCOL'  ;special:false;keyword:m_objectivec1;op:NOTOKEN), { Objective-C protocol }                           _OBJCPROTOCOL,
      (str:'WEAKEXTERNAL'  ;special:false;keyword:m_none;op:NOTOKEN),                                                           _WEAKEXTERNAL,
      (str:'DISPINTERFACE' ;special:false;keyword:m_class;op:NOTOKEN),                                                          _DISPINTERFACE,
      (str:'UNIMPLEMENTED' ;special:false;keyword:m_none;op:NOTOKEN),                                                           _UNIMPLEMENTED,
      (str:'IMPLEMENTATION';special:false;keyword:m_all;op:NOTOKEN),                                                            _IMPLEMENTATION,
      (str:'INITIALIZATION';special:false;keyword:m_initfinal;op:NOTOKEN),                                                      _INITIALIZATION,
      (str:'RESOURCESTRING';special:false;keyword:m_all;op:NOTOKEN),                                                            _RESOURCESTRING,
      (str:'LESSTHANOREQUAL';special:false;keyword:m_none;op:NOTOKEN),    { delphi operator name }                              _LESSTHANOREQUAL,
      (str:'GREATERTHANOREQUAL';special:false;keyword:m_none;op:NOTOKEN)  { delphi operator name }                              _GREATERTHANOREQUAL


关键字判定函数
    function is_keyword(const s:string):boolean;
      var
        low,high,mid : longint;
      begin
        if not (length(s) in [tokenlenmin..tokenlenmax]) or    
           not (s[1] in ['a'..'z','A'..'Z']) then
         begin
           is_keyword:=false;
           exit;
         end;
        low:=ord(tokenidx^[length(s),s[1]].first);
        high:=ord(tokenidx^[length(s),s[1]].last);
        while low<high do
         begin
           mid:=(high+low+1) shr 1;
           if pattern<tokeninfo^[ttoken(mid)].str then
            high:=mid-1
           else
            low:=mid;
         end;
        is_keyword:=(pattern=tokeninfo^[ttoken(high)].str) and    
                    (tokeninfo^[ttoken(high)].keyword in current_settings.modeswitches);
      end;
不光要字符串匹配，还要保证模式开关有开。所以开关为m_none可以作为保留字，也可以作为变量，m_all永远不能作为变量，当然也不能被定义宏.
还要注意关键字在二维数组里，ReadToken时就会从这个数组二分查找是否为关键字.